/*
 * Copyright 2011 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.web.bindery.requestfactory.apt;

import com.google.web.bindery.requestfactory.vm.impl.Deobfuscator;
import com.google.web.bindery.requestfactory.vm.impl.OperationData;
import com.google.web.bindery.requestfactory.vm.impl.OperationKey;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Arrays;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.tools.JavaFileObject;

/**
 * Visits a RequestFactory to create its associated DeobfuscatorBuilder, a
 * self-configuring subtype of
 * {@link com.google.web.bindery.requestfactory.vm.impl.Deobfuscator.Builder}
 * which provides the ServiceLayer with type- and method-mapping information.
 */
class DeobfuscatorBuilder extends ScannerBase<Void> {
  private TypeElement requestFactoryElement;
  private final StringBuilder sb = new StringBuilder();

  public String toString() {
    return sb.toString();
  }

  /**
   * Examine a method defined within a RequestFactory.
   */
  @Override
  public Void visitExecutable(ExecutableElement x, State state) {
    if (shouldIgnore(x, state)) {
      return null;
    }
    final TypeElement requestContextElement =
        (TypeElement) state.types.asElement(x.getReturnType());
    new ScannerBase<Void>() {

      /**
       * Scan a method within a RequestContext.
       */
      @Override
      public Void visitExecutable(ExecutableElement x, State state) {
        if (shouldIgnore(x, state)) {
          return null;
        }
        String requestContextBinaryName =
            state.elements.getBinaryName(requestContextElement).toString();
        String clientMethodDescriptor = x.asType().accept(new DescriptorBuilder(), state);
        ExecutableElement domainElement = (ExecutableElement) state.getClientToDomainMap().get(x);
        if (domainElement == null) {
          /*
           * No mapping from the client to domain type, probably because of an
           * unresolved ServiceName annotation. This can be fixed when building
           * the server by running ValidationTool.
           */
          if (state.mustResolveAllAnnotations()) {
            state.poison(requestContextElement, Messages
                .deobfuscatorMissingContext(requestContextElement.getSimpleName()));
          }
          return super.visitExecutable(x, state);
        }
        String domainMethodDescriptor =
            domainElement.asType().accept(new DescriptorBuilder(), state);
        String methodName = x.getSimpleName().toString();

        OperationKey key =
            new OperationKey(requestContextBinaryName, methodName, clientMethodDescriptor);
        println("withOperation(new OperationKey(\"%s\"),", key.get());
        println("  new OperationData.Builder()");
        println("  .withClientMethodDescriptor(\"%s\")", clientMethodDescriptor);
        println("  .withDomainMethodDescriptor(\"%s\")", domainMethodDescriptor);
        println("  .withMethodName(\"%s\")", methodName);
        println("  .withRequestContext(\"%s\")", requestContextBinaryName);
        println("  .build());");
        return super.visitExecutable(x, state);
      }

      /**
       * Scan a RequestContext.
       */
      @Override
      public Void visitType(TypeElement x, State state) {
        scanAllInheritedMethods(x, state);
        return null;
      }
    }.scan(requestContextElement, state);
    return null;
  }

  /**
   * Scan a RequestFactory type.
   */
  @Override
  public Void visitType(TypeElement x, State state) {
    requestFactoryElement = x;
    String simpleName = computeSimpleName(x, state);
    String packageName = state.elements.getPackageOf(x).getQualifiedName().toString();

    println("// Automatically Generated -- DO NOT EDIT");
    println("// %s", state.elements.getBinaryName(x));
    println("package %s;", packageName);
    println("import %s;", Arrays.class.getCanonicalName());
    println("import %s;", OperationData.class.getCanonicalName());
    println("import %s;", OperationKey.class.getCanonicalName());
    println("public final class %s extends %s {", simpleName, Deobfuscator.Builder.class
        .getCanonicalName());
    println("{");
    scanAllInheritedMethods(x, state);
    writeTypeAndTokenMap(state);
    println("}}");

    // Don't write the deobfuscator if something has gone wrong.
    if (state.isPoisoned()) {
      return null;
    }

    try {
      JavaFileObject obj = state.filer.createSourceFile(packageName + "." + simpleName, x);
      Writer w = obj.openWriter();
      w.write(sb.toString());
      w.close();
    } catch (Exception e) {
      StringWriter sw = new StringWriter();
      e.printStackTrace(new PrintWriter(sw));
      state.poison(x, sw.toString());
    }
    return null;
  }

  private String computeSimpleName(TypeElement x, State state) {
    // See constants in Deobfuscator
    String simpleName = state.elements.getBinaryName(x).toString() + "DeobfuscatorBuilder";
    if (state.isClientOnly()) {
      simpleName += "Lite";
    }
    simpleName = simpleName.substring(simpleName.lastIndexOf('.') + 1);
    return simpleName;
  }

  private void println(String line, Object... args) {
    sb.append(String.format(line, args)).append("\n");
  }

  /**
   * Write calls to {@code withRawTypeToken} and
   * {@code withClientToDomainMappings}.
   */
  private void writeTypeAndTokenMap(State state) {
    /*
     * A map and its comparator to build up the mapping between domain types and
     * the client type(s) that it is mapped to.
     */
    TypeComparator comparator = new TypeComparator(state);
    Map<TypeElement, SortedSet<TypeElement>> domainToClientMappings =
        new TreeMap<TypeElement, SortedSet<TypeElement>>(comparator);
    // Map accumulated by previous visitors
    Map<Element, Element> clientToDomainMap = state.getClientToDomainMap();
    // Get all types used by the RequestFactory
    Set<TypeElement> referredTypes = ReferredTypesCollector.collect(requestFactoryElement, state);

    for (TypeElement clientType : referredTypes) {
      // Ignare non-proxy types
      if (!state.types.isAssignable(clientType.asType(), state.baseProxyType)) {
        continue;
      }
      String binaryName = state.elements.getBinaryName(clientType).toString();
      // withRawTypeToken("1234ABC", "com.example.FooProxy");
      println("withRawTypeToken(\"%s\", \"%s\");", OperationKey.hash(binaryName), binaryName);

      TypeElement domainType = (TypeElement) clientToDomainMap.get(clientType);
      if (domainType == null) {
        /*
         * Missing proxy mapping, probably due to an unresolved ProxyForName. If
         * we're running as part of a build tool or an IDE, the
         * mustResolveAllAnnotations() call below will return false. The
         * isMappingRequired() check avoid false-positives on proxy supertypes
         * that extend BaseProxy but that don't declare a ProxyFor annotation.
         */
        if (state.mustResolveAllAnnotations() && state.isMappingRequired(domainType)) {
          state.poison(clientType, Messages.deobfuscatorMissingProxy(clientType.getSimpleName()));
        }
        continue;
      }
      // Generic get-and-add code
      SortedSet<TypeElement> clientTypes = domainToClientMappings.get(domainType);
      if (clientTypes == null) {
        clientTypes = new TreeSet<TypeElement>(comparator);
        domainToClientMappings.put(domainType, clientTypes);
      }
      clientTypes.add(clientType);
    }

    for (Map.Entry<TypeElement, SortedSet<TypeElement>> entry : domainToClientMappings.entrySet()) {
      // Arrays.asList("com.example.FooView1Proxy", "com.example.FooView2Proxy")
      StringBuilder list = new StringBuilder("Arrays.asList(");
      boolean needsComma = false;
      for (TypeElement elt : entry.getValue()) {
        if (needsComma) {
          list.append(", ");
        } else {
          needsComma = true;
        }
        list.append('"').append(state.elements.getBinaryName(elt)).append('"');
      }
      list.append(")");

      // withClientToDomainMappings("com.example.Domain", Arrays.asList(...))
      println("withClientToDomainMappings(\"%s\", %s);", state.elements.getBinaryName(entry
          .getKey()), list);
    }
  }
}