/*
 * Copyright 2007 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.user.rebind.rpc;

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.JMethod;
import com.google.gwt.core.ext.typeinfo.JPackage;
import com.google.gwt.core.ext.typeinfo.JParameter;
import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
import com.google.gwt.core.ext.typeinfo.JType;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.core.ext.typeinfo.TypeOracle;
import com.google.gwt.http.client.Request;
import com.google.gwt.http.client.RequestBuilder;
import com.google.gwt.user.client.rpc.AsyncCallback;

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

/**
 * Validates the asynchronous version of
 * {@link com.google.gwt.user.client.rpc.RemoteService RemoteService} interface.
 */
class RemoteServiceAsyncValidator {
  static void logValidAsyncInterfaceDeclaration(TreeLogger logger,
      JClassType remoteService) {
    TreeLogger branch = logger.branch(TreeLogger.INFO,
        "A valid definition for the asynchronous version of interface '"
            + remoteService.getQualifiedSourceName() + "' would be:\n", null);
    branch.log(TreeLogger.ERROR,
        synthesizeAsynchronousInterfaceDefinition(remoteService), null);
  }

  private static String computeAsyncMethodSignature(JMethod syncMethod,
      JClassType asyncCallbackClass) {
    return computeInternalSignature(syncMethod) + "/"
        + asyncCallbackClass.getQualifiedSourceName();
  }

  private static String computeInternalSignature(JMethod method) {
    StringBuffer sb = new StringBuffer();
    sb.setLength(0);
    sb.append(method.getName());
    JParameter[] params = method.getParameters();
    for (JParameter param : params) {
      sb.append("/");
      JType paramType = param.getType();
      sb.append(paramType.getErasedType().getQualifiedSourceName());
    }
    return sb.toString();
  }

  /**
   * Builds a map of asynchronous method internal signatures to the
   * corresponding asynchronous {@link JMethod}.
   */
  private static Map<String, JMethod> initializeAsyncMethodMap(
      JMethod[] asyncMethods) {
    Map<String, JMethod> sigs = new TreeMap<String, JMethod>();
    for (JMethod asyncMethod : asyncMethods) {
      sigs.put(computeInternalSignature(asyncMethod), asyncMethod);
    }
    return sigs;
  }

  private static String synthesizeAsynchronousInterfaceDefinition(
      JClassType serviceIntf) {
    StringBuffer sb = new StringBuffer();
    JPackage pkg = serviceIntf.getPackage();
    if (pkg != null) {
      sb.append("\npackage ");
      sb.append(pkg.getName());
      sb.append(";\n");
    }

    sb.append("\npublic interface ");
    sb.append(serviceIntf.getSimpleSourceName());
    sb.append("Async {\n");

    JMethod[] methods = serviceIntf.getOverridableMethods();
    for (JMethod method : methods) {
      assert (method != null);

      sb.append("\tvoid ");
      sb.append(method.getName());
      sb.append("(");

      JParameter[] params = method.getParameters();
      for (int paramIndex = 0; paramIndex < params.length; ++paramIndex) {
        JParameter param = params[paramIndex];

        if (paramIndex > 0) {
          sb.append(", ");
        }

        sb.append(param.toString());
      }

      if (params.length > 0) {
        sb.append(", ");
      }

      JType returnType = method.getReturnType();
      sb.append(AsyncCallback.class.getName());
      sb.append("<");
      if (returnType instanceof JPrimitiveType) {
        sb.append(((JPrimitiveType) returnType).getQualifiedBoxedSourceName());
      } else {
        sb.append(returnType.getParameterizedQualifiedSourceName());
      }
      sb.append("> arg");
      sb.append(Integer.toString(params.length + 1));
      sb.append(");\n");
    }

    sb.append("}");

    return sb.toString();
  }

  private static void validationFailed(TreeLogger branch,
      JClassType remoteService) throws UnableToCompleteException {
    logValidAsyncInterfaceDeclaration(branch, remoteService);
    throw new UnableToCompleteException();
  }

  /**
   * {@link JClassType} for the {@link AsyncCallback} interface.
   */
  private final JClassType asyncCallbackClass;

  /**
   * {@link JClassType} for the {@link RequestBuilder} class.
   */
  private final JClassType requestBuilderType;

  /**
   * {@link JClassType} for the {@link Request} class.
   */
  private final JClassType requestType;

  RemoteServiceAsyncValidator(TreeLogger logger, TypeOracle typeOracle)
      throws UnableToCompleteException {
    try {
      asyncCallbackClass = typeOracle.getType(AsyncCallback.class.getName());
      requestType = typeOracle.getType(Request.class.getCanonicalName());
      requestBuilderType = typeOracle.getType(RequestBuilder.class.getCanonicalName());
    } catch (NotFoundException e) {
      logger.log(TreeLogger.ERROR, null, e);
      throw new UnableToCompleteException();
    }
  }

  /**
   * Checks that for every method on the synchronous remote service interface
   * there is a corresponding asynchronous version in the asynchronous version
   * of the remote service. If the validation succeeds, a map of synchronous to
   * asynchronous methods is returned.
   * 
   * @param logger
   * @param remoteService
   * @return map of synchronous method to asynchronous method
   * 
   * @throws UnableToCompleteException if the asynchronous
   *           {@link com.google.gwt.user.client.rpc.RemoteService RemoteService}
   *           was not found, or if it does not have an asynchronous method
   *           version of every synchronous one
   */
  public Map<JMethod, JMethod> validate(TreeLogger logger,
      JClassType remoteService, JClassType remoteServiceAsync)
      throws UnableToCompleteException {
    TreeLogger branch = logger.branch(TreeLogger.DEBUG,
        "Checking the synchronous interface '"
            + remoteService.getQualifiedSourceName()
            + "' against its asynchronous version '"
            + remoteServiceAsync.getQualifiedSourceName() + "'", null);

    // Sync and async versions must have the same number of methods
    JMethod[] asyncMethods = remoteServiceAsync.getOverridableMethods();
    JMethod[] syncMethods = remoteService.getOverridableMethods();
    if (asyncMethods.length != syncMethods.length) {
      branch.branch(TreeLogger.ERROR, "The asynchronous version of "
          + remoteService.getQualifiedSourceName() + " has "
          + (asyncMethods.length > syncMethods.length ? "more" : "less")
          + " methods than the synchronous version", null);
      validationFailed(branch, remoteService);
    }

    // Check that for every sync method there is a corresponding async method
    boolean failed = false;
    Map<String, JMethod> asyncMethodMap = initializeAsyncMethodMap(asyncMethods);
    Map<JMethod, JMethod> syncMethodToAsyncMethodMap = new HashMap<JMethod, JMethod>();
    for (JMethod syncMethod : syncMethods) {
      String asyncSig = computeAsyncMethodSignature(syncMethod,
          asyncCallbackClass);
      JMethod asyncMethod = asyncMethodMap.get(asyncSig);
      if (asyncMethod == null) {
        branch.branch(TreeLogger.ERROR,
            "Missing asynchronous version of the synchronous method '"
                + syncMethod.getReadableDeclaration() + "'", null);
        failed = true;
      } else {
        // TODO if async param is parameterized make sure that the sync return
        // type is assignable to the first type argument
        JType returnType = asyncMethod.getReturnType();
        if (returnType != JPrimitiveType.VOID && returnType != requestType
            && returnType != requestBuilderType) {
          branch.branch(TreeLogger.ERROR,
              "The asynchronous version of the synchronous method '"
                  + syncMethod.getReadableDeclaration()
                  + "' must have a return type of 'void' or '"
                  + Request.class.getCanonicalName() + "' or '"
                  + RequestBuilder.class.getCanonicalName() + "'", null);
          failed = true;
        } else {
          syncMethodToAsyncMethodMap.put(syncMethod, asyncMethod);
        }
      }
    }

    if (failed) {
      validationFailed(branch, remoteService);
    }

    branch.log(TreeLogger.DEBUG, "Interfaces are in sync");

    return syncMethodToAsyncMethodMap;
  }
}