/**
 * 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.cassandra.io.util;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;

import org.assertj.core.api.Assertions;
import org.junit.BeforeClass;
import org.junit.Test;

import org.apache.cassandra.Util;
import org.apache.cassandra.config.DatabaseDescriptor;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

public class FileUtilsTest
{

    @BeforeClass
    public static void setupDD()
    {
        DatabaseDescriptor.daemonInitialization();
    }

    @Test
    public void testParseFileSize() throws Exception
    {
        // test straightforward conversions for each unit
        assertEquals("FileUtils.parseFileSize() failed to parse a whole number of bytes",
            256L, FileUtils.parseFileSize("256 bytes"));
        assertEquals("FileUtils.parseFileSize() failed to parse a whole number of kibibytes",
            2048L, FileUtils.parseFileSize("2 KiB"));
        assertEquals("FileUtils.parseFileSize() failed to parse a whole number of mebibytes",
            4194304L, FileUtils.parseFileSize("4 MiB"));
        assertEquals("FileUtils.parseFileSize() failed to parse a whole number of gibibytes",
            3221225472L, FileUtils.parseFileSize("3 GiB"));
        assertEquals("FileUtils.parseFileSize() failed to parse a whole number of tebibytes",
            5497558138880L, FileUtils.parseFileSize("5 TiB"));
        // test conversions of fractional units
        assertEquals("FileUtils.parseFileSize() failed to parse a rational number of kibibytes",
            1536L, FileUtils.parseFileSize("1.5 KiB"));
        assertEquals("FileUtils.parseFileSize() failed to parse a rational number of kibibytes",
            4434L, FileUtils.parseFileSize("4.33 KiB"));
        assertEquals("FileUtils.parseFileSize() failed to parse a rational number of mebibytes",
            2359296L, FileUtils.parseFileSize("2.25 MiB"));
        assertEquals("FileUtils.parseFileSize() failed to parse a rational number of mebibytes",
            3292529L, FileUtils.parseFileSize("3.14 MiB"));
        assertEquals("FileUtils.parseFileSize() failed to parse a rational number of gibibytes",
            1299227607L, FileUtils.parseFileSize("1.21 GiB"));
        assertEquals("FileUtils.parseFileSize() failed to parse a rational number of tebibytes",
            6621259022467L, FileUtils.parseFileSize("6.022 TiB"));
    }

    @Test
    public void testStringifyFileSize() throws Exception
    {
        // test straightforward conversions for each unit
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a whole number of bytes",
                     "256 bytes", FileUtils.stringifyFileSize(256L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a whole number of kibibytes",
                     "2 KiB", FileUtils.stringifyFileSize(2048L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a whole number of mebibytes",
                     "4 MiB", FileUtils.stringifyFileSize(4194304L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a whole number of gibibytes",
                     "3 GiB", FileUtils.stringifyFileSize(3221225472L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a whole number of tebibytes",
                     "5 TiB", FileUtils.stringifyFileSize(5497558138880L));
        // test conversions of fractional units
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a rational number of kibibytes",
                     "1.5 KiB", FileUtils.stringifyFileSize(1536L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a rational number of kibibytes",
                     "4.33 KiB", FileUtils.stringifyFileSize(4434L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a rational number of mebibytes",
                     "2.25 MiB", FileUtils.stringifyFileSize(2359296L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a rational number of mebibytes",
                     "3.14 MiB", FileUtils.stringifyFileSize(3292529L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a rational number of gibibytes",
                     "1.21 GiB", FileUtils.stringifyFileSize(1299227607L));
        assertEquals("FileUtils.stringifyFileSize() failed to stringify a rational number of tebibytes",
                     "6.02 TiB", FileUtils.stringifyFileSize(6621259022467L));
    }

    @Test
    public void testTruncate() throws IOException
    {
        File file = FileUtils.createDeletableTempFile("testTruncate", "1");
        final String expected = "The quick brown fox jumps over the lazy dog";

        Files.write(file.toPath(), expected.getBytes());
        assertTrue(file.exists());

        byte[] b = Files.readAllBytes(file.toPath());
        assertEquals(expected, new String(b, StandardCharsets.UTF_8));

        FileUtils.truncate(file.absolutePath(), 10);
        b = Files.readAllBytes(file.toPath());
        assertEquals("The quick ", new String(b, StandardCharsets.UTF_8));

        FileUtils.truncate(file.absolutePath(), 0);
        b = Files.readAllBytes(file.toPath());
        assertEquals(0, b.length);
    }

    @Test
    public void testFolderSize() throws Exception
    {
        File folder = createFolder(Paths.get(DatabaseDescriptor.getAllDataFileLocations()[0], "testFolderSize"));
        folder.deleteOnExit();

        File childFolder = createFolder(Paths.get(folder.path(), "child"));

        File[] files = {
                       createFile(new File(folder, "001"), 10000),
                       createFile(new File(folder, "002"), 1000),
                       createFile(new File(folder, "003"), 100),
                       createFile(new File(childFolder, "001"), 1000),
                       createFile(new File(childFolder, "002"), 2000),
        };

        assertEquals(0, FileUtils.folderSize(new File(folder, "i_dont_exist")));
        assertEquals(files[0].length(), FileUtils.folderSize(files[0]));

        long size = FileUtils.folderSize(folder);
        assertEquals(Arrays.stream(files).mapToLong(f -> f.length()).sum(), size);
    }

    @Test
    public void testIsContained()
    {
        assertTrue(FileUtils.isContained(new File("/testroot/abc"), new File("/testroot/abc")));
        assertFalse(FileUtils.isContained(new File("/testroot/abc"), new File("/testroot/abcd")));
        assertTrue(FileUtils.isContained(new File("/testroot/abc"), new File("/testroot/abc/d")));
        assertTrue(FileUtils.isContained(new File("/testroot/abc/../abc"), new File("/testroot/abc/d")));
        assertFalse(FileUtils.isContained(new File("/testroot/abc/../abc"), new File("/testroot/abcc")));
    }

    @Test
    public void testMoveFiles() throws IOException
    {
        Path tmpDir = Files.createTempDirectory(this.getClass().getSimpleName());
        Path sourceDir = Files.createDirectory(tmpDir.resolve("source"));
        Path subDir_1 = Files.createDirectory(sourceDir.resolve("a"));
        subDir_1.resolve("file_1.txt").toFile().createNewFile();
        subDir_1.resolve("file_2.txt").toFile().createNewFile();
        Path subDir_11 = Files.createDirectory(subDir_1.resolve("ab"));
        subDir_11.resolve("file_1.txt").toFile().createNewFile();
        subDir_11.resolve("file_2.txt").toFile().createNewFile();
        subDir_11.resolve("file_3.txt").toFile().createNewFile();
        Path subDir_12 = Files.createDirectory(subDir_1.resolve("ac"));
        Path subDir_2 = Files.createDirectory(sourceDir.resolve("b"));
        subDir_2.resolve("file_1.txt").toFile().createNewFile();
        subDir_2.resolve("file_2.txt").toFile().createNewFile();

        Path targetDir = Files.createDirectory(tmpDir.resolve("target"));

        FileUtils.moveRecursively(sourceDir, targetDir);

        assertThat(sourceDir).doesNotExist();
        assertThat(targetDir.resolve("a/file_1.txt")).exists();
        assertThat(targetDir.resolve("a/file_2.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_1.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_2.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_3.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_1.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_2.txt")).exists();
        assertThat(targetDir.resolve("a/ac/")).exists();
        assertThat(targetDir.resolve("b/file_1.txt")).exists();
        assertThat(targetDir.resolve("b/file_2.txt")).exists();

        // Tests that files can be moved into existing directories

        sourceDir = Files.createDirectory(tmpDir.resolve("source2"));
        subDir_1 = Files.createDirectory(sourceDir.resolve("a"));
        subDir_1.resolve("file_3.txt").toFile().createNewFile();
        subDir_11 = Files.createDirectory(subDir_1.resolve("ab"));
        subDir_11.resolve("file_4.txt").toFile().createNewFile();

        FileUtils.moveRecursively(sourceDir, targetDir);

        assertThat(sourceDir).doesNotExist();
        assertThat(targetDir.resolve("a/file_1.txt")).exists();
        assertThat(targetDir.resolve("a/file_2.txt")).exists();
        assertThat(targetDir.resolve("a/file_3.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_1.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_2.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_3.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_4.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_1.txt")).exists();
        assertThat(targetDir.resolve("a/ab/file_2.txt")).exists();
        assertThat(targetDir.resolve("a/ac/")).exists();
        assertThat(targetDir.resolve("b/file_1.txt")).exists();
        assertThat(targetDir.resolve("b/file_2.txt")).exists();

        // Tests that existing files are not replaced but trigger an error.

        sourceDir = Files.createDirectory(tmpDir.resolve("source3"));
        subDir_1 = Files.createDirectory(sourceDir.resolve("a"));
        subDir_1.resolve("file_3.txt").toFile().createNewFile();
        FileUtils.moveRecursively(sourceDir, targetDir);

        assertThat(sourceDir).exists();
        assertThat(sourceDir.resolve("a/file_3.txt")).exists();
        assertThat(targetDir.resolve("a/file_3.txt")).exists();
    }

    @Test
    public void testDeleteDirectoryIfEmpty() throws IOException
    {
        Path tmpDir = Files.createTempDirectory(this.getClass().getSimpleName());
        Path subDir_1 = Files.createDirectory(tmpDir.resolve("a"));
        Path subDir_2 = Files.createDirectory(tmpDir.resolve("b"));
        Path file_1 = subDir_2.resolve("file_1.txt");
        file_1.toFile().createNewFile();

        FileUtils.deleteDirectoryIfEmpty(subDir_1);
        assertThat(subDir_1).doesNotExist();

        FileUtils.deleteDirectoryIfEmpty(subDir_2);
        assertThat(subDir_2).exists();

        Assertions.assertThatThrownBy(() -> FileUtils.deleteDirectoryIfEmpty(file_1))
                  .isInstanceOf(IllegalArgumentException.class)
                  .hasMessageContaining("is not a directory");
    }


    private File createFolder(Path path)
    {
        File folder = new File(path);
        FileUtils.createDirectory(folder);
        return folder;
    }

    private File createFile(File file, long size)
    {
        try
        {
            Util.setFileLength(file, size);
        }
        catch (Exception e)
        {
            System.err.println(e);
        }
        return file;
    }
}
