/*
 * Copyright 2010 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.editor.rebind.model;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JClassType;
import com.google.gwt.core.ext.typeinfo.JField;
import com.google.gwt.core.ext.typeinfo.JGenericType;
import com.google.gwt.core.ext.typeinfo.JMethod;
import com.google.gwt.core.ext.typeinfo.JParameterizedType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.editor.client.CompositeEditor;
import com.google.gwt.editor.client.Editor;
import com.google.gwt.editor.client.IsEditor;
import com.google.gwt.editor.client.LeafValueEditor;
import com.google.web.bindery.autobean.gwt.rebind.model.JBeanMethod;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

/**
 * Analyzes an Editor driver declaration.
 */
public class EditorModel {
  private static final EditorData[] EMPTY_EDITOR_DATA = new EditorData[0];

  /**
   * Given type assignable to <code>ComposedEditor&lt;Foo,Bar></code>, return
   * <code>{Foo, Bar}</code>. It is an error to call this method with a type not
   * assignable to {@link ComposedEditor}.
   */
  static JClassType[] calculateCompositeTypes(JClassType editorType) {
    JClassType compositeEditorIntf = editorType.getOracle().findType(
        CompositeEditor.class.getName());
    assert compositeEditorIntf.isAssignableFrom(editorType) : editorType.getQualifiedSourceName()
        + " is not a ComposedEditor";

    for (JClassType supertype : editorType.getFlattenedSupertypeHierarchy()) {
      JParameterizedType parameterized = supertype.isParameterized();
      if (parameterized != null) {
        // Found the Editor<Foo> supertype
        if (compositeEditorIntf.equals(parameterized.getBaseType())) {
          JClassType[] typeArgs = parameterized.getTypeArgs();
          assert typeArgs.length == 3;
          return new JClassType[] {typeArgs[1], typeArgs[2]};
        }
      }
    }
    assert false : "Did not find ComposedEditor parameterization for "
        + editorType.getQualifiedSourceName();
    throw new RuntimeException();
  }

  /**
   * Given type assignable to <code>Editor&lt;Foo></code>, return
   * <code>Foo</code>. It is an error to call this method with a type not
   * assignable to {@link Editor}.
   */
  static JClassType calculateEditedType(TreeLogger logger, JClassType editorType)
      throws UnableToCompleteException {
    JClassType editorIntf = editorType.getOracle().findType(
        Editor.class.getName());
    JClassType parameterization[] = ModelUtils.findParameterizationOf(
        editorIntf, editorType);
    if (parameterization != null) {
      return parameterization[0];
    }
    logger.log(TreeLogger.ERROR,
        noEditorParameterizationMessage(editorIntf, editorType));
    throw new UnableToCompleteException();
  }

  /**
   * Given type assignable to <code>IsEditor&lt;Foo, FooEditor></code>, return
   * <code>FooEditor</code>. It is an error to call this method with a type not
   * assignable to {@link IsEditor}.
   */
  static JClassType calculateIsEditedType(TreeLogger logger,
      JClassType editorType) throws UnableToCompleteException {
    JClassType editorIntf = editorType.getOracle().findType(
        IsEditor.class.getName());
    JClassType[] parameterization = ModelUtils.findParameterizationOf(
        editorIntf, editorType);
    if (parameterization != null) {
      return parameterization[0];
    }
    logger.log(TreeLogger.ERROR,
        noEditorParameterizationMessage(editorIntf, editorType));
    throw new UnableToCompleteException();
  }

  static String cycleErrorMessage(JType editorType, String originalPath,
      String errorPath) {
    return String.format(
        "Cycle detected in editor graph. Editor type %s at path %s can"
            + " be reached again at path %s",
        editorType.getQualifiedSourceName(), originalPath, errorPath);
  }

  static String foundPrimitiveMessage(JType type, String getterExpression,
      String path) {
    return String.format("Found unexpected type %s while evauating path"
        + " \"%s\" using getter expression \"%s\"",
        type.getQualifiedSourceName(), path, getterExpression);
  }

  static String mustExtendMessage(JType driverType) {
    return String.format(
        "You must declare an interface that extends the %s type",
        driverType.getSimpleSourceName());
  }

  static String noEditorParameterizationMessage(JClassType editorIntf,
      JClassType type) {
    return String.format("The type %s is assignable to the raw %s type, but"
        + " a type parameterization is required.",
        type.getParameterizedQualifiedSourceName(), editorIntf.getName());
  }

  static String noGetterMessage(String propertyName, JType proxyType) {
    return String.format(
        "Could not find a getter for path %s in proxy type %s", propertyName,
        proxyType.getQualifiedSourceName());
  }

  static String poisonedMessage() {
    return "Unable to create Editor model due to previous errors";
  }

  static String tooManyInterfacesMessage(JType intf) {
    return String.format("The type %s extends more than one interface",
        intf.getQualifiedSourceName());
  }

  static String unexpectedInputTypeMessage(JType driverType, JType intf) {
    return String.format("Unexpected input type: %s is not assignable from %s",
        driverType.getQualifiedSourceName(), intf.getQualifiedSourceName());
  }

  private final JGenericType compositeEditorIntf;

  /**
   * The structural model.
   */
  private final EditorData[] editorData;
  /**
   * A reference to {@link Editor}.
   */
  private final JGenericType editorIntf;

  private final JClassType editorType;

  private final EditorData editorSoFar;

  /**
   * A reference to {@link IsEditor}.
   */
  private final JGenericType isEditorIntf;

  private final JGenericType leafValueEditorIntf;

  private final TreeLogger logger;

  private final TypeOracle oracle;

  private final EditorModel parentModel;

  private boolean poisoned;

  private final JClassType proxyType;

  /**
   * Type-specific data.
   */
  private final Map<JClassType, List<EditorData>> typeData;

  /**
   * Constructor to use when starting with an EditorDriver interface.
   */
  public EditorModel(TreeLogger logger, JClassType intf, JClassType driverType)
      throws UnableToCompleteException {
    assert logger != null : "logger was null";
    assert intf != null : "intf was null";
    assert driverType != null : "driver was null";

    editorSoFar = null;
    this.logger = logger.branch(TreeLogger.DEBUG, "Creating Editor model for "
        + intf.getQualifiedSourceName());
    parentModel = null;
    typeData = new HashMap<JClassType, List<EditorData>>();

    if (!driverType.isAssignableFrom(intf)) {
      die(unexpectedInputTypeMessage(driverType, intf));
    } else if (intf.equals(driverType)) {
      die(mustExtendMessage(driverType));
    }

    oracle = intf.getOracle();
    editorIntf = oracle.findType(Editor.class.getName()).isGenericType();
    assert editorIntf != null : "No Editor type";
    isEditorIntf = oracle.findType(IsEditor.class.getName()).isGenericType();
    assert isEditorIntf != null : "No IsEditor type";
    compositeEditorIntf = oracle.findType(CompositeEditor.class.getName()).isGenericType();
    assert compositeEditorIntf != null : "No CompositeEditor type";
    leafValueEditorIntf = oracle.findType(LeafValueEditor.class.getName()).isGenericType();
    assert leafValueEditorIntf != null;

    JClassType[] interfaces = intf.getImplementedInterfaces();
    if (interfaces.length != 1) {
      die(tooManyInterfacesMessage(intf));
    }

    JClassType[] parameters = ModelUtils.findParameterizationOf(driverType,
        intf);
    assert parameters.length == 2 : "Unexpected number of type parameters";
    proxyType = parameters[0];
    editorType = parameters[1];
    editorData = calculateEditorData();

    if (poisoned) {
      die(poisonedMessage());
    }
  }

  private EditorModel(EditorModel parent, JClassType editorType,
      EditorData subEditor, JClassType proxyType)
      throws UnableToCompleteException {
    logger = parent.logger.branch(TreeLogger.DEBUG, "Descending into "
        + subEditor.getPath());
    this.compositeEditorIntf = parent.compositeEditorIntf;
    this.editorIntf = parent.editorIntf;
    this.editorType = editorType;
    this.editorSoFar = subEditor;
    this.isEditorIntf = parent.isEditorIntf;
    this.leafValueEditorIntf = parent.leafValueEditorIntf;
    this.oracle = parent.oracle;
    this.parentModel = parent;
    this.proxyType = proxyType;
    this.typeData = parent.typeData;

    editorData = calculateEditorData();
  }

  public EditorData[] getEditorData() {
    return editorData;
  }

  /**
   * Guaranteed to never return null.
   */
  public EditorData[] getEditorData(JClassType editor) {
    List<EditorData> toReturn = typeData.get(editor);
    if (toReturn == null) {
      return EMPTY_EDITOR_DATA;
    }
    return toReturn.toArray(new EditorData[toReturn.size()]);
  }

  public JClassType getEditorType() {
    return editorType;
  }

  public JClassType getProxyType() {
    return proxyType;
  }

  public EditorData getRootData() throws UnableToCompleteException {
    TreeLogger rootLogger = logger.branch(TreeLogger.DEBUG,
        "Calculating root data for "
            + getEditorType().getParameterizedQualifiedSourceName());
    return new EditorData.Builder(rootLogger).access(
        EditorAccess.root(getEditorType())).build();
  }

  private void accumulateEditorData(List<EditorData> data,
      List<EditorData> flatData, List<EditorData> allData)
      throws UnableToCompleteException {
    flatData.addAll(data);
    allData.addAll(data);
    for (EditorData d : data) {
      descendIntoSubEditor(allData, d);
    }
  }

  /**
   * Create the EditorData objects for the {@link #editorData} type.
   * Essentially, the point of this method is to calculate the paths of all
   * Editor types referenced by {@link #editorType}.
   */
  private EditorData[] calculateEditorData() throws UnableToCompleteException {
    List<EditorData> flatData = new ArrayList<EditorData>();
    List<EditorData> toReturn = new ArrayList<EditorData>();

    // Only look for sub-editor accessors if the editor isn't a leaf
    if (!leafValueEditorIntf.isAssignableFrom(editorType)) {
      for (JClassType type : editorType.getFlattenedSupertypeHierarchy()) {
        for (JField field : type.getFields()) {
          if (field.isPrivate() || field.isStatic()
              || field.getAnnotation(Editor.Ignore.class) != null) {
            continue;
          }
          JType fieldClassType = field.getType();
          if (shouldExamine(fieldClassType)) {
            List<EditorData> data = createEditorData(EditorAccess.via(field));
            accumulateEditorData(data, flatData, toReturn);
          }
        }
        for (JMethod method : type.getMethods()) {
          if (method.isPrivate() || method.isStatic()
              || method.getAnnotation(Editor.Ignore.class) != null) {
            continue;
          }
          JType methodReturnType = method.getReturnType();
          if (shouldExamine(methodReturnType)
              && method.getParameters().length == 0) {
            EditorAccess access = EditorAccess.via(method);
            if (access.getPath().equals("as")
                && isEditorIntf.isAssignableFrom(editorType)) {
              // Ignore IsEditor.asEditor()
              continue;
            } else if (access.getPath().equals("createEditorForTraversal")
                && compositeEditorIntf.isAssignableFrom(editorType)) {
              // Ignore CompositeEditor.createEditorForTraversal();
              continue;
            }
            List<EditorData> data = createEditorData(access);
            accumulateEditorData(data, flatData, toReturn);
          }
        }
        type = type.getSuperclass();
      }
    }

    if (compositeEditorIntf.isAssignableFrom(editorType)) {
      JClassType subEditorType = calculateCompositeTypes(editorType)[1];
      EditorAccess access = EditorAccess.root(subEditorType);
      EditorData subEditor = new EditorData.Builder(logger).access(access).parent(
          editorSoFar).build();
      List<EditorData> accumulator = new ArrayList<EditorData>();
      descendIntoSubEditor(accumulator, subEditor);

      /*
       * It's necessary to generate a sub-Model here so that any Editor types
       * reachable only through the composite type will be added to the types
       * map. The path data isn't actually useful, since we rely on
       * CompositeEditor.getPathElement() at runtime.
       */
      EditorModel subModel = new EditorModel(this, subEditor.getEditorType(),
          subEditor, subEditor.getEditedType());
      poisoned |= subModel.poisoned;
    }

    if (!typeData.containsKey(editorType)) {
      typeData.put(editorType, flatData);
    }

    return toReturn.toArray(new EditorData[toReturn.size()]);
  }

  private List<EditorData> createEditorData(EditorAccess access)
      throws UnableToCompleteException {
    TreeLogger subLogger = logger.branch(TreeLogger.DEBUG, "Examining "
        + access.toString());

    List<EditorData> toReturn = new ArrayList<EditorData>();

    // Are we looking at a view that implements IsEditor?
    if (access.isEditor()) {
      EditorAccess subAccess = EditorAccess.via(access,
          calculateIsEditedType(subLogger, access.getEditorType()));
      toReturn = createEditorData(subAccess);

      // If an object only implements IsEditor, return now
      if (!editorIntf.isAssignableFrom(access.getEditorType())) {
        return toReturn;
      }
    }

    // Determine the Foo in Editor<Foo>
    JClassType expectedToEdit = calculateEditedType(subLogger,
        access.getEditorType());

    EditorData.Builder builder = new EditorData.Builder(subLogger);
    builder.access(access);
    builder.parent(editorSoFar);

    // Find the bean methods on the proxy interface
    findBeanPropertyMethods(access.getPath(), expectedToEdit, builder);

    toReturn.add(builder.build());
    return toReturn;
  }

  /**
   * @param accumulator
   * @param data
   * @throws UnableToCompleteException
   */
  private void descendIntoSubEditor(List<EditorData> accumulator,
      EditorData data) throws UnableToCompleteException {
    EditorModel superModel = parentModel;
    while (superModel != null) {
      if (superModel.editorType.isAssignableFrom(data.getEditorType())
          || data.getEditorType().isAssignableFrom(superModel.editorType)) {
        poison(cycleErrorMessage(data.getEditorType(), superModel.getPath(),
            data.getPath()));
        return;
      }
      superModel = superModel.parentModel;
    }

    if (data.isDelegateRequired()) {
      EditorModel subModel = new EditorModel(this, data.getEditorType(), data,
          calculateEditedType(logger, data.getEditorType()));
      accumulator.addAll(accumulator.indexOf(data) + 1,
          Arrays.asList(subModel.getEditorData()));
      poisoned |= subModel.poisoned;
    }
  }

  private void die(String message) throws UnableToCompleteException {
    logger.log(TreeLogger.ERROR, message);
    throw new UnableToCompleteException();
  }

  /**
   * Traverses a path to create expressions to access the getter and setter.
   * <p>
   * This method returns a three-element string array containing the
   * interstitial getter expression specified by the path, the name of the
   * getter method, and the name of the setter method. For example, the input
   * <code>foo.bar.baz</code> might return
   * <code>{ ".getFoo().getBar()", "getBaz", "setBaz" }</code>.
   */
  private void findBeanPropertyMethods(String path, JClassType propertyType,
      EditorData.Builder builder) {
    StringBuilder interstitialGetters = new StringBuilder();
    StringBuilder interstitialGuard = new StringBuilder("true");
    String[] parts = path.split(Pattern.quote("."));
    String setterName = null;

    JClassType lookingAt = proxyType;
    part : for (int i = 0, j = parts.length; i < j; i++) {
      if (parts[i].length() == 0) {
        continue;
      }
      boolean lastPart = i == j - 1;
      boolean foundGetterForPart = false;

      for (JMethod maybeSetter : lookingAt.getInheritableMethods()) {
        JBeanMethod which = JBeanMethod.which(maybeSetter);
        if (JBeanMethod.CALL.equals(which)) {
          continue;
        }
        if (!which.inferName(maybeSetter).equals(parts[i])) {
          continue;
        }
        switch (which) {
          case GET: {
            JType returnType = maybeSetter.getReturnType();
            lookingAt = returnType.isClassOrInterface();
            if (!lastPart && lookingAt == null) {
              poison(foundPrimitiveMessage(returnType, interstitialGetters.toString(), path));
              return;
            }
            interstitialGetters.append(".").append(maybeSetter.getName()).append("()");
            interstitialGuard.append(" && %1$s").append(interstitialGetters).append(" != null");
            builder.propertyOwnerType(maybeSetter.getEnclosingType());
            foundGetterForPart = true;
            if (!lastPart) {
              continue part;
            }
            break;
          }
          case SET:
          case SET_BUILDER: {
            if (lastPart && setterName == null) {
              /*
               * If looking at the last element of the path, also look for a
               * setter.
               */

              JType setterParamType = maybeSetter.getParameters()[0].getType();
              // Handle the case of setFoo(int) vs. Editor<Integer>
              if (setterParamType.isPrimitive() != null) {
                // Replace the int with Integer
                setterParamType =
                    oracle.findType(setterParamType.isPrimitive().getQualifiedBoxedSourceName());
              }
              boolean matches = setterParamType.isClassOrInterface().isAssignableFrom(propertyType);
              if (matches) {
                setterName = maybeSetter.getName();
              }
            }
            break;
          }
        }
      }
      if (!foundGetterForPart) {
        poison(noGetterMessage(path, proxyType));
        return;
      }
    }

    int idx = interstitialGetters.lastIndexOf(".");
    builder.beanOwnerExpression(idx <= 0 ? "" : interstitialGetters.substring(0, idx));
    if (parts.length > 1) {
      // Strip after last && since null is a valid value
      interstitialGuard.delete(interstitialGuard.lastIndexOf(" &&"), interstitialGuard.length());
      builder.beanOwnerGuard(interstitialGuard.substring(8));
    }
    if (interstitialGetters.length() > 0) {
      builder.getterExpression("."
          + interstitialGetters.substring(idx + 1, interstitialGetters.length() - 2) + "()");
    } else {
      builder.getterExpression("");
    }
    builder.setterName(setterName);
  }

  private String getPath() {
    if (editorSoFar != null) {
      return editorSoFar.getPath();
    } else {
      return "<Root Object>";
    }
  }

  /**
   * Record an error that is not immediately fatal.
   */
  private void poison(String message) {
    logger.log(TreeLogger.ERROR, message);
    poisoned = true;
  }

  /**
   * Returns <code>true</code> if the given type participates in Editor
   * hierarchies.
   */
  private boolean shouldExamine(JType type) {
    JClassType classType = type.isClassOrInterface();
    if (classType == null) {
      return false;
    }
    return editorIntf.isAssignableFrom(classType)
        || isEditorIntf.isAssignableFrom(classType);
  }
}