/*
 * ProGuard -- shrinking, optimization, obfuscation, and preverification
 *             of Java bytecode.
 *
 * Copyright (c) 2002-2019 Guardsquare NV
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package proguard;

import proguard.classfile.*;
import proguard.io.*;
import proguard.util.*;

import static proguard.DataEntryReaderFactory.getFilterExcludingVersionedClasses;

import java.util.List;

/**
 * This class can create DataEntryWriter instances based on class paths. The
 * writers will wrap the output in the proper apks, jars, wars, ears, jmods,
 * and zips.
 *
 * @author Eric Lafortune
 */
public class DataEntryWriterFactory
{
    private final ClassPool                              programClassPool;
    private final MultiValueMap                          extraClassNameMap;


    /**
     * Creates a new DataEntryWriterFactory with the given parameters.
     * @param programClassPool      the program classpool to process.
     */
    public DataEntryWriterFactory(ClassPool                              programClassPool,
                                  MultiValueMap<String, String>          extraClassNamemap)
    {
        this.programClassPool                 = programClassPool;
        this.extraClassNameMap                = extraClassNamemap;
    }


    /**
     * Creates a DataEntryWriter that can write to the given class path entries.
     *
     * @param classPath the output class path.
     * @param fromIndex the start index in the class path.
     * @param toIndex   the end index in the class path.
     * @return a DataEntryWriter for writing to the given class path entries.
     */
    public DataEntryWriter createDataEntryWriter(ClassPath classPath,
                                                 int       fromIndex,
                                                 int       toIndex)
    {
        DataEntryWriter writer = null;

        // Create a chain of writers, one for each class path entry.
        for (int index = toIndex - 1; index >= fromIndex; index--)
        {
            ClassPathEntry entry = classPath.get(index);

            writer = createClassPathEntryWriter(entry, writer);
        }

        return writer;
    }


    /**
     * Creates a DataEntryWriter that can write to the given class path entry,
     * or delegate to another DataEntryWriter if its filters don't match.
     */
    private DataEntryWriter createClassPathEntryWriter(ClassPathEntry  classPathEntry,
                                                       DataEntryWriter alternativeWriter)
    {
        boolean isApk  = classPathEntry.isApk();
        boolean isJar  = classPathEntry.isJar();
        boolean isAar  = classPathEntry.isAar();
        boolean isWar  = classPathEntry.isWar();
        boolean isEar  = classPathEntry.isEar();
        boolean isJmod = classPathEntry.isJmod();
        boolean isZip  = classPathEntry.isZip();

        List filter     = getFilterExcludingVersionedClasses(classPathEntry);
        List apkFilter  = classPathEntry.getApkFilter();
        List jarFilter  = classPathEntry.getJarFilter();
        List aarFilter  = classPathEntry.getAarFilter();
        List warFilter  = classPathEntry.getWarFilter();
        List earFilter  = classPathEntry.getEarFilter();
        List jmodFilter = classPathEntry.getJmodFilter();
        List zipFilter  = classPathEntry.getZipFilter();

        System.out.println("Preparing output " +
                           (isApk  ? "apk"  :
                            isJar  ? "jar"  :
                            isAar  ? "aar"  :
                            isWar  ? "war"  :
                            isEar  ? "ear"  :
                            isJmod ? "jmod" :
                            isZip  ? "zip"  :
                                     "directory") +
                           " [" + classPathEntry.getName() + "]" +
                           (filter     != null ||
                            apkFilter  != null ||
                            jarFilter  != null ||
                            aarFilter  != null ||
                            warFilter  != null ||
                            earFilter  != null ||
                            jmodFilter != null ||
                            zipFilter  != null ? " (filtered)" : ""));

        DataEntryWriter writer = new DirectoryWriter(classPathEntry.getFile(),
                                                     isApk  ||
                                                     isJar  ||
                                                     isAar  ||
                                                     isWar  ||
                                                     isEar  ||
                                                     isJmod ||
                                                     isZip);

        // If the output is an archive, we'll flatten (unpack the contents of)
        // higher level input archives, e.g. when writing into a jar file, we
        // flatten zip files.
        boolean flattenApks  = false;
        boolean flattenJars  = flattenApks  || isApk;
        boolean flattenAars  = flattenJars  || isJar;
        boolean flattenWars  = flattenAars  || isAar;
        boolean flattenEars  = flattenWars  || isWar;
        boolean flattenJmods = flattenEars  || isEar;
        boolean flattenZips  = flattenJmods || isJmod;

        // Set up the filtered jar writers.
        writer = wrapInJarWriter(writer, flattenZips,  isZip,  ".zip",  zipFilter,  null,                       null);
        writer = wrapInJarWriter(writer, flattenJmods, isJmod, ".jmod", jmodFilter, ClassConstants.JMOD_HEADER, ClassConstants.JMOD_CLASS_FILE_PREFIX);
        writer = wrapInJarWriter(writer, flattenEars,  isEar,  ".ear",  earFilter,  null,                       null);
        writer = wrapInJarWriter(writer, flattenWars,  isWar,  ".war",  warFilter,  null,                       ClassConstants.WAR_CLASS_FILE_PREFIX);
        writer = wrapInJarWriter(writer, flattenAars,  isAar,  ".aar",  aarFilter,  null,                       null);
        writer = wrapInJarWriter(writer, flattenJars,  isJar,  ".jar",  jarFilter,  null,                       null);
        writer = wrapInJarWriter(writer, flattenApks,  isApk,  ".apk",  apkFilter,  null,                       null);

        // Set up for writing out the program classes.
        writer = new ClassDataEntryWriter(programClassPool, writer);

        // Add a data entry filter, if specified.
        writer = filter != null ?
            new FilteredDataEntryWriter(
                new DataEntryNameFilter(
                    new ListParser(new FileNameParser()).parse(filter)),
                writer) :
            writer;

        // Add a writer for the injected classes.
        writer = new ExtraDataEntryWriter(extraClassNameMap,
                                          writer,
                                          writer,
                                          ClassConstants.CLASS_FILE_EXTENSION);

        // Let the writer cascade, if specified.
        return alternativeWriter != null ?
            new CascadingDataEntryWriter(writer, alternativeWriter) :
            writer;
    }


    /**
     * Wraps the given DataEntryWriter in a JarWriter, filtering if necessary.
     */
    private DataEntryWriter wrapInJarWriter(DataEntryWriter writer,
                                            boolean         flatten,
                                            boolean         isOutputJar,
                                            String          jarFilterExtension,
                                            List            jarFilter,
                                            byte[]          jarHeader,
                                            String          classFilePrefix)
    {
        // Flatten jars or zip them up.
        DataEntryWriter jarWriter;
        if (flatten)
        {
            // Unpack the jar.
            jarWriter = new ParentDataEntryWriter(writer);
        }
        else
        {
            // Pack the jar.
            jarWriter = new JarWriter(jarHeader, writer);

            // Add a prefix for class files inside the jar, if specified.
            if (classFilePrefix != null)
            {
                jarWriter =
                    new FilteredDataEntryWriter(
                    new DataEntryNameFilter(
                    new ExtensionMatcher(ClassConstants.CLASS_FILE_EXTENSION)),
                    new PrefixAddingDataEntryWriter(classFilePrefix,
                                                    jarWriter),
                    jarWriter);
            }
        }

        // Either zip up the jar or delegate to the original writer.
        return
            new FilteredDataEntryWriter(
            new DataEntryParentFilter(
            new DataEntryNameFilter(
            new ExtensionMatcher(jarFilterExtension))),

                // The parent of the data entry is a jar.
                // Write the data entry to the jar.
                // Apply the jar filter, if specified, to the parent.
                jarFilter != null ?
                    new FilteredDataEntryWriter(
                    new DataEntryParentFilter(
                    new DataEntryNameFilter(
                    new ListParser(new FileNameParser()).parse(jarFilter))),
                    jarWriter) :
                    jarWriter,

                // The parent of the data entry is not a jar.
                // Write the entry to a jar anyway if the output is a jar.
                // Otherwise just delegate to the original writer.
                isOutputJar ?
                    jarWriter :
                    writer);
    }
}