/*
 * 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.cling.invoker.mvnup.goals;

import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import eu.maveniverse.domtrip.Document;
import eu.maveniverse.domtrip.Element;
import eu.maveniverse.domtrip.maven.Coordinates;
import eu.maveniverse.domtrip.maven.MavenPomElements;
import org.apache.maven.api.cli.mvnup.UpgradeOptions;
import org.apache.maven.api.di.Named;
import org.apache.maven.api.di.Priority;
import org.apache.maven.api.di.Singleton;
import org.apache.maven.cling.invoker.mvnup.UpgradeContext;

import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.ARTIFACT_ID;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.BUILD;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCIES;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCY;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.DEPENDENCY_MANAGEMENT;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.GROUP_ID;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PARENT;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGIN;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PLUGINS;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILE;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.PROFILES;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.SUBPROJECT;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.SUBPROJECTS;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Elements.VERSION;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Files.DEFAULT_PARENT_RELATIVE_PATH;
import static eu.maveniverse.domtrip.maven.MavenPomElements.Files.POM_XML;
import static eu.maveniverse.domtrip.maven.MavenPomElements.ModelVersions.MODEL_VERSION_4_1_0;

/**
 * Strategy for applying Maven inference optimizations.
 * For 4.0.0 models: applies limited inference (parent-related only).
 * For 4.1.0+ models: applies full inference optimizations.
 * Removes redundant information that can be inferred by Maven during model building.
 */
@Named
@Singleton
@Priority(30)
public class InferenceStrategy extends AbstractUpgradeStrategy {

    @Override
    public boolean isApplicable(UpgradeContext context) {
        UpgradeOptions options = getOptions(context);

        // Handle --all option (overrides individual options)
        boolean useAll = options.all().orElse(false);
        if (useAll) {
            return true;
        }

        // Check if --infer is explicitly set
        if (options.infer().isPresent()) {
            return options.infer().get();
        }

        // Apply default behavior: if no specific options are provided, enable --infer
        if (options.infer().isEmpty()
                && options.model().isEmpty()
                && options.plugins().isEmpty()
                && options.modelVersion().isEmpty()) {
            return true;
        }

        return false;
    }

    @Override
    public String getDescription() {
        return "Applying Maven inference optimizations";
    }

    @Override
    public UpgradeResult doApply(UpgradeContext context, Map<Path, Document> pomMap) {
        Set<Path> processedPoms = new HashSet<>();
        Set<Path> modifiedPoms = new HashSet<>();
        Set<Path> errorPoms = new HashSet<>();

        // Compute all GAVs for inference
        Set<Coordinates> allGAVs = computeAllArtifactCoordinates(context, pomMap);

        for (Map.Entry<Path, Document> entry : pomMap.entrySet()) {
            Path pomPath = entry.getKey();
            Document pomDocument = entry.getValue();
            processedPoms.add(pomPath);

            String currentVersion = ModelVersionUtils.detectModelVersion(pomDocument);
            context.info(pomPath + " (current: " + currentVersion + ")");
            context.indent();

            try {
                if (!ModelVersionUtils.isEligibleForInference(currentVersion)) {
                    context.warning(
                            "Model version " + currentVersion + " not eligible for inference (requires >= 4.0.0)");
                    continue;
                }

                boolean hasInferences = false;

                // Apply limited parent inference for all eligible models (4.0.0+)
                hasInferences |= applyLimitedParentInference(context, pomDocument);

                // Apply full inference optimizations only for 4.1.0+ models
                if (MODEL_VERSION_4_1_0.equals(currentVersion) || ModelVersionUtils.isNewerThan410(currentVersion)) {
                    hasInferences |= applyFullParentInference(context, pomMap, pomDocument);
                    hasInferences |= applyDependencyInference(context, allGAVs, pomDocument);
                    hasInferences |= applyDependencyInferenceRedundancy(context, pomMap, pomDocument);
                    hasInferences |= applySubprojectsInference(context, pomDocument, pomPath);
                    hasInferences |= applyModelVersionInference(context, pomDocument);
                }

                if (hasInferences) {
                    modifiedPoms.add(pomPath);
                    if (MODEL_VERSION_4_1_0.equals(currentVersion)
                            || ModelVersionUtils.isNewerThan410(currentVersion)) {
                        context.success("Full inference optimizations applied");
                    } else {
                        context.success("Limited inference optimizations applied (parent-related only)");
                    }
                } else {
                    context.success("No inference optimizations needed");
                }
            } catch (Exception e) {
                context.failure("Failed to apply inference optimizations" + ": " + e.getMessage());
                errorPoms.add(pomPath);
            } finally {
                context.unindent();
            }
        }

        return new UpgradeResult(processedPoms, modifiedPoms, errorPoms);
    }

    /**
     * Applies limited parent-related inference optimizations for Maven 4.0.0+ models.
     * Removes redundant child groupId/version that can be inferred from parent.
     */
    private boolean applyLimitedParentInference(UpgradeContext context, Document pomDocument) {
        Element root = pomDocument.root();

        // Check if this POM has a parent
        Element parentElement = root.childElement(PARENT).orElse(null);
        if (parentElement == null) {
            return false;
        }

        // Apply limited inference (child groupId/version removal only)
        return trimParentElementLimited(context, root, parentElement);
    }

    /**
     * Applies full parent-related inference optimizations for Maven 4.1.0+ models.
     * Removes redundant parent elements that can be inferred from relativePath.
     */
    private boolean applyFullParentInference(UpgradeContext context, Map<Path, Document> pomMap, Document pomDocument) {
        Element root = pomDocument.root();

        // Check if this POM has a parent
        Element parentElement = root.childElement(PARENT).orElse(null);
        if (parentElement == null) {
            return false;
        }

        // Apply full inference (parent element trimming based on relativePath)
        return trimParentElementFull(context, root, parentElement, pomMap);
    }

    /**
     * Applies dependency-related inference optimizations.
     * Removes managed dependencies that point to project artifacts.
     */
    private boolean applyDependencyInference(UpgradeContext context, Set<Coordinates> allGAVs, Document pomDocument) {
        boolean hasChanges = false;
        Element root = pomDocument.root();

        // Check dependencyManagement section
        Element dependencyManagement = root.childElement(DEPENDENCY_MANAGEMENT).orElse(null);
        if (dependencyManagement != null) {
            Element dependencies =
                    dependencyManagement.childElement(DEPENDENCIES).orElse(null);
            if (dependencies != null) {
                hasChanges |=
                        removeManagedDependenciesFromSection(context, dependencies, allGAVs, DEPENDENCY_MANAGEMENT);
            }
        }

        // Check profiles for dependencyManagement
        boolean profileChanges = root.childElement(PROFILES).stream()
                .flatMap(profiles -> profiles.childElements(PROFILE))
                .map(profile -> profile.childElement(DEPENDENCY_MANAGEMENT)
                        .flatMap(dm -> dm.childElement(DEPENDENCIES))
                        .map(deps -> removeManagedDependenciesFromSection(
                                context, deps, allGAVs, "profile dependencyManagement"))
                        .orElse(false))
                .reduce(false, Boolean::logicalOr);

        hasChanges |= profileChanges;

        return hasChanges;
    }

    /**
     * Applies dependency inference redundancy optimizations.
     * Removes redundant groupId/version from regular dependencies that can be inferred from project artifacts.
     */
    private boolean applyDependencyInferenceRedundancy(
            UpgradeContext context, Map<Path, Document> pomMap, Document pomDocument) {
        Element root = pomDocument.root();
        boolean hasChanges = false;

        // Process main dependencies
        Element dependenciesElement = root.childElement(DEPENDENCIES).orElse(null);
        if (dependenciesElement != null) {
            hasChanges |= removeDependencyInferenceFromSection(context, dependenciesElement, pomMap, DEPENDENCIES);
        }

        // Process profile dependencies
        boolean profileDependencyChanges = root.childElement(PROFILES).stream()
                .flatMap(profiles -> profiles.childElements(PROFILE))
                .map(profile -> profile.childElement(DEPENDENCIES)
                        .map(deps ->
                                removeDependencyInferenceFromSection(context, deps, pomMap, "profile dependencies"))
                        .orElse(false))
                .reduce(false, Boolean::logicalOr);

        hasChanges |= profileDependencyChanges;

        // Process build plugin dependencies
        boolean pluginDependencyChanges =
                root.childElement(BUILD).flatMap(build -> build.childElement(PLUGINS)).stream()
                        .flatMap(plugins -> plugins.childElements(PLUGIN))
                        .map(plugin -> plugin.childElement(DEPENDENCIES)
                                .map(deps -> removeDependencyInferenceFromSection(
                                        context, deps, pomMap, "plugin dependencies"))
                                .orElse(false))
                        .reduce(false, Boolean::logicalOr);

        hasChanges |= pluginDependencyChanges;

        return hasChanges;
    }

    /**
     * Applies subprojects-related inference optimizations.
     * Removes redundant subprojects lists that match direct children.
     */
    private boolean applySubprojectsInference(UpgradeContext context, Document pomDocument, Path pomPath) {
        boolean hasChanges = false;
        Element root = pomDocument.root();

        // Check main subprojects
        Element subprojectsElement = root.childElement(SUBPROJECTS).orElse(null);
        if (subprojectsElement != null) {
            if (isSubprojectsListRedundant(subprojectsElement, pomPath)) {
                DomUtils.removeElement(subprojectsElement);
                context.detail("Removed: redundant subprojects list (matches direct children)");
                hasChanges = true;
            }
        }

        // Check profiles for subprojects
        boolean profileSubprojectsChanges = root.childElement(PROFILES).stream()
                .flatMap(profiles -> profiles.childElements(PROFILE))
                .map(profile -> profile.childElement(SUBPROJECTS)
                        .filter(subprojects -> isSubprojectsListRedundant(subprojects, pomPath))
                        .map(subprojects -> {
                            DomUtils.removeElement(subprojects);
                            context.detail(
                                    "Removed: redundant subprojects list from profile (matches direct children)");
                            return true;
                        })
                        .orElse(false))
                .reduce(false, Boolean::logicalOr);

        hasChanges |= profileSubprojectsChanges;

        return hasChanges;
    }

    /**
     * Applies model version inference optimization.
     * Removes modelVersion element when it can be inferred from namespace.
     */
    private boolean applyModelVersionInference(UpgradeContext context, Document pomDocument) {
        String currentVersion = ModelVersionUtils.detectModelVersion(pomDocument);

        // Only remove modelVersion for 4.1.0+ models where it can be inferred from namespace
        if (MODEL_VERSION_4_1_0.equals(currentVersion) || ModelVersionUtils.isNewerThan410(currentVersion)) {

            if (ModelVersionUtils.removeModelVersion(pomDocument)) {
                context.detail("Removed: modelVersion element (can be inferred from namespace)");
                return true;
            }
        }

        return false;
    }

    /**
     * Applies limited parent inference for 4.0.0 models.
     * Only removes child groupId/version when they match parent.
     */
    private boolean trimParentElementLimited(UpgradeContext context, Element root, Element parentElement) {
        boolean hasChanges = false;

        // Get parent GAV
        String parentGroupId = parentElement.childText(MavenPomElements.Elements.GROUP_ID);
        String parentVersion = parentElement.childText(MavenPomElements.Elements.VERSION);

        // Get child GAV
        String childGroupId = root.childText(MavenPomElements.Elements.GROUP_ID);
        String childVersion = root.childText(MavenPomElements.Elements.VERSION);

        // Remove child groupId if it matches parent groupId
        if (childGroupId != null && Objects.equals(childGroupId, parentGroupId)) {
            Element childGroupIdElement = root.childElement(GROUP_ID).orElse(null);
            if (childGroupIdElement != null) {
                DomUtils.removeElement(childGroupIdElement);
                context.detail("Removed: child groupId (matches parent)");
                hasChanges = true;
            }
        }

        // Remove child version if it matches parent version
        if (childVersion != null && Objects.equals(childVersion, parentVersion)) {
            Element childVersionElement = root.childElement("version").orElse(null);
            if (childVersionElement != null) {
                DomUtils.removeElement(childVersionElement);
                context.detail("Removed: child version (matches parent)");
                hasChanges = true;
            }
        }

        return hasChanges;
    }

    /**
     * Applies full parent inference for 4.1.0+ models.
     * Removes parent groupId/version/artifactId when they can be inferred.
     */
    private boolean trimParentElementFull(
            UpgradeContext context, Element root, Element parentElement, Map<Path, Document> pomMap) {
        boolean hasChanges = false;

        // Get child GAV before applying any changes
        String childGroupId = root.childText(MavenPomElements.Elements.GROUP_ID);
        String childVersion = root.childText(MavenPomElements.Elements.VERSION);

        // First apply limited inference (child elements) - this removes matching child groupId/version
        hasChanges |= trimParentElementLimited(context, root, parentElement);

        // Only remove parent elements if the parent is in the same reactor (not external)
        if (isParentInReactor(parentElement, pomMap, context)) {
            // Remove parent groupId if child has no explicit groupId
            if (childGroupId == null) {
                Element parentGroupIdElement =
                        parentElement.childElement(GROUP_ID).orElse(null);
                if (parentGroupIdElement != null) {
                    DomUtils.removeElement(parentGroupIdElement);
                    context.detail("Removed: parent groupId (child has no explicit groupId)");
                    hasChanges = true;
                }
            }

            // Remove parent version if child has no explicit version
            if (childVersion == null) {
                Element parentVersionElement =
                        parentElement.childElement(VERSION).orElse(null);
                if (parentVersionElement != null) {
                    DomUtils.removeElement(parentVersionElement);
                    context.detail("Removed: parent version (child has no explicit version)");
                    hasChanges = true;
                }
            }

            // Remove parent artifactId if it can be inferred from relativePath
            if (canInferParentArtifactId(parentElement, pomMap)) {
                Element parentArtifactIdElement =
                        parentElement.childElement(ARTIFACT_ID).orElse(null);
                if (parentArtifactIdElement != null) {
                    DomUtils.removeElement(parentArtifactIdElement);
                    context.detail("Removed: parent artifactId (can be inferred from relativePath)");
                    hasChanges = true;
                }
            }
        }

        return hasChanges;
    }

    /**
     * Determines if the parent is part of the same reactor (multi-module project)
     * vs. an external parent POM by checking if the parent exists in the pomMap.
     */
    private boolean isParentInReactor(Element parentElement, Map<Path, Document> pomMap, UpgradeContext context) {
        // If relativePath is explicitly set to empty, parent is definitely external
        String relativePath = parentElement.childText(MavenPomElements.Elements.RELATIVE_PATH);
        if (relativePath != null && relativePath.trim().isEmpty()) {
            return false;
        }

        // Extract parent GAV
        String parentGroupId = parentElement.childText(MavenPomElements.Elements.GROUP_ID);
        String parentArtifactId = parentElement.childText(MavenPomElements.Elements.ARTIFACT_ID);
        String parentVersion = parentElement.childText(MavenPomElements.Elements.VERSION);

        if (parentGroupId == null || parentArtifactId == null || parentVersion == null) {
            // Cannot determine parent GAV, assume external
            return false;
        }

        Coordinates parentGAV = Coordinates.of(parentGroupId, parentArtifactId, parentVersion);

        // Check if any POM in our reactor matches the parent GAV using GAVUtils
        for (Document pomDocument : pomMap.values()) {
            Coordinates pomGAV =
                    AbstractUpgradeStrategy.extractArtifactCoordinatesWithParentResolution(context, pomDocument);
            if (pomGAV != null && coordinatesMatch(pomGAV, parentGAV)) {
                return true;
            }
        }

        // Parent not found in reactor, must be external
        return false;
    }

    private static boolean coordinatesMatch(Coordinates a, Coordinates b) {
        return Objects.equals(a.groupId(), b.groupId())
                && Objects.equals(a.artifactId(), b.artifactId())
                && Objects.equals(a.version(), b.version());
    }

    /**
     * Determines if parent artifactId can be inferred from relativePath.
     */
    private boolean canInferParentArtifactId(Element parentElement, Map<Path, Document> pomMap) {
        // Get relativePath (default is "../pom.xml" if not specified)
        String relativePath = parentElement.childText(MavenPomElements.Elements.RELATIVE_PATH);
        if (relativePath == null || relativePath.trim().isEmpty()) {
            relativePath = DEFAULT_PARENT_RELATIVE_PATH; // Maven default
        }

        // Only infer artifactId if relativePath is the default and we have multiple POMs
        // indicating this is likely a multi-module project
        return DEFAULT_PARENT_RELATIVE_PATH.equals(relativePath) && pomMap.size() > 1;
    }

    /**
     * Checks if a subprojects list is redundant (matches direct child directories with pom.xml).
     */
    private boolean isSubprojectsListRedundant(Element subprojectsElement, Path pomPath) {
        List<Element> subprojectElements =
                subprojectsElement.childElements(SUBPROJECT).toList();
        if (subprojectElements.isEmpty()) {
            return true; // Empty list is redundant
        }

        // Get the directory containing this POM
        Path parentDir = pomPath.getParent();
        if (parentDir == null) {
            return false;
        }

        // Get declared subprojects
        Set<String> declaredSubprojects = subprojectElements.stream()
                .map(Element::textContentTrimmed)
                .filter(name -> !name.isEmpty())
                .collect(Collectors.toSet());

        // Get list of actual direct child directories with pom.xml
        Set<String> actualSubprojects = new HashSet<>();
        try {
            if (Files.exists(parentDir) && Files.isDirectory(parentDir)) {
                try (Stream<Path> children = Files.list(parentDir)) {
                    children.filter(Files::isDirectory)
                            .filter(dir -> Files.exists(dir.resolve(POM_XML)))
                            .forEach(dir ->
                                    actualSubprojects.add(dir.getFileName().toString()));
                }
            }
        } catch (Exception e) {
            // If we can't read the directory, assume not redundant
            return false;
        }

        // Lists are redundant if they match exactly
        return declaredSubprojects.equals(actualSubprojects);
    }

    /**
     * Helper method to remove managed dependencies from a specific dependencies section.
     */
    private boolean removeManagedDependenciesFromSection(
            UpgradeContext context, Element dependencies, Set<Coordinates> allGAVs, String sectionName) {
        List<Element> dependencyElements =
                dependencies.childElements(DEPENDENCY).toList();

        List<Element> projectArtifacts = dependencyElements.stream()
                .filter(dependency -> {
                    String groupId = dependency.childText(MavenPomElements.Elements.GROUP_ID);
                    String artifactId = dependency.childText(MavenPomElements.Elements.ARTIFACT_ID);

                    if (groupId != null && artifactId != null) {
                        boolean isProjectArtifact = allGAVs.stream()
                                .anyMatch(gav -> Objects.equals(gav.groupId(), groupId)
                                        && Objects.equals(gav.artifactId(), artifactId));

                        if (isProjectArtifact) {
                            context.detail("Removed: managed dependency " + groupId + ":" + artifactId + " from "
                                    + sectionName + " (project artifact)");
                            return true;
                        }
                    }
                    return false;
                })
                .toList();

        // Remove project artifacts while preserving formatting
        projectArtifacts.forEach(DomUtils::removeElement);

        return !projectArtifacts.isEmpty();
    }

    /**
     * Helper method to remove dependency inference redundancy from a specific dependencies section.
     */
    private boolean removeDependencyInferenceFromSection(
            UpgradeContext context, Element dependencies, Map<Path, Document> pomMap, String sectionName) {
        List<Element> dependencyElements =
                dependencies.childElements(DEPENDENCY).toList();
        boolean hasChanges = false;

        for (Element dependency : dependencyElements) {
            String groupId = dependency.childText(MavenPomElements.Elements.GROUP_ID);
            String artifactId = dependency.childText(MavenPomElements.Elements.ARTIFACT_ID);
            String version = dependency.childText(MavenPomElements.Elements.VERSION);

            if (artifactId != null) {
                // Try to find the dependency POM in our pomMap
                Document dependencyPom = findDependencyPom(context, pomMap, groupId, artifactId);
                if (dependencyPom != null) {
                    // Check if we can infer groupId
                    if (groupId != null && canInferDependencyGroupId(context, dependencyPom, groupId)) {
                        Element groupIdElement =
                                dependency.childElement(GROUP_ID).orElse(null);
                        if (groupIdElement != null) {
                            DomUtils.removeElement(groupIdElement);
                            context.detail("Removed: " + "dependency groupId " + groupId + " from " + sectionName
                                    + " (can be inferred from project)");
                            hasChanges = true;
                        }
                    }

                    // Check if we can infer version
                    if (version != null && canInferDependencyVersion(context, dependencyPom, version)) {
                        Element versionElement =
                                dependency.childElement(VERSION).orElse(null);
                        if (versionElement != null) {
                            DomUtils.removeElement(versionElement);
                            context.detail("Removed: " + "dependency version " + version + " from " + sectionName
                                    + " (can be inferred from project)");
                            hasChanges = true;
                        }
                    }
                }
            }
        }

        return hasChanges;
    }

    /**
     * Finds a dependency POM in the pomMap by groupId and artifactId.
     */
    private Document findDependencyPom(
            UpgradeContext context, Map<Path, Document> pomMap, String groupId, String artifactId) {
        return pomMap.values().stream()
                .filter(pomDocument -> {
                    Coordinates gav = AbstractUpgradeStrategy.extractArtifactCoordinatesWithParentResolution(
                            context, pomDocument);
                    return gav != null
                            && Objects.equals(gav.groupId(), groupId)
                            && Objects.equals(gav.artifactId(), artifactId);
                })
                .findFirst()
                .orElse(null);
    }

    /**
     * Determines if a dependency version can be inferred from the project artifact.
     */
    private boolean canInferDependencyVersion(UpgradeContext context, Document dependencyPom, String declaredVersion) {
        Coordinates projectGav =
                AbstractUpgradeStrategy.extractArtifactCoordinatesWithParentResolution(context, dependencyPom);
        if (projectGav == null || projectGav.version() == null) {
            return false;
        }

        // We can infer the version if the declared version matches the project version
        return Objects.equals(declaredVersion, projectGav.version());
    }

    /**
     * Determines if a dependency groupId can be inferred from the project artifact.
     */
    private boolean canInferDependencyGroupId(UpgradeContext context, Document dependencyPom, String declaredGroupId) {
        Coordinates projectGav =
                AbstractUpgradeStrategy.extractArtifactCoordinatesWithParentResolution(context, dependencyPom);
        if (projectGav == null || projectGav.groupId() == null) {
            return false;
        }

        // We can infer the groupId if the declared groupId matches the project groupId
        return Objects.equals(declaredGroupId, projectGav.groupId());
    }
}
