package io.vertx.codegen;

/*
 * Copyright 2014 Red Hat, Inc.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Apache License v2.0 which accompanies this distribution.
 *
 * The Eclipse Public License is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * The Apache License v2.0 is available at
 * http://www.opensource.org/licenses/apache2.0.php
 *
 * You may elect to redistribute this code under either of these licenses.
 */

import io.vertx.codegen.doc.Doc;
import io.vertx.codegen.doc.Text;
import io.vertx.codegen.type.ClassKind;
import io.vertx.codegen.type.ClassTypeInfo;
import io.vertx.codegen.type.ParameterizedTypeInfo;
import io.vertx.codegen.type.TypeInfo;
import io.vertx.codegen.type.TypeVariableInfo;

import java.util.*;

Author:
Tim Fox/**
 * @author <a href="http://tfox.org">Tim Fox</a>
 */
public class MethodInfo implements Comparable<MethodInfo> {

  private String name;
  private TypeInfo returnType;
  private Text returnDescription;
  private boolean fluent;
  private boolean cacheReturn;
  private String comment;
  private Doc doc;
  private boolean staticMethod;
  private boolean defaultMethod;
  private List<TypeParamInfo.Method> typeParams;
  private Set<ClassTypeInfo> ownerTypes;
  private List<ParamInfo> params;
  private boolean deprecated;
  private Text deprecatedDesc;

  public MethodInfo(Set<ClassTypeInfo> ownerTypes, String name,
                    TypeInfo returnType, Text returnDescription, boolean fluent,  boolean cacheReturn,
                    List<ParamInfo> params, String comment, Doc doc, boolean staticMethod, boolean defaultMethod,
                    List<TypeParamInfo.Method> typeParams, boolean deprecated, Text deprecatedDesc) {


    this.comment = comment;
    this.name = name;
    this.returnType = returnType;
    this.returnDescription = returnDescription;
    this.fluent = fluent;
    this.cacheReturn = cacheReturn;
    this.doc = doc;
    this.staticMethod = staticMethod;
    this.defaultMethod = defaultMethod;
    this.params = params;
    this.typeParams = typeParams;
    this.ownerTypes = ownerTypes;
    this.deprecated = deprecated;
    this.deprecatedDesc = deprecatedDesc;
  }

  public String getName() {
    return name;
  }

  public MethodInfo setName(String name) {
    this.name = name;
    return this;
  }

  public String getName(Case _case) {
    return _case.format(Case.CAMEL.parse(name));
  }

  public MethodKind getKind() {
    int lastParamIndex = params.size() - 1;
    if (lastParamIndex >= 0 && (returnType.isVoid() || fluent)) {
      TypeInfo lastParamType = params.get(lastParamIndex).type;
      if (lastParamType.getKind() == ClassKind.HANDLER) {
        TypeInfo typeArg = ((ParameterizedTypeInfo) lastParamType).getArgs().get(0);
        if (typeArg.getKind() == ClassKind.ASYNC_RESULT) {
          return MethodKind.FUTURE;
        } else {
          return MethodKind.HANDLER;
        }
      }
    }
    return MethodKind.OTHER;
  }

  public TypeInfo getReturnType() {
    return returnType;
  }

  public MethodInfo setReturnType(TypeInfo returnType) {
    this.returnType = returnType;
    return this;
  }

  
Returns:
whether the method is annotated with GenIgnore/**
   * @return whether the method is annotated with {@link io.vertx.codegen.annotations.GenIgnore}
   */
  public boolean isContainingAnyJavaType() {
    return params.stream().map(ParamInfo::getType).anyMatch(MethodInfo::containsAnyJavaType) || containsAnyJavaType(returnType);
  }

  private static boolean containsAnyJavaType(TypeInfo type) {
    if (type instanceof ParameterizedTypeInfo) {
      return containsAnyJavaType(type.getRaw()) || ((ParameterizedTypeInfo) type).getArgs().stream().anyMatch(MethodInfo::containsAnyJavaType);
    } else {
      return type.getKind() == ClassKind.OTHER;
    }
  }

  
Resolve the method parameter that is of kind ClassKind.CLASS_TYPE and that matches the specified type variable e.g:


 <U> Map.Entry<String, U> getEntry(String s, Class<U> type); 


 returns for <U> the second method parameter. 
Params:
typeVar – the type variable to check
Returns:
the matching method parameter or null/**
   * Resolve the method parameter that is of kind {@link ClassKind#CLASS_TYPE} and that matches the specified type variable e.g:<br/>
   * <br/>
   * {@code <U> Map.Entry<String, U> getEntry(String s, Class<U> type);}
   * <br/>
   * <br/>
   * returns for {@code <U>} the second method parameter.
   *
   * @param typeVar the type variable to check
   * @return the matching method parameter or null
   */
  public ParamInfo resolveClassTypeParam(TypeVariableInfo typeVar) {
    TypeArgExpression res = resolveTypeArg(typeVar);
    if (res != null && res.isClassType()) {
      return res.getParam();
    }
    return null;
  }

  public TypeArgExpression resolveTypeArg(TypeVariableInfo typeVar) {
    for (TypeParamInfo.Method typeParam : typeParams) {
      if (typeParam.getName().equals(typeVar.getName())) {
        for (ParamInfo param : params) {
          if (param.getType().getKind() == ClassKind.CLASS_TYPE &&
            param.getType().isParameterized()) {
            TypeInfo arg_ = ((ParameterizedTypeInfo) param.getType()).getArg(0);
            if (arg_.isVariable()) {
              TypeVariableInfo ttt = (TypeVariableInfo) arg_;
              if (ttt.getParam().equals(typeParam)) {
                return new TypeArgExpression(TypeArgExpression.CLASS_TYPE_ARG, ttt, param, 0);
              }
            }
          } else if (param.getType().getKind() == ClassKind.API && param.getType().isParameterized()) {
            ParameterizedTypeInfo type = (ParameterizedTypeInfo) param.getType();
            int index = 0;
            for (TypeInfo i : type.getArgs()) {
              if (i instanceof TypeVariableInfo) {
                TypeVariableInfo tt = (TypeVariableInfo) i;
                if (tt.getParam().equals(typeParam)) {
                  return new TypeArgExpression(TypeArgExpression.API_ARG, tt, param, index);
                }
              }
              index++;
            }
          }
        }
        return null;
      }
    }
    return null;
  }

  public Text getReturnDescription() {
    return returnDescription;
  }

  public MethodInfo setReturnDescription(Text returnDescription) {
    this.returnDescription = returnDescription;
    return this;
  }

  public Set<ClassTypeInfo> getOwnerTypes() {
    return ownerTypes;
  }

  public MethodInfo setOwnerTypes(Set<ClassTypeInfo> ownerTypes) {
    this.ownerTypes = ownerTypes;
    return this;
  }

  
Returns the method signature, the returned object is freely modifiable.
Returns:
the method signature/**
   * Returns the method signature, the returned object is freely modifiable.
   *
   * @return the method signature
   */
  public Signature getSignature() {
    return new Signature(name, new ArrayList<>(params));
  }

  
Return true if the provided type is the sole owner of this method, i.e this method
is only declared by the provided type.
Params:
owner – the tested type
Returns:
true when this method is owned by the owner argument/**
   * Return true if the provided type is the sole owner of this method, i.e this method
   * is only declared by the provided type.
   *
   * @param owner the tested type
   * @return true when this method is owned by the <code>owner</code> argument
   */
  public boolean isOwnedBy(ClassTypeInfo owner) {
    return ownerTypes.contains(owner) && ownerTypes.size() == 1;
  }

  public boolean isFluent() {
    return fluent;
  }

  public MethodInfo setFluent(boolean fluent) {
    this.fluent = fluent;
    return this;
  }

  public boolean isCacheReturn() {
    return cacheReturn;
  }

  public MethodInfo setCacheReturn(boolean cacheReturn) {
    this.cacheReturn = cacheReturn;
    return this;
  }

  
Returns:
true if the method has a nullable return/**
   * @return true if the method has a nullable return
   */
  public boolean isNullableReturn() {
    return returnType.isNullable();
  }

  public List<ParamInfo> getParams() {
    return params;
  }

  public MethodInfo setParams(List<ParamInfo> params) {
    this.params = params;
    return this;
  }

  public ParamInfo getParam(int index) {
    return params.get(index);
  }

  public String getComment() {
    return comment;
  }

  public MethodInfo setComment(String comment) {
    this.comment = comment;
    return this;
  }

  public Doc getDoc() {
    return doc;
  }

  public MethodInfo setDoc(Doc doc) {
    this.doc = doc;
    return this;
  }

  public boolean isStaticMethod() {
    return staticMethod;
  }

  public MethodInfo setStaticMethod(boolean staticMethod) {
    this.staticMethod = staticMethod;
    return this;
  }

  public boolean isDefaultMethod() {
    return defaultMethod;
  }

  public MethodInfo setDefaultMethod(boolean defaultMethod) {
    this.defaultMethod = defaultMethod;
    return this;
  }

  
Returns:
true if the method has a @Deprecated annotation/**
   *
   * @return {@code true} if the method has a {@code @Deprecated} annotation
   */
  public boolean isDeprecated() {
    return deprecated;
  }

  public MethodInfo setDeprecated(boolean deprecated) {
    this.deprecated = deprecated;
    return this;
  }

  
Returns:
the description of deprecated/**
   * @return the description of deprecated
   */
  public Text getDeprecatedDesc() {
    return deprecatedDesc;
  }

  public MethodInfo setDeprecatedDesc(Text deprecatedDesc) {
    this.deprecatedDesc = deprecatedDesc;
    return this;
  }

  public List<TypeParamInfo.Method> getTypeParams() {
    return typeParams;
  }

  public MethodInfo setTypeParams(List<TypeParamInfo.Method> typeParams) {
    this.typeParams = typeParams;
    return this;
  }

  public void mergeTypeParams(List<TypeParamInfo.Method> mergedTypeParams) throws IllegalArgumentException {
    int l = Math.min(typeParams.size(), mergedTypeParams.size());
    if (typeParams.subList(0, l).equals(mergedTypeParams.subList(0, l))) {
      if (mergedTypeParams.size() > typeParams.size()) {
        typeParams.addAll(mergedTypeParams.subList(typeParams.size(), mergedTypeParams.size()));
      }
    } else {
      throw new IllegalArgumentException("Merged type params " + mergedTypeParams + " don't match the existing ones " + typeParams);
    }
  }

  public void collectImports(Collection<ClassTypeInfo> imports) {
    params.stream().map(ParamInfo::getType).forEach(a -> a.collectImports(imports));
  }

  
Returns:
a copy of this object/**
   * @return a copy of this object
   */
  public MethodInfo copy() {
    return new MethodInfo(
      new HashSet<>(ownerTypes),
      name,
      returnType,
      returnDescription,
      fluent,
      cacheReturn,
      new ArrayList<>(params),
      comment,
      doc,
      staticMethod,
      defaultMethod,
      new ArrayList<>(typeParams),
      deprecated,
      deprecatedDesc);
  }

  @Override
  public int compareTo(MethodInfo o) {
    int cmp = name.compareTo(o.name);
    if (cmp != 0) {
      return cmp;
    }
    Iterator<ParamInfo> i1 = params.iterator();
    Iterator<ParamInfo> i2 = o.params.iterator();
    while (i1.hasNext() && i2.hasNext()) {
      ParamInfo p1 = i1.next();
      ParamInfo p2 = i2.next();
      cmp = p1.getType().getRaw().getName().compareTo(p2.getType().getRaw().getName());
      if (cmp != 0) {
        return cmp;
      }
    }
    if (i1.hasNext()) {
      if (!i2.hasNext()) {
        return 1;
      }
    } else if (!i2.hasNext()) {
      return -1;
    }
    return 0;
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder();
    if (typeParams.size() > 0) {
      for (int i = 0;i < typeParams.size();i++) {
        sb.append(i > 0 ? ", " : "<");
        sb.append(typeParams.get(i).getName());
      }
      sb.append("> ");
    }
    sb.append(returnType.getName());
    sb.append(' ');
    sb.append(getSignature().toString());
    return sb.toString();
  }
}