/*
 * 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.wicket.util.license;

import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;

import org.apache.wicket.util.lang.Generics;
import org.apache.wicket.util.string.Strings;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Testcase used in the different wicket projects for testing for the correct ASL license headers.
 * Doesn't really make sense outside org.apache.wicket.
 * 
 * @author Frank Bille Jensen (frankbille)
 */
public abstract class ApacheLicenseHeaderTestCase
{
        /** Log. */
        private static final Logger log = LoggerFactory.getLogger(ApacheLicenseHeaderTestCase.class);

        private static final String LINE_ENDING = System.getProperty("line.separator");
        protected List<String> javaIgnore = Generics.newArrayList();
        protected List<String> htmlIgnore = Generics.newArrayList();
        protected List<String> xmlPrologIgnore = Generics.newArrayList();
        protected List<String> propertiesIgnore = Generics.newArrayList();
        protected List<String> xmlIgnore = Generics.newArrayList();
        protected List<String> cssIgnore = Generics.newArrayList();
        protected List<String> velocityIgnore = Generics.newArrayList();
        protected List<String> javaScriptIgnore = Generics.newArrayList();
        protected boolean addHeaders = false;
        private ILicenseHeaderHandler[] licenseHeaderHandlers;
        private File baseDirectory = new File("").getAbsoluteFile();
        /**
         * Construct.
         */
        public ApacheLicenseHeaderTestCase()
        {

                // -------------------------------
                // Configure defaults
                // -------------------------------

                // addHeaders = true;
                xmlIgnore.add(".settings");
                xmlIgnore.add("EclipseCodeFormat.xml");
                xmlIgnore.add("nb-configuration.xml");

                /*
                 * License header in test files lower the visibility of the test.
                 */
                htmlIgnore.add("src/test/java");

                /*
                 * Low level configuration files for logging. No license needed.
                 */
                propertiesIgnore.add("src/test/java");

                /*
                 * .html in test is very test specific and a license header would confuse and make it
                 * unclear what the test is about.
                 */
                xmlPrologIgnore.add("src/test/java");

                /*
                 * Ignore package.html
                 */
                xmlPrologIgnore.add("package.html");
        }

        /**
         *
         */
        @BeforeEach
        final void before()
        {
                // setup the base directory for when running inside maven (building a release
                // comes to mind).
                String property = System.getProperty("basedir");
                if (!Strings.isEmpty(property))
                {
                        baseDirectory = new File(property).getAbsoluteFile();
                }
        }

        /**
         * Test all the files in the project which has an associated {@link ILicenseHeaderHandler}.
         */
        @Test
        void licenseHeaders()
        {
                licenseHeaderHandlers = new ILicenseHeaderHandler[] {
                                new JavaLicenseHeaderHandler(javaIgnore),
                                new JavaScriptLicenseHeaderHandler(javaScriptIgnore),
                                new XmlLicenseHeaderHandler(xmlIgnore),
                                new PropertiesLicenseHeaderHandler(propertiesIgnore),
                                new HtmlLicenseHeaderHandler(htmlIgnore),
                                new VelocityLicenseHeaderHandler(velocityIgnore),
                                new XmlPrologHeaderHandler(xmlPrologIgnore),
                                new CssLicenseHeaderHandler(cssIgnore), };

                final Map<ILicenseHeaderHandler, List<File>> badFiles = new HashMap<>();

                for (final ILicenseHeaderHandler licenseHeaderHandler : licenseHeaderHandlers)
                {
                        visitFiles(licenseHeaderHandler.getSuffixes(), licenseHeaderHandler.getIgnoreFiles(),
                                new FileVisitor()
                                {
                                        @Override
                                        public void visitFile(final File file)
                                        {
                                                if (licenseHeaderHandler.checkLicenseHeader(file) == false)
                                                {
                                                        if ((addHeaders == false) ||
                                                                (licenseHeaderHandler.addLicenseHeader(file) == false))
                                                        {
                                                                List<File> files = badFiles.get(licenseHeaderHandler);

                                                                if (files == null)
                                                                {
                                                                        files = new ArrayList<>();
                                                                        badFiles.put(licenseHeaderHandler, files);
                                                                }

                                                                files.add(file);
                                                        }
                                                }
                                        }
                                });
                }

                failIncorrectLicenceHeaders(badFiles);
        }

        private void failIncorrectLicenceHeaders(final Map<ILicenseHeaderHandler, List<File>> files)
        {
                if (files.size() > 0)
                {
                        StringBuilder failString = new StringBuilder();

                        for (Entry<ILicenseHeaderHandler, List<File>> entry : files.entrySet())
                        {
                                ILicenseHeaderHandler licenseHeaderHandler = entry.getKey();
                                List<File> fileList = entry.getValue();

                                failString.append('\n');
                                failString.append(licenseHeaderHandler.getClass().getName());
                                failString.append(" failed. The following files(");
                                failString.append(fileList.size());
                                failString.append(") didn't have correct license header:\n");

                                for (File file : fileList)
                                {
                                        String filename = file.getAbsolutePath();

                                        // Find the license type
                                        String licenseType = licenseHeaderHandler.getLicenseType(file);

                                        failString.append(Objects.requireNonNullElse(licenseType, "NONE"));
                                        failString.append(' ').append(filename).append(LINE_ENDING);
                                }
                        }

                        System.out.println(failString);
                        throw new AssertionError(failString.toString());
                }
        }

        private void visitFiles(final List<String> suffixes, final List<String> ignoreFiles,
                final FileVisitor fileVisitor)
        {
                visitDirectory(suffixes, ignoreFiles, baseDirectory, fileVisitor);
        }

        private void visitDirectory(final List<String> suffixes, final List<String> ignoreFiles,
                final File directory, final FileVisitor fileVisitor)
        {
                File[] files = directory.listFiles(new SuffixAndIgnoreFileFilter(suffixes, ignoreFiles));

                if (files != null)
                {
                        for (File file : files)
                        {
                                fileVisitor.visitFile(file);
                        }
                }

                // Find the directories in this directory on traverse deeper
                files = directory.listFiles(new DirectoryFileFilter());

                if (files != null)
                {
                        for (File childDirectory : files)
                        {
                                visitDirectory(suffixes, ignoreFiles, childDirectory, fileVisitor);
                        }
                }
        }

        interface FileVisitor
        {
                /**
                 * @param file
                 */
                void visitFile(File file);
        }

        private class SuffixAndIgnoreFileFilter implements FileFilter
        {
                private final List<String> suffixes;
                private final List<String> ignoreFiles;

                private SuffixAndIgnoreFileFilter(final List<String> suffixes,
                        final List<String> ignoreFiles)
                {
                        this.suffixes = suffixes;
                        this.ignoreFiles = ignoreFiles;
                }

                @Override
                public boolean accept(final File pathname)
                {
                        boolean accept = false;

                        if (pathname.isFile())
                        {
                                if (ignoreFile(pathname) == false)
                                {
                                        for (String suffix : suffixes)
                                        {
                                                if (pathname.getName().endsWith("." + suffix))
                                                {
                                                        accept = true;
                                                        break;
                                                }
                                                else
                                                {
                                                        log.debug("File ignored: '{}'", pathname);
                                                }
                                        }
                                }
                                else
                                {
                                        log.debug("File ignored: '{}'", pathname);
                                }
                        }

                        return accept;
                }

                private boolean ignoreFile(final File pathname)
                {
                        boolean ignore = false;

                        if (ignoreFiles != null)
                        {
                                String relativePathname = pathname.getAbsolutePath();
                                relativePathname = Strings
                                        .replaceAll(relativePathname,
                                                baseDirectory.getAbsolutePath() + System.getProperty("file.separator"), "")
                                        .toString();

                                for (String ignorePath : ignoreFiles)
                                {
                                        // Will convert '/'s to '\\'s on Windows
                                        ignorePath = Strings
                                                .replaceAll(ignorePath, "/", System.getProperty("file.separator"))
                                                .toString();
                                        File ignoreFile = new File(baseDirectory, ignorePath);

                                        // Directory ignore
                                        if (ignoreFile.isDirectory())
                                        {
                                                if (pathname.getAbsolutePath().startsWith(ignoreFile.getAbsolutePath()))
                                                {
                                                        ignore = true;
                                                        break;
                                                }
                                        }
                                        // Absolute file
                                        else if (ignoreFile.isFile())
                                        {
                                                if (relativePathname.equals(ignorePath))
                                                {
                                                        ignore = true;
                                                        break;
                                                }
                                        }
                                        else if (pathname.getName().equals(ignorePath))
                                        {
                                                ignore = true;
                                                break;
                                        }
                                }
                        }

                        return ignore;
                }
        }

        private class DirectoryFileFilter implements FileFilter
        {
                private final String[] ignoreDirectory = new String[] { ".git" };

                @Override
                public boolean accept(final File pathname)
                {
                        boolean accept = false;

                        if (pathname.isDirectory())
                        {
                                String relativePathname = pathname.getAbsolutePath();
                                relativePathname = Strings
                                        .replaceAll(relativePathname,
                                                baseDirectory.getAbsolutePath() + System.getProperty("file.separator"), "")
                                        .toString();
                                if ("target".equals(relativePathname) == false)
                                {
                                        boolean found = false;
                                        for (String ignore : ignoreDirectory)
                                        {
                                                if (pathname.getName().equals(ignore))
                                                {
                                                        found = true;
                                                        break;
                                                }
                                        }
                                        if (found == false)
                                        {
                                                accept = true;
                                        }
                                }
                        }

                        return accept;
                }
        }
}