package net.knarcraft.minecraftserverlauncher.utility;

import net.knarcraft.minecraftserverlauncher.Main;
import net.knarcraft.minecraftserverlauncher.profile.Collection;
import net.knarcraft.minecraftserverlauncher.server.Server;
import net.knarcraft.minecraftserverlauncher.userinterface.GUI;
import net.knarcraft.minecraftserverlauncher.userinterface.WebBrowser;

import java.io.*;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.util.Scanner;

/**
 * A holding class for methods shared between classes.
 *
 * @author Kristian Knarvik <kristian.knarvik@knett.no>
 * @version 1.0.0
 * @since 1.0.0
 */
public final class CommonFunctions {

    private static final String filesDirectory = Main.getApplicationWorkDirectory() + File.separator + "files";

    /**
     * Creates all folders necessary for tests and normal operation
     *
     * @throws FileNotFoundException <p>If unable to create a folder</p>
     */
    public static void createAllFolders() throws FileNotFoundException {
        createFolder(new File(filesDirectory));
        createFolder(new File(filesDirectory + File.separator + "Jars"));
        createFolder(new File(filesDirectory + File.separator + "testjars"));
    }

    /**
     * Creates a given folder
     *
     * @param folder <p>The folder to create</p>
     * @throws FileNotFoundException <p>If unable to create the folder</p>
     */
    private static void createFolder(File folder) throws FileNotFoundException {
        if (!folder.exists()) {
            if (!folder.mkdirs()) {
                throw new FileNotFoundException("Cannot create necessary directory.");
            }
        }
    }

    /**
     * Gets a resource as an InputStream
     *
     * @param resourceName <p>The name of the resource you want to readFromServer</p>
     * @return <p>An input stream which can be used to access the resource</p>
     */
    public static InputStream getResourceAsStream(String resourceName) {
        ClassLoader classloader = Thread.currentThread().getContextClassLoader();
        return classloader.getResourceAsStream(resourceName);
    }

    /**
     * Gets a resource as a Scanner
     *
     * @param resourceName <p>The name of the resource you want to readFromServer</p>
     * @return <p>A scanner which can be used to readFromServer contents of the resource</p>
     * @throws FileNotFoundException <p>If the resource is not found</p>
     */
    public static Scanner getResourceAsScanner(String resourceName) throws FileNotFoundException {
        InputStream is = getResourceAsStream(resourceName);
        if (is == null) {
            throw new FileNotFoundException("The resource was not found.");
        }
        return new Scanner(is);
    }

    /**
     * Finds a substring between two substrings in a string
     *
     * @param string <p>The string containing the substrings</p>
     * @param start  <p>The substring before the wanted substring</p>
     * @param end    <p>The substring after the wanted substring</p>
     * @return <p>The wanted substring</p>
     */
    public static String stringBetween(String string, String start, String end) {
        int startPos = string.indexOf(start) + start.length();
        if (!string.contains(start) || string.indexOf(end, startPos) < startPos) {
            return "";
        }
        return string.substring(startPos, string.indexOf(end, startPos));
    }

    /**
     * Reads a file from a website
     *
     * <p>This is used to find the newest version of jars and the software.</p>
     *
     * @param path <p>The full url of the file to readFromServer</p>
     * @return <p>True if successful. False otherwise</p>
     */
    public static String readFile(String path) throws IOException {
        URL url = new URL(path);
        return new Scanner(url.openStream()).useDelimiter("\\Z").next();
    }

    /**
     * Downloads a file from a website and replaces the target file
     *
     * @param path    <p>The full url of the file to download</p>
     * @param outfile <p>The file to save to</p>
     * @return <p>True if successful. False otherwise</p>
     */
    public static boolean downloadFile(String path, Path outfile) {
        try {
            URL url = new URL(path);
            InputStream in = url.openStream();
            Files.copy(in, outfile, StandardCopyOption.REPLACE_EXISTING);
            return true;
        } catch (IOException e) {
            return false;
        }
    }

    /**
     * Recursively copies a folder to another location
     *
     * @param source      <p>The folder to copy</p>
     * @param destination <p>Target destination</p>
     * @throws IOException <p>If we can't start a file stream</p>
     */
    public static void copyFolder(GUI serverLauncherGui, File source, File destination) throws IOException {
        if (!source.isDirectory()) {
            copyFile(serverLauncherGui, source, destination);
        } else {
            serverLauncherGui.setStatus("Copying directory " + source);
            if (!destination.exists() && !destination.mkdir()) {
                return;
            }
            String[] files = source.list();
            if (files != null) {
                for (String file : files) {
                    File srcFile = new File(source, file);
                    File destinationFile = new File(destination, file);
                    copyFolder(serverLauncherGui, srcFile, destinationFile);
                }
            }
            serverLauncherGui.setStatus("Copied directory " + source);
        }
    }

    /**
     * Copies a file from one location to another
     *
     * @param serverLauncherGui <p>The serverLauncherGui to use for alerting the user</p>
     * @param source            <p>The file to copy</p>
     * @param destination       <p>The location of the copied file</p>
     * @throws IOException <p>If reading or writing fails</p>
     */
    private static void copyFile(GUI serverLauncherGui, File source, File destination) throws IOException {
        serverLauncherGui.setStatus("Copying file " + source + "...");
        InputStream in = new FileInputStream(source);
        OutputStream out = new FileOutputStream(destination);
        byte[] buffer = new byte[1024];
        int length;
        while ((length = in.read(buffer)) > 0) {
            out.write(buffer, 0, length);
        }
        in.close();
        out.close();
        serverLauncherGui.setStatus("Copied file " + source);
    }

    /**
     * Opens an url in the user's default application.
     *
     * @param url <p>The URL to open</p>
     */
    public static void goToURL(String url) {
        java.awt.Desktop desktop = java.awt.Desktop.getDesktop();
        try {
            desktop.browse(new URI(url));
        } catch (URISyntaxException | IOException | UnsupportedOperationException e1) {
            WebBrowser.displayPage(url);
        }
    }

    /**
     * Reads all lines from a buffered reader
     *
     * @param reader <p>The buffered reader to read from</p>
     * @return <p>All lines currently readable from the reader, split by the \n character</p>
     * @throws IOException <p>If unable to read from the buffered reader</p>
     */
    public static String readBufferedReader(BufferedReader reader) throws IOException {
        String line;
        StringBuilder text = new StringBuilder();
        while (reader.ready() && (line = reader.readLine()) != null) {
            text.append(line).append("\n");
        }
        return text.toString().trim();
    }

    /**
     * Copies all server directories to a folder specified by the user.
     */
    public static void backup(GUI gui) {
        File path = gui.askForDirectory("Backup folder");
        for (Collection collection : Main.getController().getCurrentProfile().getCollections()) {
            //Ignore disabled and invalid servers
            if (collection.getServer().getPath().equals("") || !collection.getServer().isEnabled()) {
                continue;
            }
            //Decide sub-folders
            Server targetServer = collection.getServer();
            String name = targetServer.getName();
            File srcFolder = new File(targetServer.getPath());
            File destinationFolder = new File(path, name);
            //Create child folders
            if (!destinationFolder.exists() && !destinationFolder.mkdirs()) {
                throw new IllegalArgumentException("Unable to create necessary sub-folder in the backup folder");
            }
            //Backup
            try {
                CommonFunctions.copyFolder(gui, srcFolder, destinationFolder);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        gui.setStatus("Backup finished");
    }

    /**
     * Validates that a name is not empty and does not contain invalid characters
     *
     * @param name <p>The name to check</p>
     * @return <p>True if the name is valid</p>
     */
    public static boolean nameIsValid(String name) {
        return !name.equals("") && name.matches("[^!?;,]+");
    }
}