/*
 * 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.commons.compress;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;

import java.io.BufferedInputStream;
import java.io.Closeable;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.apache.commons.compress.archivers.ArchiveEntry;
import org.apache.commons.compress.archivers.ArchiveInputStream;
import org.apache.commons.compress.archivers.ArchiveOutputStream;
import org.apache.commons.compress.archivers.ArchiveStreamFactory;
import org.apache.commons.compress.archivers.ar.ArArchiveOutputStream;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.junit.jupiter.api.io.TempDir;

public abstract class AbstractTest extends AbstractTempDirTest {

    protected interface StreamWrapper<I extends InputStream> {
        I wrap(InputStream inputStream) throws Exception;
    }

    /**
     * Deletes a file or directory. For a directory, delete it and all subdirectories.
     *
     * @param file a file or directory.
     * @return whether deletion was successful
     */
    public static boolean forceDelete(final File file) {
        try {
            if (file != null && file.exists()) {
                FileUtils.forceDelete(file);
            }
            return true;
        } catch (final IOException e) {
            e.printStackTrace();
            file.deleteOnExit();
            return false;
        }
    }

    /**
     * Deletes a file or directory. For a directory, delete it and all subdirectories.
     *
     * @param path a file or directory
     * @return whether deletion was successful
     */
    public static boolean forceDelete(final Path path) {
        return forceDelete(path != null ? path.toFile() : null);
    }

    public static File getFile(final String path) throws IOException {
        final URL url = AbstractTest.class.getClassLoader().getResource(path);
        if (url == null) {
            throw new FileNotFoundException("couldn't find " + path);
        }
        try {
            return new File(url.toURI());
        } catch (final URISyntaxException ex) {
            throw new IOException(ex);
        }
    }

    public static Path getPath(final String path) throws IOException {
        return getFile(path).toPath();
    }

    public static InputStream newInputStream(final String path) throws IOException {
        return Files.newInputStream(getPath(path));
    }

    public static byte[] readAllBytes(final String path) throws IOException {
        return Files.readAllBytes(getPath(path));
    }

    @TempDir
    protected File tempResultDir;

    /** Lists the content of the archive as originally created. */
    protected List<String> archiveList;

    protected final ArchiveStreamFactory factory = ArchiveStreamFactory.DEFAULT;

    /**
     * Add an entry to the archive, and keep track of the names in archiveList.
     *
     * @param outputStream
     * @param fileName
     * @param inputFile
     * @throws IOException
     * @throws FileNotFoundException
     */
    private <O extends ArchiveOutputStream<E>, E extends ArchiveEntry> void addArchiveEntry(final O outputStream, final String fileName, final File inputFile)
            throws IOException, FileNotFoundException {
        final E entry = outputStream.createArchiveEntry(inputFile, fileName);
        outputStream.putArchiveEntry(entry);
        Files.copy(inputFile.toPath(), outputStream);
        outputStream.closeArchiveEntry();
        archiveList.add(fileName);
    }

    /**
     * Checks that an archive input stream can be read, and that the file data matches file sizes.
     *
     * @param inputStream
     * @param expected    list of expected entries or {@code null} if no check of names desired
     * @throws Exception
     */
    protected void checkArchiveContent(final ArchiveInputStream<?> inputStream, final List<String> expected) throws Exception {
        checkArchiveContent(inputStream, expected, true);
    }

    /**
     * Checks that an archive input stream can be read, and that the file data matches file sizes.
     *
     * @param inputStream
     * @param expected    list of expected entries or {@code null} if no check of names desired
     * @param cleanUp     Cleans up resources if true
     * @return returns the created result file if cleanUp = false, or null otherwise
     * @throws Exception
     */
    protected File checkArchiveContent(final ArchiveInputStream<?> inputStream, final List<String> expected, final boolean cleanUp) throws Exception {
        final Path targetDir = createTempDirectory("dir-result");
        final Path result = targetDir.resolve("result");
        try {
            ArchiveEntry entry;
            while ((entry = inputStream.getNextEntry()) != null) {
                final Path outputFile = entry.resolveIn(result);
                long bytesCopied = 0;
                if (entry.isDirectory()) {
                    Files.createDirectories(outputFile);
                } else {
                    Files.createDirectories(outputFile.getParent());
                    bytesCopied = Files.copy(inputStream, outputFile);
                }
                final long size = entry.getSize();
                if (size != ArchiveEntry.SIZE_UNKNOWN) {
                    assertEquals(size, bytesCopied, "Entry.size should equal bytes read.");
                }

                if (!Files.exists(outputFile)) {
                    fail("Extraction failed: " + entry.getName());
                }
                if (expected != null && !expected.remove(getExpectedString(entry))) {
                    fail("Unexpected entry: " + getExpectedString(entry));
                }
            }
            inputStream.close();
            if (expected != null && !expected.isEmpty()) {
                fail(expected.size() + " missing entries: " + Arrays.toString(expected.toArray()));
            }
            if (expected != null) {
                assertEquals(0, expected.size());
            }
        } finally {
            if (cleanUp) {
                forceDelete(targetDir);
            }
        }
        return targetDir.toFile();
    }

    /**
     * Checks if an archive contains all expected files.
     *
     * @param archive  the archive to check
     * @param expected a list with expected string file names
     * @throws Exception
     */
    protected void checkArchiveContent(final File archive, final List<String> expected) throws Exception {
        checkArchiveContent(archive.toPath(), expected);
    }

    /**
     * Checks if an archive contains all expected files.
     *
     * @param archive  the archive to check
     * @param expected a list with expected string file names
     * @throws Exception
     */
    protected void checkArchiveContent(final Path archive, final List<String> expected) throws Exception {
        try (InputStream inputStream = Files.newInputStream(archive);
                ArchiveInputStream<?> archiveInputStream = factory.createArchiveInputStream(new BufferedInputStream(inputStream))) {
            checkArchiveContent(archiveInputStream, expected);
        }
    }

    protected void closeQuietly(final Closeable closeable) {
        IOUtils.closeQuietly(closeable);
    }

    /**
     * Creates an archive of text-based files in several directories. The archive name is the factory identifier for the archiver, for example zip, tar, cpio,
     * jar, ar. The archive is created as a temp file.
     *
     * The archive contains the following files:
     * <ul>
     * <li>testdata/test1.xml</li>
     * <li>testdata/test2.xml</li>
     * <li>test/test3.xml</li>
     * <li>bla/test4.xml</li>
     * <li>bla/test5.xml</li>
     * <li>bla/blubber/test6.xml</li>
     * <li>test.txt</li>
     * <li>something/bla</li>
     * <li>test with spaces.txt</li>
     * </ul>
     *
     * @param archiveName the identifier of this archive
     * @return the newly created file
     * @throws Exception in case something goes wrong
     */
    protected Path createArchive(final String archiveName) throws Exception {
        final Path archivePath = createTempPath("test", "." + archiveName);
        archiveList = new ArrayList<>();
        try (OutputStream outputStream = Files.newOutputStream(archivePath);
                ArchiveOutputStream<ArchiveEntry> archiveOutputStream = factory.createArchiveOutputStream(archiveName, outputStream)) {
            setLongFileMode(archiveOutputStream);
            final File file1 = getFile("test1.xml");
            final File file2 = getFile("test2.xml");
            final File file3 = getFile("test3.xml");
            final File file4 = getFile("test4.xml");
            final File file5 = getFile("test.txt");
            final File file6 = getFile("test with spaces.txt");

            addArchiveEntry(archiveOutputStream, "testdata/test1.xml", file1);
            addArchiveEntry(archiveOutputStream, "testdata/test2.xml", file2);
            addArchiveEntry(archiveOutputStream, "test/test3.xml", file3);
            addArchiveEntry(archiveOutputStream, "bla/test4.xml", file4);
            addArchiveEntry(archiveOutputStream, "bla/test5.xml", file4);
            addArchiveEntry(archiveOutputStream, "bla/blubber/test6.xml", file4);
            addArchiveEntry(archiveOutputStream, "test.txt", file5);
            addArchiveEntry(archiveOutputStream, "something/bla", file6);
            addArchiveEntry(archiveOutputStream, "test with spaces.txt", file6);

            archiveOutputStream.finish();
            return archivePath;
        }
    }

    /**
     * Create an empty archive.
     *
     * @param archiveName
     * @return the archive File
     * @throws Exception
     */
    protected Path createEmptyArchive(final String archiveName) throws Exception {
        archiveList = new ArrayList<>();
        final Path archivePath = createTempPath("empty", "." + archiveName);
        try (OutputStream outputStream = Files.newOutputStream(archivePath);
                ArchiveOutputStream<?> archiveOutputStream = factory.createArchiveOutputStream(archiveName, outputStream)) {
            archiveOutputStream.finish();
        }
        return archivePath;
    }

    /**
     * Create an archive with a single file "test1.xml".
     *
     * @param archiveName
     * @return the archive File
     * @throws Exception
     */
    protected Path createSingleEntryArchive(final String archiveName) throws Exception {
        archiveList = new ArrayList<>();
        final Path archivePath = createTempPath("empty", "." + archiveName);
        try (OutputStream outputStream = Files.newOutputStream(archivePath);
                ArchiveOutputStream<?> archiveOutputStream = factory.createArchiveOutputStream(archiveName, outputStream)) {
            // Use short file name so does not cause problems for ar
            addArchiveEntry(archiveOutputStream, "test1.xml", getFile("test1.xml"));
            archiveOutputStream.finish();
        }
        return archivePath;
    }

    public Path createTempDirectory(final String prefix) throws IOException {
        return Files.createTempDirectory(getTempDirPath(), prefix);
    }

    /**
     * Override this method to change what is to be compared in the List. For example, size + name instead of just name.
     *
     * @param entry
     * @return returns the entry name
     */
    protected String getExpectedString(final ArchiveEntry entry) {
        return entry.getName();
    }

    protected void setLongFileMode(final ArchiveOutputStream<?> outputStream) {
        if (outputStream instanceof ArArchiveOutputStream) {
            ((ArArchiveOutputStream) outputStream).setLongFileMode(ArArchiveOutputStream.LONGFILE_BSD);
        }
    }

}
