package me.mrkirby153.quarxel.manager;

import me.mrkirby153.quarxel.manager.extension.QuarxelExtension;
import me.mrkirby153.quarxel.manager.tasks.CreateServer;
import me.mrkirby153.quarxel.manager.tasks.RunBuildToolsTask;
import me.mrkirby153.quarxel.manager.tasks.util.DownloadTask;
import me.mrkirby153.quarxel.manager.tasks.util.ExtractFromJarTask;
import org.gradle.api.Action;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.Task;
import org.gradle.api.plugins.JavaPlugin;
import org.gradle.api.specs.Spec;
import org.gradle.api.tasks.Copy;
import org.gradle.api.tasks.JavaExec;
import org.gradle.api.tasks.bundling.AbstractArchiveTask;

import java.io.File;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Arrays;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;

public class QuarxelManagerPlugin implements Plugin<Project> {

    public Project project;

    @Override
    public void apply(Project project) {
        this.project = project;
        project.getExtensions().create("quarxel", QuarxelExtension.class);
        final QuarxelExtension obj = (QuarxelExtension) project.getExtensions().findByName("quarxel");
        project.getPluginManager().apply(JavaPlugin.class);
        project.afterEvaluate(new Action<Project>() {
            @Override
            public void execute(Project project) {
                afterEval(project, obj);
            }
        });
        File buildToolsLoc;
        {
            DownloadTask dt = makeTask("downloadBT", DownloadTask.class);
            dt.setUrl("https://hub.spigotmc.org/jenkins/view/All/job/BuildTools-Beta/lastSuccessfulBuild/artifact/target/BuildTools.jar");
            dt.setOutputFile(buildToolsLoc = new File(getGradleCache(), "BuildTools.jar"));
            dt.setGroup("QuarxelManager");
            dt.setDescription("Downloads Build Tools");
        }
        RunBuildToolsTask runBuildToolsTask = makeTask("runBuildTools", RunBuildToolsTask.class);
        {
            runBuildToolsTask.setWorkingDir(new File(project.getGradle().getGradleUserHomeDir().getAbsolutePath() + "/caches/QuarxelManager/BuildTools"));
            runBuildToolsTask.getWorkingDir().mkdirs();
            runBuildToolsTask.setBtLoc(buildToolsLoc);
            runBuildToolsTask.dependsOn("downloadBT");
            runBuildToolsTask.setOutput(new File(runBuildToolsTask.getWorkingDir(), "spigot-1.8.3.jar"));
            runBuildToolsTask.getOutputs().upToDateWhen(new Spec<Task>() {
                @Override
                public boolean isSatisfiedBy(Task task) {
                    File output = ((RunBuildToolsTask) task).getOutput();
                    if (!output.exists())
                        return false;
                    Calendar c = Calendar.getInstance();
                    c.setTimeInMillis(System.currentTimeMillis());
                    c.add(Calendar.WEEK_OF_YEAR, 14);
                    return output.lastModified() < c.getTimeInMillis();
                }
            });
        }
        {
            ExtractFromJarTask extractStartScript = makeTask("extractStartScript", ExtractFromJarTask.class);
            extractStartScript.setExtractLocation(new File(getGradleCache(), "start.bat"));
            File startLocation;
            URL startURL = QuarxelManagerPlugin.class.getResource("/start.bat");
            try {
                startLocation = new File(startURL.toURI());
            } catch (URISyntaxException ex) {
                startLocation = new File(startURL.getPath());
            }
            extractStartScript.setInputFile(startLocation);
        }
        {
            CreateServer createServer = makeTask("createServer", CreateServer.class);
            createServer.setGroup("QuarxelManager");
            createServer.setDescription("Creates a testing server");
            createServer.dependsOn("runBuildTools", "extractStartScript");
            createServer.setSpigotFile(runBuildToolsTask.getOutput());
        }
        {
           /* CopyTask task = makeTask("deployTestPlugin", CopyTask.class);
            AbstractArchiveTask jarTask = (AbstractArchiveTask) project.getTasks().getByName("jar");
            task.setSource(jarTask.getArchivePath());
            task.dependsOn("jar");*/
            Copy task = makeTask("deployTestPlugin", Copy.class);
            AbstractArchiveTask jarTask = (AbstractArchiveTask) project.getTasks().getByName("jar");
            task.from(jarTask.getArchivePath());
            task.dependsOn("jar");
        }
        {
            JavaExec start = makeTask("runServer", JavaExec.class);
            start.setMain("-jar");
            start.setStandardOutput(System.out);
            start.setStandardInput(System.in);
            start.setErrorOutput(System.err);

        }
    }

    @SuppressWarnings("unchecked")
    public <T extends Task> T makeTask(String name, Class<T> type) {
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("name", name);
        map.put("type", type);
        return (T) project.task(map, name);
    }

    public static void afterEval(Project project, final QuarxelExtension ext) {
        {
            CreateServer cst = ((CreateServer) project.getTasks().getByName("createServer"));
            final File serverFile = new File("." + File.separator + ext.getServerLocation());
            cst.setServerOutputDirectory(serverFile);
            cst.setSpigotOutputFile(new File(cst.getServerOutputDirectory(), "spigot.jar"));
            cst.setStartFileOutput(new File(cst.getServerOutputDirectory(), "start.bat"));
            cst.setStartFileInput(new File(project.getGradle().getGradleUserHomeDir().getAbsolutePath() + "/caches/QuarxelManager", "start.bat"));

            Copy ct = (Copy) project.getTasks().getByName("deployTestPlugin");
            AbstractArchiveTask jarTask = (AbstractArchiveTask) project.getTasks().getByName("jar");
            File pluginDest = new File(serverFile, "plugins");
            ct.into(pluginDest);

            JavaExec exec = (JavaExec) project.getTasks().getByName("runServer");
            List<String> jvmArgs = Arrays.asList(ext.getServerArgs().split(" "));
            exec.jvmArgs(jvmArgs);
            exec.args("spigot.jar");
            exec.workingDir(ext.getServerLocation());
        }
    }

    public File getGradleCache() {
        return new File(project.getGradle().getGradleUserHomeDir().getAbsolutePath() + "/caches/QuarxelManager");
    }
}