/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 ~ 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.sling.scriptingbundle.maven.plugin;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;

import org.apache.commons.lang3.StringUtils;
import org.apache.maven.plugin.logging.Log;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.osgi.framework.Version;
import org.osgi.framework.VersionRange;


class ResourceTypeFolderAnalyser {

    private final Log log;
    private final Path scriptsDirectory;
    private final ResourceTypeFolderPredicate resourceTypeFolderPredicate;

    ResourceTypeFolderAnalyser(@NotNull Log log, @NotNull Path scriptsDirectory) {
        this.log = log;
        this.scriptsDirectory = scriptsDirectory;
        this.resourceTypeFolderPredicate = new ResourceTypeFolderPredicate(log);
    }

    Capabilities getCapabilities(@NotNull Path resourceTypeDirectory, @NotNull Map<String, String> scriptEngineMappings) {
        Set<ProvidedCapability> providedCapabilities = new LinkedHashSet<>();
        Set<RequiredCapability> requiredCapabilities = new LinkedHashSet<>();
        String version = null;
        String resourceType = null;
        try {
            Path fileName = resourceTypeDirectory.getFileName();
            if (fileName != null) {
                version = Version.parseVersion(fileName.toString()).toString();
            }
        } catch (IllegalArgumentException ignored) {
            log.debug("No resourceType version detected in " + scriptsDirectory.resolve(resourceTypeDirectory).toString());
        }
        if (StringUtils.isNotEmpty(version)) {
            Path parent = resourceTypeDirectory.getParent();
            if (parent != null) {
                resourceType = getResourceType(parent);
            }
        } else {
            resourceType = getResourceType(resourceTypeDirectory);
        }
        if (resourceType != null) {
            String resourceTypeLabel = getResourceTypeLabel(resourceType);
            try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(scriptsDirectory.resolve(resourceTypeDirectory))) {
                for (Path directoryEntry : directoryStream) {
                    if (Files.isRegularFile(directoryEntry)) {
                        Path file = directoryEntry.getFileName();
                        if (file != null) {
                            if (MetadataMojo.EXTENDS_FILE.equals(file.toString())) {
                                processExtendsFile(resourceType, version, directoryEntry, providedCapabilities, requiredCapabilities);
                            } else if (MetadataMojo.REQUIRES_FILE.equals(file.toString())) {
                                processRequiresFile(directoryEntry, requiredCapabilities);
                            } else {
                                processScriptFile(resourceTypeDirectory, scriptEngineMappings, directoryEntry, resourceType, version,
                                        resourceTypeLabel, providedCapabilities);
                            }
                        }
                    } else if (Files.isDirectory(directoryEntry) && !resourceTypeFolderPredicate.test(directoryEntry)) {
                        try (Stream<Path> subtree = Files.walk(directoryEntry)) {
                            Iterator<Path> subtreeIterator = subtree.iterator();
                            while (subtreeIterator.hasNext()) {
                                Path subtreeEntry = subtreeIterator.next();
                                if (Files.isRegularFile(subtreeEntry)) {
                                    processScriptFile(resourceTypeDirectory, scriptEngineMappings, subtreeEntry, resourceType, version,
                                            resourceTypeLabel, providedCapabilities);
                                }
                            }
                        }
                    }
                }
            } catch (IOException | IllegalArgumentException e) {
                log.warn(String.format("Cannot analyse folder %s.", scriptsDirectory.resolve(resourceTypeDirectory).toString()), e);
            }
        }

        return new Capabilities(providedCapabilities, requiredCapabilities);
    }

    private void processExtendsFile(@NotNull String resourceType, @Nullable String version, @NotNull Path extendsFile,
                                    @NotNull Set<ProvidedCapability> providedCapabilities,
                                    @NotNull Set<RequiredCapability> requiredCapabilities)
            throws IOException {
        List<String> extendResources = Files.readAllLines(extendsFile, StandardCharsets.UTF_8);
        if (extendResources.size() == 1) {
            String extend = extendResources.get(0);
            if (StringUtils.isNotEmpty(extend)) {
                String[] extendParts = extend.split(";");
                String extendedResourceType = extendParts[0];
                String extendedResourceTypeVersion = extendParts.length > 1 ? extendParts[1] : null;
                providedCapabilities.add(
                        ProvidedCapability.builder()
                                .withResourceType(resourceType)
                                .withVersion(version)
                                .withExtendsResourceType(extendedResourceType)
                                .build());
                RequiredCapability.Builder requiredBuilder =
                        RequiredCapability.builder().withResourceType(extendedResourceType);
                try {
                    if (extendedResourceTypeVersion != null) {
                        requiredBuilder.withVersionRange(
                                VersionRange.valueOf(extendedResourceTypeVersion.substring(extendedResourceTypeVersion.indexOf('=') + 1)));
                    }
                } catch (IllegalArgumentException ignored) {
                    log.warn(String.format("Invalid version range '%s' defined for extended resourceType '%s'" +
                                    " in file %s.", extendedResourceTypeVersion, extendedResourceType,
                            extendsFile.toString()));
                }
                requiredCapabilities.add(requiredBuilder.build());
            }
        }
    }

    private void processRequiresFile(@NotNull Path requiresFile,
                                     @NotNull Set<RequiredCapability> requiredCapabilities)
            throws IOException {
        List<String> requiredResourceTypes = Files.readAllLines(requiresFile, StandardCharsets.UTF_8);
        for (String requiredResourceType : requiredResourceTypes) {
            if (StringUtils.isNotEmpty(requiredResourceType)) {
                String[] requireParts = requiredResourceType.split(";");
                String resourceType = requireParts[0];
                String version = requireParts.length > 1 ? requireParts[1] : null;
                RequiredCapability.Builder requiredBuilder =
                        RequiredCapability.builder().withResourceType(resourceType);
                try {
                    if (version != null) {
                        requiredBuilder.withVersionRange(VersionRange.valueOf(version.substring(version.indexOf('=') + 1)));
                    }
                } catch (IllegalArgumentException ignored) {
                    log.warn(String.format("Invalid version range '%s' defined for required resourceType '%s'" +
                                    " in file %s.", version, resourceType,
                            requiresFile.toString()));
                }
                requiredCapabilities.add(requiredBuilder.build());
            }
        }
    }

    private void processScriptFile(@NotNull Path resourceTypeDirectory, @NotNull Map<String, String> scriptEngineMappings,
                                   @NotNull Path script, @NotNull String resourceType, @Nullable String version,
                                   @NotNull String resourceTypeLabel, @NotNull Set<ProvidedCapability> providedCapabilities) {
        Path scriptFile = script.getFileName();
        if (scriptFile != null) {
            Path relativeResourceTypeFolder = resourceTypeDirectory.relativize(script);
            int pathSegments = relativeResourceTypeFolder.getNameCount();
            ArrayList<String> selectors = new ArrayList<>();
            if (pathSegments > 1) {
                for (int i = 0; i < pathSegments - 1; i++) {
                    selectors.add(relativeResourceTypeFolder.getName(i).toString());
                }
            }
            String[] parts = scriptFile.toString().split("\\.");
            if (parts.length >= 2 && parts.length <= 4) {
                String method = null;
                String requestExtension = null;
                String scriptExtension = parts[parts.length - 1];
                String first = parts[0];
                if (!first.equals(resourceTypeLabel)) {
                    if (MetadataMojo.METHODS.contains(first)) {
                        // method script
                        method = first;
                        if ("HEAD".equals(method) || "GET".equals(method)) {
                            if (parts.length == 4) {
                                selectors.add(parts[1]);
                                requestExtension = parts[2];
                            } else if (parts.length == 3) {
                                String middlePart = parts[1];
                                if (MimeTypeChecker.hasMimeType(middlePart)) {
                                    requestExtension = middlePart;
                                } else {
                                    selectors.add(middlePart);
                                }
                            }
                        } else {
                            if (parts.length != 2) {
                                log.warn(String.format("Script %s doesn't respect naming conventions. Only GET and HEAD scripts are " +
                                        "allowed to use additional selectors or request extensions.", script.toString()));
                                return;
                            }
                        }
                    } else {
                        // selector script
                        if (parts.length == 3) {
                            selectors.add(first);
                            requestExtension = parts[1];
                        } else if (parts.length == 2) {
                            selectors.add(first);
                        } else {
                            log.warn(String.format("Script %s doesn't respect naming conventions. A selector script can contain at max " +
                                    "the request extension, but no other selectors."));
                            return;
                        }
                    }
                } else {
                    // main script
                    if (parts.length > 3) {
                        log.warn(String.format("Script %s doesn't respect naming conventions. The main script can contain at max " +
                                "the request extension, but no other selectors."));
                        return;
                    }
                    if (parts.length == 3) {
                        requestExtension = parts[parts.length - 2];
                    }
                }
                String scriptEngine = scriptEngineMappings.get(scriptExtension);
                if (StringUtils.isNotEmpty(scriptEngine)) {
                    providedCapabilities.add(ProvidedCapability.builder().withResourceType(resourceType).withScriptEngine(scriptEngine)
                            .withVersion(version).withSelectors(selectors).withRequestExtension(requestExtension).withRequestMethod(method)
                            .build());
                } else {
                    log.warn(String.format("Unknown script engine mapping for script %s. Skipping.", scriptFile.toString()));
                }
            } else {
                log.warn(String.format("Skipping script %s since it either does not target a script engine or it provides too many " +
                        "selector parts in its name.", script.toString()));
            }
        } else {
            log.warn(String.format("Skipping path %s since it has 0 elements.", script.toString()));
        }

    }

    private String getResourceType(@NotNull Path resourceTypeFolder) {
        StringBuilder stringBuilder = new StringBuilder();
        Path relativeResourceTypePath = scriptsDirectory.relativize(resourceTypeFolder);
        if (StringUtils.isNotEmpty(relativeResourceTypePath.toString())) {
            int parts = relativeResourceTypePath.getNameCount();
            for (int i = 0; i < parts; i++) {
                stringBuilder.append(relativeResourceTypePath.getName(i));
                if (i < parts - 1) {
                    stringBuilder.append('/');
                }
            }
        }
        return stringBuilder.toString();
    }

    private @NotNull String getResourceTypeLabel(@NotNull String resourceType) {
        String resourceTypeLabel = null;
        if (resourceType.contains("/")) {
            int lastIndex = resourceType.lastIndexOf('/');
            if (lastIndex < resourceType.length() - 2) {
                resourceTypeLabel = resourceType.substring(++lastIndex);
            }
        } else if (resourceType.contains(".")) {
            int lastIndex = resourceType.lastIndexOf('.');
            if (lastIndex < resourceType.length() - 2) {
                resourceTypeLabel = resourceType.substring(++lastIndex);
            }
        } else {
            resourceTypeLabel = resourceType;
        }
        if (StringUtils.isEmpty(resourceTypeLabel)) {
            throw new IllegalArgumentException(String.format("Resource type '%s' does not provide a resourceTypeLabel.", resourceType));
        }
        return resourceTypeLabel;
    }
}