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

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

/**
 * Utility class for handling files.
 *
 * @author Michele Mostarda (mostarda@fbk.eu)
 */
public class FileUtils {

    /**
     * Moves a <code>target</code> file to a new <code>dest</code> location.
     *
     * @param target
     *            file to be moved.
     * @param dest
     *            dest dir.
     * 
     * @return destination file.
     */
    public static File mv(File target, File dest) {
        if (!dest.isDirectory()) {
            throw new IllegalArgumentException("destination must be a directory.");
        }

        final File newFile = new File(dest, target.getName());
        boolean success = target.renameTo(newFile);
        if (!success) {
            throw new IllegalStateException(
                    String.format(Locale.ROOT, "Cannot move target file [%s] to destination [%s]", target, newFile));
        }
        return newFile;
    }

    /**
     * Copies the content of the input stream within the given dest file. The dest file must not exist.
     *
     * @param is
     *            {@link java.io.InputStream} to copy
     * @param dest
     *            detination to copy it to.
     */
    public static void cp(InputStream is, File dest) {
        if (dest.exists()) {
            throw new IllegalArgumentException("Destination must not exist.");
        }
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(is);
            FileOutputStream fos = new FileOutputStream(dest);
            bos = new BufferedOutputStream(fos);
            final byte[] buffer = new byte[1024 * 4];
            int read;
            while (true) {
                read = bis.read(buffer);
                if (read == -1) {
                    break;
                }
                bos.write(buffer, 0, read);
            }
        } catch (Exception e) {
            throw new RuntimeException("Error while copying stream into file.", e);
        } finally {
            StreamUtils.closeGracefully(bis);
            StreamUtils.closeGracefully(bos);
        }
    }

    /**
     * Copies a file <code>src</code> to the <code>dest</code>.
     *
     * @param src
     *            source file.
     * @param dest
     *            destination file.
     * 
     * @throws java.io.FileNotFoundException
     *             if file cannot be copied or created.
     */
    public static void cp(File src, File dest) throws FileNotFoundException {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(src);
            cp(fis, dest);
        } finally {
            StreamUtils.closeGracefully(fis);
        }
    }

    /**
     * Dumps the given string within a file.
     *
     * @param f
     *            file target.
     * @param content
     *            content to be dumped.
     * 
     * @throws IOException
     *             if there is an error dumping the content
     */
    public static void dumpContent(File f, String content) throws IOException {
        Writer fw = null;
        try {
            fw = new OutputStreamWriter(new FileOutputStream(f), StandardCharsets.UTF_8);
            fw.write(content);
        } finally {
            StreamUtils.closeGracefully(fw);
        }
    }

    /**
     * Dumps the stack trace of the given exception into the specified file.
     *
     * @param f
     *            file to generate dump.
     * @param t
     *            exception to be dumped.
     * 
     * @throws IOException
     *             if there is an error dumping the content
     */
    public static void dumpContent(File f, Throwable t) throws IOException {
        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        final PrintWriter pw = new PrintWriter(new OutputStreamWriter(baos, StandardCharsets.UTF_8), true);
        t.printStackTrace(pw);
        pw.close();
        dumpContent(f, baos.toString("UTF-8"));
    }

    /**
     * Reads a resource file and returns the content as a string.
     *
     * @param clazz
     *            the class to use load the resource.
     * @param resource
     *            the resource to be load.
     * 
     * @return the string representing the file content.
     * 
     * @throws java.io.IOException
     *             if there is an error loading the resource
     */
    public static String readResourceContent(Class clazz, String resource) throws IOException {
        return StreamUtils.asString(clazz.getResourceAsStream(resource));
    }

    /**
     * Reads a resource file and returns the content as a string.
     *
     * @param resource
     *            the resource to be load.
     * 
     * @return the string representing the file content.
     * 
     * @throws java.io.IOException
     *             if there is an error loading the resource
     */
    public static String readResourceContent(String resource) throws IOException {
        return readResourceContent(FileUtils.class, resource);
    }

    /**
     * Returns the content of a file a single string.
     *
     * @param f
     *            the file to read.
     * 
     * @return the content of file.
     * 
     * @throws IOException
     *             if an error occurs while locating or accessing the file.
     */
    public static String readFileContent(File f) throws IOException {
        FileInputStream fis = new FileInputStream(f);
        return StreamUtils.asString(fis, true);
    }

    /**
     * Returns all the lines of a file.
     *
     * @param f
     *            the file to read.
     * 
     * @return a not <code>null</code> array with not <code>null</code> line strings.
     * 
     * @throws IOException
     *             if an error occurs while locating or accessing the file.
     */
    public static String[] readFileLines(File f) throws IOException {
        FileInputStream fis = new FileInputStream(f);
        return StreamUtils.asLines(fis);
    }

    /**
     * Lists the content of a dir applying the specified filter.
     *
     * @param dir
     *            directory root.
     * @param filenameFilter
     *            filter to be applied.
     * 
     * @return list of matching files.
     */
    public static File[] listFilesRecursively(File dir, FilenameFilter filenameFilter) {
        if (!dir.isDirectory()) {
            throw new IllegalArgumentException(dir.getAbsolutePath() + " must be a directory.");
        }
        final List<File> result = new ArrayList<File>();
        visitFilesRecursively(dir, filenameFilter, result);
        return result.toArray(new File[result.size()]);
    }

    /**
     * Visits a directory recursively, applying the given filter and adding matches to the result list.
     *
     * @param dir
     *            directory to find.
     * @param filenameFilter
     *            filter to apply.
     * @param result
     *            result list.
     */
    private static void visitFilesRecursively(File dir, FilenameFilter filenameFilter, List<File> result) {
        for (File file : dir.listFiles()) {
            if (!file.isDirectory()) {
                if (filenameFilter == null || filenameFilter.accept(dir, file.getName())) {
                    result.add(file);
                }
            } else {
                visitFilesRecursively(file, filenameFilter, result);
            }
        }
    }

    /**
     * Function class.
     */
    private FileUtils() {
    }

}
