/*
 * 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
 *
 *      https://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.io.file;

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.File;
import java.io.IOException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;

import org.apache.commons.io.file.Counters.PathCounters;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

import com.google.common.jimfs.Configuration;
import com.google.common.jimfs.Jimfs;

/**
 * Tests {@link PathUtils}.
 */
class PathUtilsContentEqualsTest {

    static Configuration[] testConfigurations() {
        // @formatter:off
        return new Configuration[] {
                Configuration.osX().toBuilder().setWorkingDirectory("/").build(),
                Configuration.unix().toBuilder().setWorkingDirectory("/").build(),
                Configuration.windows().toBuilder().setWorkingDirectory("C:\\").build()
        };
        // @formatter:on
    }

    @TempDir
    public File temporaryFolder;

    private void assertContentEquals(final FileSystem fileSystem1, final FileSystem fileSystem2) throws IOException {
        assertTrue(PathUtils.contentEquals(fileSystem1, fileSystem2));
        assertTrue(PathUtils.contentEquals(fileSystem2, fileSystem1));
        assertTrue(PathUtils.contentEquals(fileSystem1, fileSystem1));
        assertTrue(PathUtils.contentEquals(fileSystem2, fileSystem2));
    }

    private void assertContentNotEquals(final FileSystem fileSystem1, final FileSystem fileSystem2) throws IOException {
        assertFalse(PathUtils.contentEquals(fileSystem1, fileSystem2));
        assertFalse(PathUtils.contentEquals(fileSystem2, fileSystem1));
        assertTrue(PathUtils.contentEquals(fileSystem1, fileSystem1));
        assertTrue(PathUtils.contentEquals(fileSystem2, fileSystem2));
    }

    private void assertDirectoryAndFileContentEquals(final Path dir1, final Path dir2) throws IOException {
        assertTrue(PathUtils.directoryAndFileContentEquals(dir1, dir2));
        assertTrue(PathUtils.directoryAndFileContentEquals(dir2, dir2));
        assertTrue(PathUtils.directoryAndFileContentEquals(dir1, dir1));
        assertTrue(PathUtils.directoryAndFileContentEquals(dir2, dir2));
    }

    private void assertDirectoryAndFileContentNotEquals(final Path dir1, final Path dir2) throws IOException {
        assertFalse(PathUtils.directoryAndFileContentEquals(dir1, dir2));
        assertFalse(PathUtils.directoryAndFileContentEquals(dir2, dir1));
        assertTrue(PathUtils.directoryAndFileContentEquals(dir1, dir1));
        assertTrue(PathUtils.directoryAndFileContentEquals(dir2, dir2));
    }

    private void assertFileContentEquals(final Path path1, final Path path2) throws IOException {
        assertTrue(PathUtils.fileContentEquals(path1, path1));
        assertTrue(PathUtils.fileContentEquals(path1, path2));
        assertTrue(PathUtils.fileContentEquals(path2, path2));
        assertTrue(PathUtils.fileContentEquals(path2, path1));
    }

    private void assertFileContentNotEquals(final Path path1, final Path path2) throws IOException {
        assertFalse(PathUtils.fileContentEquals(path1, path2));
        assertFalse(PathUtils.fileContentEquals(path2, path1));
        assertTrue(PathUtils.fileContentEquals(path1, path1));
        assertTrue(PathUtils.fileContentEquals(path2, path2));
    }

    private String getName() {
        return this.getClass().getSimpleName();
    }

    @ParameterizedTest
    @MethodSource("testConfigurations")
    void testContentEqualsFileSystemsMemVsMem(final Configuration configuration) throws Exception {
        final Path refDir = Paths.get("src/test/resources/dir-equals-tests");
        try (FileSystem fileSystem1 = Jimfs.newFileSystem(configuration);
                FileSystem fileSystem2 = Jimfs.newFileSystem(configuration)) {
            final Path fsDir1 = fileSystem1.getPath(refDir.getFileName().toString());
            final Path fsDir2 = fileSystem2.getPath(refDir.getFileName().toString());
            assertTrue(PathUtils.copyDirectory(refDir, fsDir1).getByteCounter().get() > 0);
            assertTrue(PathUtils.copyDirectory(refDir, fsDir2).getByteCounter().get() > 0);
            assertContentEquals(fileSystem1, fileSystem2);
        }
    }

    @ParameterizedTest
    @MethodSource("testConfigurations")
    void testContentEqualsFileSystemsMemVsZip(final Configuration configuration) throws Exception {
        final Path refDir = Paths.get("src/test/resources/dir-equals-tests");
        try (FileSystem fileSystem1 = Jimfs.newFileSystem(configuration);
                FileSystem fileSystem2 = FileSystems.newFileSystem(refDir.resolveSibling(refDir.getFileName() + ".zip"), null)) {
            final Path fsDir1 = fileSystem1.getPath(refDir.getFileName().toString());
            final PathCounters copyDirectory = PathUtils.copyDirectory(refDir, fsDir1);
            assertTrue(copyDirectory.getByteCounter().get() > 0);
            assertContentEquals(fileSystem1, fileSystem2);
        }
    }

    @Test
    void testContentEqualsFileSystemsZipVsZip() throws Exception {
        final Path zipPath = Paths.get("src/test/resources/dir-equals-tests.zip");
        final Path zipCopy = temporaryFolder.toPath().resolve("copy2.zip");
        Files.copy(zipPath, zipCopy, StandardCopyOption.REPLACE_EXISTING);
        try (FileSystem fileSystem1 = FileSystems.newFileSystem(zipPath, null); FileSystem fileSystem2 = FileSystems.newFileSystem(zipCopy, null)) {
            assertContentEquals(fileSystem1, fileSystem2);
        }
        final Path emptyZip = Paths.get("src/test/resources/org/apache/commons/io/empty.zip");
        try (FileSystem fileSystem1 = FileSystems.newFileSystem(emptyZip, null); FileSystem fileSystem2 = FileSystems.newFileSystem(emptyZip, null)) {
            assertContentEquals(fileSystem1, fileSystem2);
        }
        try (FileSystem fileSystem1 = FileSystems.newFileSystem(zipCopy, null); FileSystem fileSystem2 = FileSystems.newFileSystem(emptyZip, null)) {
            assertContentNotEquals(fileSystem1, fileSystem2);
        }
        try (FileSystem fileSystem1 = FileSystems.newFileSystem(zipPath, null); FileSystem fileSystem2 = FileSystems.newFileSystem(emptyZip, null)) {
            assertContentNotEquals(fileSystem1, fileSystem2);
        }
    }

    @Test
    void testDirectoryAndFileContentEquals() throws Exception {
        // Non-existent files
        final Path path1 = new File(temporaryFolder, getName()).toPath();
        final Path path2 = new File(temporaryFolder, getName() + "2").toPath();
        assertDirectoryAndFileContentEquals(null, null);
        assertDirectoryAndFileContentNotEquals(path1, null);
        // both don't exist
        assertDirectoryAndFileContentEquals(path1, path2);
        // Tree equals true tests
        {
            // Trees of files only that contain the same files.
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-files-only/directory-files-only1");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-files-only/directory-files-only2");
            assertDirectoryAndFileContentEquals(dir1, dir2);
        }
        {
            // Trees of directories containing other directories.
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-then-files/dir1");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-then-files/dir2");
            assertDirectoryAndFileContentEquals(dir1, dir2);
        }
        {
            // Trees of directories containing other directories and files.
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files/dirs-and-files1");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files/dirs-and-files1");
            assertDirectoryAndFileContentEquals(dir1, dir2);
        }
        // Tree equals false tests
        {
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files/dirs-and-files1/directory-files-only1");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files/dirs-and-files1/");
            assertDirectoryAndFileContentNotEquals(dir1, dir2);
        }
        {
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-then-files");
            assertDirectoryAndFileContentNotEquals(dir1, dir2);
        }
    }

    /**
     * Tests IO-872 PathUtils.directoryAndFileContentEquals doesn't work across FileSystems.
     *
     * @throws Exception on test failure.
     */
    @Test
    void testDirectoryAndFileContentEqualsDifferentFileSystemsFileVsZip() throws Exception {
        final Path dir1 = Paths.get("src/test/resources/dir-equals-tests");
        try (FileSystem fileSystem = FileSystems.newFileSystem(dir1.resolveSibling(dir1.getFileName() + ".zip"), null)) {
            final Path dir2 = fileSystem.getPath("/dir-equals-tests");
            // WindowsPath, UnixPath, and ZipPath equals() methods always return false if the argument is not of the same instance as itself.
            assertDirectoryAndFileContentEquals(dir1, dir2);
        }
    }

    /**
     * Tests IO-872 PathUtils.directoryAndFileContentEquals doesn't work across FileSystems.
     *
     * @throws Exception on test failure.
     */
    @Test
    void testDirectoryAndFileContentEqualsDifferentFileSystemsZipVsZip() throws Exception {
        final Path zipPath = Paths.get("src/test/resources/dir-equals-tests.zip");
        final Path zipCopy = temporaryFolder.toPath().resolve("copy1.zip");
        Files.copy(zipPath, zipCopy, StandardCopyOption.REPLACE_EXISTING);
        try (FileSystem fileSystem1 = FileSystems.newFileSystem(zipPath, null);
                FileSystem fileSystem2 = FileSystems.newFileSystem(zipCopy, null)) {
            final Path dir1 = fileSystem1.getPath("/dir-equals-tests");
            final Path dir2 = fileSystem2.getPath("/dir-equals-tests");
            // WindowsPath, UnixPath, and ZipPath equals() methods always return false if the argument is not of the same instance as itself.
            assertDirectoryAndFileContentEquals(dir1, dir2);
        }
    }

    /**
     * Tests IO-872 PathUtils.directoryAndFileContentEquals doesn't work across FileSystems.
     *
     * @throws Exception on test failure.
     */
    @Test
    void testDirectoryAndFileContentEqualsDifferentFileSystemsZipVsZipEmpty() throws Exception {
        final Path zipPath = Paths.get("src/test/resources/dir-equals-tests.zip");
        final Path zipCopy = temporaryFolder.toPath().resolve("copy1.zip");
        final Path emptyZip = Paths.get("src/test/resources/org/apache/commons/io/empty.zip");
        Files.copy(zipPath, zipCopy, StandardCopyOption.REPLACE_EXISTING);
        try (FileSystem fileSystem1 = FileSystems.newFileSystem(zipPath, null);
                FileSystem fileSystem2 = FileSystems.newFileSystem(emptyZip, null)) {
            final Path dir1 = fileSystem1.getPath("/dir-equals-tests");
            final Path dir2 = fileSystem2.getPath("/");
            // WindowsPath, UnixPath, and ZipPath equals() methods always return false if the argument is not of the same instance as itself.
            assertDirectoryAndFileContentNotEquals(dir1, dir2);
        }
        try (FileSystem fileSystem1 = FileSystems.newFileSystem(zipPath, null);
                FileSystem fileSystem2 = FileSystems.newFileSystem(emptyZip, null)) {
            final Path dir1 = fileSystem1.getPath("/dir-equals-tests");
            final Path dir2 = fileSystem2.getRootDirectories().iterator().next();
            // WindowsPath, UnixPath, and ZipPath equals() methods always return false if the argument is not of the same instance as itself.
            assertDirectoryAndFileContentNotEquals(dir1, dir2);
        }
        Files.copy(emptyZip, zipCopy, StandardCopyOption.REPLACE_EXISTING);
        try (FileSystem fileSystem1 = FileSystems.newFileSystem(emptyZip, null);
                FileSystem fileSystem2 = FileSystems.newFileSystem(zipCopy, null)) {
            final Path dir1 = fileSystem1.getPath("/");
            final Path dir2 = fileSystem2.getPath("/");
            // WindowsPath, UnixPath, and ZipPath equals() methods always return false if the argument is not of the same instance as itself.
            assertDirectoryAndFileContentEquals(dir1, dir2);
        }
    }

    @Test
    void testDirectoryContentEquals() throws Exception {
        // Non-existent files
        final Path path1 = new File(temporaryFolder, getName()).toPath();
        final Path path2 = new File(temporaryFolder, getName() + "2").toPath();
        assertTrue(PathUtils.directoryContentEquals(null, null));
        assertFalse(PathUtils.directoryContentEquals(null, path1));
        assertFalse(PathUtils.directoryContentEquals(path1, null));
        // both don't exist
        assertTrue(PathUtils.directoryContentEquals(path1, path1));
        assertTrue(PathUtils.directoryContentEquals(path1, path2));
        assertTrue(PathUtils.directoryContentEquals(path2, path2));
        assertTrue(PathUtils.directoryContentEquals(path2, path1));
        // Tree equals true tests
        {
            // Trees of files only that contain the same files.
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-files-only/directory-files-only1");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-files-only/directory-files-only2");
            assertTrue(PathUtils.directoryContentEquals(dir1, dir2));
            assertTrue(PathUtils.directoryContentEquals(dir2, dir2));
            assertTrue(PathUtils.directoryContentEquals(dir1, dir1));
            assertTrue(PathUtils.directoryContentEquals(dir2, dir2));
        }
        {
            // Trees of directories containing other directories.
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-then-files/dir1");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-then-files/dir2");
            assertTrue(PathUtils.directoryContentEquals(dir1, dir2));
            assertTrue(PathUtils.directoryContentEquals(dir2, dir2));
            assertTrue(PathUtils.directoryContentEquals(dir1, dir1));
            assertTrue(PathUtils.directoryContentEquals(dir2, dir2));
        }
        {
            // Trees of directories containing other directories and files.
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files/dirs-and-files1");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files/dirs-and-files1");
            assertTrue(PathUtils.directoryContentEquals(dir1, dir2));
            assertTrue(PathUtils.directoryContentEquals(dir2, dir2));
            assertTrue(PathUtils.directoryContentEquals(dir1, dir1));
            assertTrue(PathUtils.directoryContentEquals(dir2, dir2));
        }
        // Tree equals false tests
        {
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files/dirs-and-files1/directory-files-only1");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files/dirs-and-files1/");
            assertFalse(PathUtils.directoryContentEquals(dir1, dir2));
            assertFalse(PathUtils.directoryContentEquals(dir2, dir1));
        }
        {
            final Path dir1 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-and-files");
            final Path dir2 = Paths.get("src/test/resources/dir-equals-tests/dir-equals-dirs-then-files");
            assertFalse(PathUtils.directoryContentEquals(dir1, dir2));
            assertFalse(PathUtils.directoryContentEquals(dir2, dir1));
        }
    }

    @Test
    void testFileContentEquals() throws Exception {
        // Non-existent files
        final Path path1 = new File(temporaryFolder, getName()).toPath();
        final Path path2 = new File(temporaryFolder, getName() + "2").toPath();
        assertTrue(PathUtils.fileContentEquals(null, null));
        assertFileContentNotEquals(path1, null);
        // both don't exist
        assertFileContentEquals(path1, path2);
        // Directories
        assertThrows(IOException.class, () -> PathUtils.fileContentEquals(temporaryFolder.toPath(), temporaryFolder.toPath()));
        // Different files
        final Path objFile1 = Paths.get(temporaryFolder.getAbsolutePath(), getName() + ".object");
        PathUtils.copyFile(getClass().getResource("/java/lang/Object.class"), objFile1);
        final Path objFile1b = Paths.get(temporaryFolder.getAbsolutePath(), getName() + ".object2");
        PathUtils.copyFile(getClass().getResource("/java/lang/Object.class"), objFile1b);
        final Path objFile2 = Paths.get(temporaryFolder.getAbsolutePath(), getName() + ".collection");
        PathUtils.copyFile(getClass().getResource("/java/util/Collection.class"), objFile2);
        assertFalse(PathUtils.fileContentEquals(objFile1, objFile2));
        assertFalse(PathUtils.fileContentEquals(objFile1b, objFile2));
        assertTrue(PathUtils.fileContentEquals(objFile1, objFile1b));
        assertTrue(PathUtils.fileContentEquals(objFile1, objFile1));
        assertTrue(PathUtils.fileContentEquals(objFile1b, objFile1b));
        assertTrue(PathUtils.fileContentEquals(objFile2, objFile2));
        // Equal files
        Files.createFile(path1);
        Files.createFile(path2);
        assertFileContentEquals(path1, path2);
    }

    @Test
    void testFileContentEqualsZip() throws Exception {
        final Path path1 = Paths.get("src/test/resources/org/apache/commons/io/bla.zip");
        final Path path2 = Paths.get("src/test/resources/org/apache/commons/io/bla-copy.zip");
        // moby.zip is from https://issues.apache.org/jira/browse/COMPRESS-93
        final Path path3 = Paths.get("src/test/resources/org/apache/commons/io/moby.zip");
        assertFileContentEquals(path1, path2);
        assertFileContentNotEquals(path1, path3);
    }

    @Test
    void testFileContentEqualsZipFileSystem() throws Exception {
        try (FileSystem fileSystem = FileSystems.newFileSystem(Paths.get("src/test/resources/org/apache/commons/io/test-same-size-diff-contents.zip"),
                ClassLoader.getSystemClassLoader())) {
            // Contains one char: A
            final Path path1 = fileSystem.getPath("/test-same-size-diff-contents/A.txt");
            // Contains one char: B
            final Path path2 = fileSystem.getPath("/test-same-size-diff-contents/B.txt");
            assertTrue(Files.exists(path1));
            assertTrue(Files.exists(path2));
            assertFileContentNotEquals(path1, path2);
        }
    }

}