/*
 * Copyright 2006 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.dev.util.xml;

import com.google.gwt.core.ext.UnableToCompleteException;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

/**
 * Represents metadata about a handler method in a class derived from {@link Schema}. 
 */
public final class HandlerMethod {

  private static final HandlerParam[] EMPTY_HANDLERPARAMS = new HandlerParam[0];

  // A schema level that ignores everything.
  private static final Schema sArbitraryChildHandler = new Schema() {

    @Override
    public void onBadAttributeValue(int lineNumber, String elemName,
        String attrName, String attrValue, Class<?> paramType) {
      // Ignore
    }

    @Override
    public void onHandlerException(int lineNumber, String elemLocalName,
        Method method, Throwable e) {
      // Ignore
    }

    @Override
    public void onMissingAttribute(int lineNumber, String elemName,
        String argName) {
      // Ignore
    }

    @Override
    public void onUnexpectedAttribute(int lineNumber, String elemName,
        String attrName, String attrValue) {
      // Ignore
    }

    @Override
    public void onUnexpectedChild(int lineNumber, String elemName) {
      // Ignore
    }

    @Override
    public void onUnexpectedElement(int lineNumber, String elemName) {
      // Ignore
    }
  };

  private static final int TYPE_NONE = 0;
  private static final int TYPE_BEGIN = 1;
  private static final int TYPE_END = 2;
  private static final int TYPE_TEXT = 3;

  static {
    ReflectiveParser.registerSchemaLevel(sArbitraryChildHandler.getClass());
  }

  /**
   * Attempts to create a handler method from any method. You can pass in any
   * method at all, but an exception will be thrown if the method is clearly a
   * handler but the containing class does not have the proper parameter
   * metafields.
   */
  @SuppressWarnings("unchecked")
  public static HandlerMethod tryCreate(Method method) {
    String methodName = method.getName();
    String normalizedTagName = null;
    try {
      int type = TYPE_NONE;

      if (methodName.startsWith("__")) {
        if (methodName.endsWith("_begin")) {
          type = TYPE_BEGIN;
          normalizedTagName = methodName.substring(0, methodName.length()
              - "_begin".length());
        } else if (methodName.endsWith("_end")) {
          type = TYPE_END;
          normalizedTagName = methodName.substring(0, methodName.length()
              - "_end".length());
        } else if (methodName.equals("__text")) {
          type = TYPE_TEXT;
        }
      }

      if (type == TYPE_NONE) {
        // This was not a handler method.
        // Exit early.
        //
        return null;
      }

      assert (type == TYPE_BEGIN || type == TYPE_END || type == TYPE_TEXT);

      // Can the corresponding element have arbitrary children?
      //
      Class<?> returnType = method.getReturnType();
      boolean arbitraryChildren = false;
      if (type == TYPE_BEGIN) {
        if (Schema.class.isAssignableFrom(returnType)) {
          arbitraryChildren = false;

          // Also, we need to register this schema type.
          //
          ReflectiveParser.registerSchemaLevel((Class<? extends Schema>) returnType);

        } else if (returnType.equals(Void.TYPE)) {
          arbitraryChildren = true;
        } else {
          throw new IllegalArgumentException(
              "The return type of begin handlers must be 'void' or assignable to 'SchemaLevel'");
        }
      } else if (!Void.TYPE.equals(returnType)) {
        throw new IllegalArgumentException(
            "Only 'void' may be specified as a return type for 'end' and 'text' handlers");
      }

      // Create handler args.
      //
      if (type == TYPE_TEXT) {
        Class<?>[] paramTypes = method.getParameterTypes();
        if (paramTypes.length != 1 || !String.class.equals(paramTypes[0])) {
          throw new IllegalArgumentException(
              "__text handlers must have exactly one String parameter");
        }

        // We pretend it doesn't have any param since they're always
        // pre-determined.
        //
        return new HandlerMethod(method, type, false, EMPTY_HANDLERPARAMS);
      } else {
        Class<?>[] paramTypes = method.getParameterTypes();
        List<HandlerParam> handlerParams = new ArrayList<HandlerParam>();
        for (int i = 0, n = paramTypes.length; i < n; ++i) {
          HandlerParam handlerParam = HandlerParam.create(method,
              normalizedTagName, i);
          if (handlerParam != null) {
            handlerParams.add(handlerParam);
          } else {
            throw new IllegalArgumentException("In method '" + method.getName()
                + "', parameter " + (i + 1) + " is an unsupported type");
          }
        }

        HandlerParam[] hpa = handlerParams.toArray(EMPTY_HANDLERPARAMS);
        return new HandlerMethod(method, type, arbitraryChildren, hpa);
      }
    } catch (Exception e) {
      throw new RuntimeException("Unable to use method '" + methodName
          + "' as a handler", e);
    }
  }

  private final boolean arbitraryChildren;

  private final HandlerParam[] handlerParams;

  private final Method method;

  private final int methodType;

  private HandlerMethod(Method method, int type, boolean arbitraryChildren,
      HandlerParam[] hpa) {
    this.method = method;
    this.methodType = type;
    this.arbitraryChildren = arbitraryChildren;
    this.handlerParams = hpa.clone();

    this.method.setAccessible(true);
  }

  public HandlerArgs createArgs(Schema schema, int lineNumber, String elemName) {
    return new HandlerArgs(schema, lineNumber, elemName, handlerParams);
  }

  public String getNormalizedName() {
    String name = method.getName();
    if (isStartMethod()) {
      return name.substring(2, name.length() - "_begin".length());
    } else if (isEndMethod()) {
      return name.substring(2, name.length() - "_end".length());
    } else {
      throw new IllegalStateException("Unexpected method name");
    }
  }

  public HandlerParam getParam(int i) {
    return handlerParams[i];
  }

  public int getParamCount() {
    return handlerParams.length;
  }

  public Schema invokeBegin(int lineNumber, String elemLocalName,
      Schema target, HandlerArgs args, Object[] outInvokeArgs)
      throws UnableToCompleteException {
    assert (outInvokeArgs.length == args.getArgCount());

    for (int i = 0, n = args.getArgCount(); i < n; ++i) {
      Object invokeArg = args.convertToArg(i);
      outInvokeArgs[i] = invokeArg;
    }

    Schema nextSchemaLevel = null;

    Throwable caught = null;
    try {
      target.setLineNumber(lineNumber);
      nextSchemaLevel = (Schema) method.invoke(target, outInvokeArgs);
    } catch (IllegalArgumentException e) {
      caught = e;
    } catch (IllegalAccessException e) {
      caught = e;
    } catch (InvocationTargetException e) {
      caught = e.getTargetException();
    }

    if (caught != null) {
      target.onHandlerException(lineNumber, elemLocalName, method, caught);
    }

    // Prepare a resulting schema level that allows the reflective parser
    // to simply perform its normal logic, even while there are some
    // special cases.
    //
    // Four cases:
    // (1) childSchemaLevel is non-null, in which case it becomes the new
    // schema used for child elements
    // (2) the handler method has return type "SchemaLevel" but the result
    // was null, meaning that it cannot have child elements;
    // we return null to indicate this
    // (3) the handler method has return type "void", meaning that child
    // elements are simply ignored; we push null to detect this
    // (4) the method failed or could not be called, which is treated the same
    // as case (3)
    //
    if (nextSchemaLevel != null) {
      return nextSchemaLevel;
    } else if (arbitraryChildren) {
      return sArbitraryChildHandler;
    } else {
      return null;
    }
  }

  public void invokeEnd(int lineNumber, String elem, Schema target,
      Object[] args) throws UnableToCompleteException {
    Throwable caught = null;
    try {
      target.setLineNumber(lineNumber);
      method.invoke(target, args);
      return;
    } catch (IllegalArgumentException e) {
      caught = e;
    } catch (IllegalAccessException e) {
      caught = e;
    } catch (InvocationTargetException e) {
      caught = e.getTargetException();
    }
    target.onHandlerException(lineNumber, elem, method, caught);
  }

  public void invokeText(int lineNumber, String text, Schema target)
      throws UnableToCompleteException {
    Throwable caught = null;
    try {
      target.setLineNumber(lineNumber);
      method.invoke(target, new Object[] {text});
      return;
    } catch (IllegalArgumentException e) {
      caught = e;
    } catch (IllegalAccessException e) {
      caught = e;
    } catch (InvocationTargetException e) {
      caught = e.getTargetException();
    }
    target.onHandlerException(lineNumber, "#text", method, caught);
  }

  public boolean isEndMethod() {
    return methodType == TYPE_END;
  }

  public boolean isStartMethod() {
    return methodType == TYPE_BEGIN;
  }
}