/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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 org.apache.maven.tools.plugin.extractor.annotations.converter;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import com.github.javaparser.ast.ImportDeclaration;
import com.github.javaparser.ast.Node;
import com.github.javaparser.ast.body.FieldDeclaration;
import com.github.javaparser.ast.body.TypeDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedConstructorDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedFieldDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedMethodLikeDeclaration;
import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
import com.github.javaparser.resolution.types.ResolvedReferenceType;
import org.apache.maven.tools.plugin.extractor.annotations.JavaSourceModel;
import org.apache.maven.tools.plugin.extractor.annotations.scanner.MojoAnnotatedClass;
import org.apache.maven.tools.plugin.javadoc.FullyQualifiedJavadocReference;
import org.apache.maven.tools.plugin.javadoc.FullyQualifiedJavadocReference.MemberType;
import org.apache.maven.tools.plugin.javadoc.JavadocLinkGenerator;
import org.apache.maven.tools.plugin.javadoc.JavadocReference;

/** {@link ConverterContext} backed by JavaParser source declarations and symbol resolution. */
public class JavaClassConverterContext implements ConverterContext {

    /** The Mojo class whose documentation is being generated. */
    private final TypeDeclaration<?> mojoClass;

    /** The class declaring the converted Javadoc, possibly a superclass of the Mojo class. */
    private final TypeDeclaration<?> declaringClass;

    private final Node locationNode;
    private final JavaSourceModel sourceModel;
    private final Map<String, MojoAnnotatedClass> mojoAnnotatedClasses;

    /** The link generator, or {@code null} when no Javadoc site is configured. */
    private final JavadocLinkGenerator linkGenerator;

    private final int lineNumber;
    private final Map<String, Object> attributes = new HashMap<>();

    public JavaClassConverterContext(
            TypeDeclaration<?> mojoClass,
            JavaSourceModel sourceModel,
            Map<String, MojoAnnotatedClass> mojoAnnotatedClasses,
            JavadocLinkGenerator linkGenerator,
            int lineNumber) {
        this(mojoClass, mojoClass, mojoClass, sourceModel, mojoAnnotatedClasses, linkGenerator, lineNumber);
    }

    public JavaClassConverterContext(
            TypeDeclaration<?> mojoClass,
            TypeDeclaration<?> declaringClass,
            Node locationNode,
            JavaSourceModel sourceModel,
            Map<String, MojoAnnotatedClass> mojoAnnotatedClasses,
            JavadocLinkGenerator linkGenerator,
            int lineNumber) {
        this.mojoClass = mojoClass;
        this.declaringClass = declaringClass;
        this.locationNode = locationNode;
        this.sourceModel = sourceModel;
        this.mojoAnnotatedClasses = mojoAnnotatedClasses;
        this.linkGenerator = linkGenerator;
        this.lineNumber = lineNumber;
    }

    @Override
    public Optional<String> getModuleName() {
        return sourceModel.getModuleName(getPackageName());
    }

    @Override
    public String getPackageName() {
        return resolve(mojoClass).getPackageName();
    }

    @Override
    public String getLocation() {
        return sourceModel.getLocation(locationNode, lineNumber);
    }

    /** Returns whether {@code reference} identifies the Mojo class or one of its ancestors. */
    @Override
    public boolean isReferencedBy(FullyQualifiedJavadocReference reference) {
        ResolvedReferenceTypeDeclaration declaration = resolve(mojoClass);
        if (isClassReferencedByReference(declaration, reference)) {
            return true;
        }
        return declaration.getAllAncestors().stream()
                .map(ResolvedReferenceType::getTypeDeclaration)
                .filter(Optional::isPresent)
                .map(Optional::get)
                .anyMatch(type -> isClassReferencedByReference(type, reference));
    }

    private static boolean isClassReferencedByReference(
            ResolvedReferenceTypeDeclaration declaration, FullyQualifiedJavadocReference reference) {
        return declaration.getPackageName().equals(reference.getPackageName().orElse(""))
                && declaration.getClassName().equals(reference.getClassName().orElse(""));
    }

    @Override
    public boolean canGetUrl() {
        return linkGenerator != null;
    }

    @Override
    public URI getUrl(FullyQualifiedJavadocReference reference) {
        try {
            if (isReferencedBy(reference)
                    && MemberType.FIELD == reference.getMemberType().orElse(null)) {
                // Fields in the current Mojo link to parameter anchors on the same page.
                return new URI(null, null, reference.getMember().orElse(null));
            }
            Optional<String> fqClassName = reference.getFullyQualifiedClassName();
            if (fqClassName.isPresent()) {
                MojoAnnotatedClass mojoAnnotatedClass = mojoAnnotatedClasses.get(fqClassName.get());
                if (mojoAnnotatedClass != null
                        && mojoAnnotatedClass.getMojo() != null
                        && (!reference.getLabel().isPresent()
                                || MemberType.FIELD == reference.getMemberType().orElse(null))) {
                    // Fields and whole-class references to another Mojo link to that Mojo's page.
                    return new URI(
                            null,
                            "./" + mojoAnnotatedClass.getMojo().name() + "-mojo.html",
                            reference.getMember().orElse(null));
                }
            }
        } catch (URISyntaxException e) {
            throw new IllegalStateException("Error constructing a valid URL", e);
        }
        if (linkGenerator == null) {
            throw new IllegalStateException("No Javadoc Sites given to create URLs to");
        }
        return linkGenerator.createLink(reference);
    }

    @Override
    public FullyQualifiedJavadocReference resolveReference(JavadocReference reference) {
        Optional<FullyQualifiedJavadocReference> resolved;
        // First try the reference exactly as written, which handles fully qualified names.
        if (reference.getPackageNameClassName().isPresent()) {
            String name = reference.getPackageNameClassName().get();
            resolved = resolveNamedReference(name, reference.getMember(), reference.getLabel());
            if (resolved.isPresent()) {
                return resolved.get();
            }
        }

        // Search member-only references in the current class or interface first, then its ancestors.
        if (reference.getMember().isPresent()
                && !reference.getPackageNameClassName().isPresent()) {
            resolved = resolveMember(resolve(declaringClass), reference.getMember(), reference.getLabel(), true);
            if (resolved.isPresent()) {
                return resolved.get();
            }
        } else if (reference.getPackageNameClassName().isPresent()) {
            // Resolve simple and nested type names using Javadoc's lookup order.
            String name = reference.getPackageNameClassName().get();
            for (String candidate : classNameCandidates(name)) {
                resolved = resolveNamedReference(candidate, reference.getMember(), reference.getLabel());
                if (resolved.isPresent()) {
                    return resolved.get();
                }
            }
        }
        throw new IllegalArgumentException("Could not resolve javadoc reference " + reference);
    }

    private Optional<FullyQualifiedJavadocReference> resolveNamedReference(
            String name, Optional<String> member, Optional<String> label) {
        Optional<ResolvedReferenceTypeDeclaration> type = sourceModel.resolveType(name);
        if (type.isPresent()) {
            return resolveMember(type.get(), member, label, true);
        }
        // Package references cannot contain members.
        if (!member.isPresent() && sourceModel.hasPackage(name)) {
            return Optional.of(new FullyQualifiedJavadocReference(name, label, !sourceModel.isInternalPackage(name)));
        }
        return Optional.empty();
    }

    private List<String> classNameCandidates(String name) {
        List<String> candidates = new ArrayList<>();
        ResolvedReferenceTypeDeclaration declaration = resolve(declaringClass);
        // Search order: current package, implicit java.lang import, then explicit imports in declaration order.
        candidates.add(declaration.getPackageName() + "." + name);
        candidates.add("java.lang." + name);
        List<ImportDeclaration> imports = declaringClass
                .findCompilationUnit()
                .<List<ImportDeclaration>>map(unit -> new ArrayList<>(unit.getImports()))
                .orElseGet(Collections::emptyList);
        for (ImportDeclaration importDeclaration : imports) {
            if (importDeclaration.isStatic()) {
                continue;
            }
            String importName = importDeclaration.getNameAsString();
            if (importDeclaration.isAsterisk()) {
                candidates.add(importName + "." + name);
            } else if (name.equals(simpleName(importName))) {
                candidates.add(importName);
            } else if (name.startsWith(simpleName(importName) + ".")) {
                // An imported outer type may prefix a nested-type reference.
                candidates.add(
                        importName + name.substring(simpleName(importName).length()));
            }
        }
        return candidates;
    }

    private Optional<FullyQualifiedJavadocReference> resolveMember(
            ResolvedReferenceTypeDeclaration type,
            Optional<String> member,
            Optional<String> label,
            boolean includeAncestors) {
        if (!member.isPresent()) {
            return Optional.of(toReference(type, Optional.empty(), Optional.empty(), label));
        }

        String memberText = member.get();
        // Resolve ambiguous member text as a field, method, then constructor.
        Optional<ResolvedFieldDeclaration> field = findField(type, memberText, includeAncestors);
        if (field.isPresent()) {
            return Optional.of(toReference(
                    field.get().declaringType().asReferenceType(), member, Optional.of(MemberType.FIELD), label));
        }

        String methodName = methodName(memberText);
        Optional<List<String>> parameterTypes = parameterTypes(memberText);
        Optional<ResolvedMethodDeclaration> method = findMethod(type, methodName, parameterTypes, includeAncestors);
        if (method.isPresent()) {
            return Optional.of(toReference(
                    method.get().declaringType(),
                    Optional.of(canonicalMember(method.get())),
                    Optional.of(MemberType.METHOD),
                    label));
        }

        if (methodName.equals(type.getName())) {
            Optional<ResolvedConstructorDeclaration> constructor = findConstructor(type, parameterTypes);
            if (constructor.isPresent()) {
                return Optional.of(toReference(
                        type,
                        Optional.of(canonicalMember(constructor.get())),
                        Optional.of(MemberType.CONSTRUCTOR),
                        label));
            }
        }
        return Optional.empty();
    }

    private Optional<ResolvedFieldDeclaration> findField(
            ResolvedReferenceTypeDeclaration type, String name, boolean includeAncestors) {
        List<ResolvedFieldDeclaration> fields = includeAncestors ? type.getAllFields() : type.getDeclaredFields();
        return fields.stream().filter(field -> field.getName().equals(name)).findFirst();
    }

    private Optional<ResolvedMethodDeclaration> findMethod(
            ResolvedReferenceTypeDeclaration type,
            String name,
            Optional<List<String>> parameterTypes,
            boolean includeAncestors) {
        List<ResolvedReferenceTypeDeclaration> hierarchy = new ArrayList<>();
        hierarchy.add(type);
        if (includeAncestors) {
            type.getAllAncestors().stream()
                    .map(ResolvedReferenceType::getTypeDeclaration)
                    .filter(Optional::isPresent)
                    .map(Optional::get)
                    .forEach(hierarchy::add);
        }
        for (ResolvedReferenceTypeDeclaration declaration : hierarchy) {
            Optional<ResolvedMethodDeclaration> method = declaration.getDeclaredMethods().stream()
                    .filter(candidate -> candidate.getName().equals(name))
                    .filter(candidate -> matches(candidate, parameterTypes))
                    .findFirst();
            if (method.isPresent()) {
                return method;
            }
        }
        return Optional.empty();
    }

    private Optional<ResolvedConstructorDeclaration> findConstructor(
            ResolvedReferenceTypeDeclaration type, Optional<List<String>> parameterTypes) {
        return type.getConstructors().stream()
                .filter(candidate -> matches(candidate, parameterTypes))
                .findFirst();
    }

    private boolean matches(ResolvedMethodLikeDeclaration declaration, Optional<List<String>> parameterTypes) {
        if (!parameterTypes.isPresent()) {
            return true;
        }
        if (declaration.getNumberOfParams() != parameterTypes.get().size()) {
            return false;
        }
        for (int index = 0; index < declaration.getNumberOfParams(); index++) {
            String actual = declaration.getParam(index).getType().erasure().describe();
            if (!actual.equals(parameterTypes.get().get(index))) {
                return false;
            }
        }
        return true;
    }

    private Optional<List<String>> parameterTypes(String member) {
        int opening = member.indexOf('(');
        int closing = member.lastIndexOf(')');
        if (opening < 0 && closing < 0) {
            // Without parentheses, match the first overload found, mirroring javadoc.
            return Optional.empty();
        }
        if (opening < 0 || closing < opening) {
            throw new IllegalArgumentException("Found opening without closing parentheses or vice versa in " + member);
        }
        String arguments = member.substring(opening + 1, closing).trim();
        if (arguments.isEmpty()) {
            return Optional.of(Collections.emptyList());
        }
        List<String> result = new ArrayList<>();
        for (String argument : splitArguments(arguments)) {
            result.add(resolveParameterType(stripArgumentName(argument.trim())));
        }
        return Optional.of(result);
    }

    private static List<String> splitArguments(String arguments) {
        List<String> result = new ArrayList<>();
        int genericDepth = 0;
        int start = 0;
        for (int index = 0; index < arguments.length(); index++) {
            char ch = arguments.charAt(index);
            if (ch == '<') {
                genericDepth++;
            } else if (ch == '>') {
                genericDepth--;
            } else if (ch == ',' && genericDepth == 0) {
                result.add(arguments.substring(start, index));
                start = index + 1;
            }
        }
        result.add(arguments.substring(start));
        return result;
    }

    private static String stripArgumentName(String argument) {
        int genericDepth = 0;
        for (int index = argument.length() - 1; index >= 0; index--) {
            char ch = argument.charAt(index);
            if (ch == '>') {
                genericDepth++;
            } else if (ch == '<') {
                genericDepth--;
            } else if (Character.isWhitespace(ch) && genericDepth == 0) {
                return argument.substring(0, index).trim();
            }
        }
        return argument;
    }

    private String resolveParameterType(String typeName) {
        String normalized = eraseGenerics(typeName.replace("...", "[]"));
        int dimensions = 0;
        while (normalized.endsWith("[]")) {
            dimensions++;
            normalized = normalized.substring(0, normalized.length() - 2);
        }
        String resolved;
        if (isPrimitive(normalized)) {
            resolved = normalized;
        } else {
            List<String> candidates = new ArrayList<>();
            candidates.add(normalized);
            candidates.addAll(classNameCandidates(normalized));
            resolved = candidates.stream()
                    .filter(candidate -> sourceModel.resolveType(candidate).isPresent())
                    .findFirst()
                    .orElseThrow(
                            () -> new IllegalArgumentException("Found unresolvable method argument type " + typeName));
        }
        StringBuilder result = new StringBuilder(resolved);
        for (int index = 0; index < dimensions; index++) {
            result.append("[]");
        }
        return result.toString();
    }

    private static String eraseGenerics(String value) {
        StringBuilder result = new StringBuilder();
        int depth = 0;
        for (int index = 0; index < value.length(); index++) {
            char ch = value.charAt(index);
            if (ch == '<') {
                depth++;
            } else if (ch == '>') {
                depth--;
            } else if (depth == 0) {
                result.append(ch);
            }
        }
        return result.toString();
    }

    private static boolean isPrimitive(String name) {
        return "boolean".equals(name)
                || "byte".equals(name)
                || "char".equals(name)
                || "double".equals(name)
                || "float".equals(name)
                || "int".equals(name)
                || "long".equals(name)
                || "short".equals(name);
    }

    private FullyQualifiedJavadocReference toReference(
            ResolvedReferenceTypeDeclaration type,
            Optional<String> member,
            Optional<MemberType> memberType,
            Optional<String> label) {
        return new FullyQualifiedJavadocReference(
                type.getPackageName(),
                Optional.of(type.getClassName()),
                member,
                memberType,
                label,
                !sourceModel.isInternal(type));
    }

    @Override
    public String getStaticFieldValue(FullyQualifiedJavadocReference reference) {
        String fqcn = reference
                .getFullyQualifiedClassName()
                .orElseThrow(() ->
                        new IllegalArgumentException("Given reference does not specify a fully qualified class name!"));
        String fieldName = reference
                .getMember()
                .orElseThrow(() -> new IllegalArgumentException("Given reference does not specify a member!"));
        TypeDeclaration<?> type = sourceModel
                .getType(fqcn)
                .orElseThrow(() -> new IllegalArgumentException("Could not find source class " + fqcn));
        for (FieldDeclaration field : type.getFields()) {
            Optional<com.github.javaparser.ast.body.VariableDeclarator> variable = field.getVariables().stream()
                    .filter(candidate -> candidate.getNameAsString().equals(fieldName))
                    .findFirst();
            if (variable.isPresent()) {
                if (!field.isStatic()) {
                    throw new IllegalArgumentException(
                            "Field with name " + fieldName + " in class " + fqcn + " is not static");
                }
                return variable.get()
                        .getInitializer()
                        .map(initializer -> initializer.toString())
                        .orElseThrow(() -> new IllegalArgumentException(
                                "Field with name " + fieldName + " in class " + fqcn + " has no initializer"));
            }
        }
        throw new IllegalArgumentException("Could not find field with name " + fieldName + " in class " + fqcn);
    }

    @Override
    public URI getInternalJavadocSiteBaseUrl() {
        return linkGenerator.getInternalJavadocSiteBaseUrl();
    }

    private static ResolvedReferenceTypeDeclaration resolve(TypeDeclaration<?> declaration) {
        return declaration.resolve();
    }

    private static String methodName(String member) {
        int opening = member.indexOf('(');
        return opening < 0 ? member : member.substring(0, opening);
    }

    private static String canonicalMember(ResolvedMethodLikeDeclaration declaration) {
        return declaration.getName() + "("
                + declaration.formalParameterTypes().stream()
                        .map(type -> type.erasure().describe())
                        .collect(Collectors.joining(","))
                + ")";
    }

    private static String simpleName(String name) {
        int separator = name.lastIndexOf('.');
        return separator < 0 ? name : name.substring(separator + 1);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T setAttribute(String name, T value) {
        return (T) attributes.put(name, value);
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T getAttribute(String name, Class<T> clazz, T defaultValue) {
        return (T) attributes.getOrDefault(name, defaultValue);
    }
}