/*
 * 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.archetype.ui.generation;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;

import org.apache.commons.lang3.math.NumberUtils;
import org.apache.maven.archetype.catalog.Archetype;
import org.apache.maven.archetype.ui.ArchetypeDefinition;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.DefaultArtifactVersion;
import org.codehaus.plexus.components.interactivity.Prompter;
import org.codehaus.plexus.components.interactivity.PrompterException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Named("default")
@Singleton
public class DefaultArchetypeSelectionQueryer implements ArchetypeSelectionQueryer {
    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultArchetypeSelectionQueryer.class);

    @Inject
    @Named("archetype")
    private Prompter prompter;

    @Override
    public Archetype selectArchetype(Map<String, List<Archetype>> catalogs) throws PrompterException {
        return selectArchetype(catalogs, null);
    }

    @Override
    public Archetype selectArchetype(Map<String, List<Archetype>> catalogs, ArchetypeDefinition defaultDefinition)
            throws PrompterException {
        Archetype selection = null;
        Map<String, List<Archetype>> filteredCatalogs = catalogs;

        do {
            StringBuilder query = new StringBuilder("Choose archetype:\n");

            Set<String> archetypeKeys = new HashSet<>();
            List<String> answers = new ArrayList<>();
            Map<String, Archetype> archetypeAnswerMap = new HashMap<>();

            int counter = 0;
            int defaultSelection = 0;

            for (Map.Entry<String, List<Archetype>> entry : filteredCatalogs.entrySet()) {
                String catalog = entry.getKey();

                for (Archetype archetype : entry.getValue()) {
                    String archetypeKey = archetype.getGroupId() + ":" + archetype.getArtifactId();

                    if (!archetypeKeys.add(archetypeKey)) {
                        continue;
                    }

                    counter++;

                    String description = archetype.getDescription();
                    if (description == null) {
                        description = "-";
                    }

                    String answer = String.valueOf(counter);

                    query.append(answer + ": " + catalog + " -> " + archetype.getGroupId() + ":"
                            + archetype.getArtifactId() + " (" + description + ")\n");

                    answers.add(answer);

                    archetypeAnswerMap.put(answer, archetype);

                    // the version is not tested. This is intentional.
                    if (defaultDefinition != null
                            && archetype.getGroupId().equals(defaultDefinition.getGroupId())
                            && archetype.getArtifactId().equals(defaultDefinition.getArtifactId())) {
                        defaultSelection = counter;
                    }
                }
            }

            if (counter == 0) {
                query.append("   Your filter doesn't match any archetype (hint: enter to return to initial list)\n");
            }

            query.append("Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): ");

            String answer;
            if (defaultSelection == 0) {
                answer = prompter.prompt(query.toString());
            } else {
                answer = prompter.prompt(query.toString(), Integer.toString(defaultSelection));
            }

            if (NumberUtils.isCreatable(answer)) {
                selection = archetypeAnswerMap.get(answer);
            } else {
                // not a number so apply filter and ask again
                filteredCatalogs = ArchetypeSelectorUtils.getFilteredArchetypesByCatalog(catalogs, answer);
            }
        } while (selection == null);

        return selectVersion(catalogs, selection.getGroupId(), selection.getArtifactId());
    }

    private Archetype selectVersion(Map<String, List<Archetype>> catalogs, String groupId, String artifactId)
            throws PrompterException {
        SortedMap<ArtifactVersion, Archetype> archetypeVersionsMap = new TreeMap<>();

        for (Map.Entry<String, List<Archetype>> entry : catalogs.entrySet()) {
            for (Archetype archetype : entry.getValue()) {
                if (!groupId.equals(archetype.getGroupId()) || !artifactId.equals(archetype.getArtifactId())) {
                    continue;
                }

                ArtifactVersion version = new DefaultArtifactVersion(archetype.getVersion());

                // don't override the first catalog containing a defined version of the artifact
                if (!archetypeVersionsMap.containsKey(version)) {
                    archetypeVersionsMap.put(version, archetype);
                }
            }
        }

        if (archetypeVersionsMap.size() == 1) {
            return archetypeVersionsMap.values().iterator().next();
        }

        // let the user choose between available versions
        StringBuilder query = new StringBuilder("Choose " + groupId + ":" + artifactId + " version: \n");

        List<String> answers = new ArrayList<>();
        Map<String, Archetype> answerMap = new HashMap<>();

        int counter = 1;
        String mapKey = null;

        for (Map.Entry<ArtifactVersion, Archetype> entry : archetypeVersionsMap.entrySet()) {
            ArtifactVersion version = entry.getKey();
            Archetype archetype = entry.getValue();

            mapKey = String.valueOf(counter);

            query.append(mapKey + ": " + version + "\n");

            answers.add(mapKey);

            answerMap.put(mapKey, archetype);

            counter++;
        }

        query.append("Choose a number: ");

        Archetype archetype = null;

        do {
            String answer = prompter.prompt(query.toString(), answers, mapKey);

            archetype = answerMap.get(answer);
        } while (archetype == null);

        return archetype;
    }

    public void setPrompter(Prompter prompter) {
        this.prompter = prompter;
    }
}
