/*
 * This file is a part of the SteamWar software.
 *
 * Copyright (C) 2020  SteamWar.de-Serverteam
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */


import org.apache.tools.ant.taskdefs.condition.Os

plugins {
    // Adding the base plugin fixes the following gradle warnings in IntelliJ:
    //
    // Warning: root project 'module-work-multi': Unable to resolve all content root directories
    // Details: java.lang.IllegalStateException: No value has been specified for this provider.
    //
    // Warning: root project 'module-work-multi': Unable to resolve additional project configuration.
    // Details: java.lang.IllegalStateException: No value has been specified for this provider.
    id 'base'
    id 'application'

    id 'com.github.johnrengelman.shadow' version '5.0.0'
}

ext.swdep = { s ->
    if (file("${rootDir}/lib/${s}.jar").exists()) {
        return files("${rootDir}/lib/${s}.jar")
    } else {
        if (s.contains("-")) {
            return "de.steamwar:${s.toLowerCase().replace('-', ':')}"
        } else {
            return "de.steamwar:${s.toLowerCase()}:RELEASE"
        }
    }
}

group 'de.steamwar'
version ''

Properties steamwarProperties = new Properties()
if (file("steamwar.properties").exists()) {
    steamwarProperties.load(file("steamwar.properties").newDataInputStream())
}

ext {
    buildName = 'BauSystem2.0'
    artifactName = 'bausystem2.0'

    uberJarName = "${buildName}-all.jar"
    jarName = "${artifactName}.jar"
    libs = "${buildDir}/libs"

    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
        operatingSystem = "windows"
    } else {
        operatingSystem = "unix"
    }
}

compileJava.options.encoding = 'UTF-8'
compileJava.options.compilerArgs << '-parameter'

sourceCompatibility = 11
targetCompatibility = 11

mainClassName = ''

allprojects {
    repositories {
        mavenCentral()

        maven {
            url = uri("https://repo.codemc.io/repository/maven-snapshots/")
        }

        maven {
            url = uri('https://hub.spigotmc.org/nexus/content/repositories/snapshots/')
        }

        maven {
            url = uri('https://libraries.minecraft.net')
        }

        maven {
            url = uri('https://steamwar.de/maven/')
            credentials {
                username = steamwarProperties.getProperty("maven.username")
                password = steamwarProperties.getProperty("maven.password")
            }
        }
    }
}

dependencies {
    file('.').listFiles().each {
        if (!it.isDirectory()) {
            return
        }
        if (new File(it, "build.gradle").exists()) {
            implementation project(":" + it.name)
        }
    }
}

task buildProject {
    description 'Build this project'
    group "Steamwar"

    dependsOn build
}

task finalizeProject {
    description 'Finalize this project'
    group "Steamwar"

    doLast {
        if ("${buildDir}" == null) {
            return
        }
        delete fileTree("${libs}").matching {
            exclude("${uberJarName}")
        }
        file(libs + "/" + uberJarName).renameTo(file(libs + "/" + jarName))
    }
}
build.finalizedBy(finalizeProject)

if (steamwarProperties.containsKey("hostname")) {
    String hostname = steamwarProperties.get("hostname")

    String type = steamwarProperties.getOrDefault("type", "Bau19")
    String world = steamwarProperties.getOrDefault("world", "")
    String pluginFolder = steamwarProperties.getOrDefault("pluginFolder", "")

    task uploadProject {
        description 'Upload this project'
        group "Steamwar"

        doLast {
            await(shell("scp ${libs}/${jarName} ${hostname}:${pluginFolder}"))
            if (steamwarProperties.getOrDefault("directStart", "false") == "false" && !answer("Start ${server} server?")) {
                return
            }
            serverStart(type, hostname, world, pluginFolder)
        }
    }
    uploadProject.dependsOn(buildProject)

    task startDevServer {
        description 'Start the DevServer'
        group "Steamwar"

        doLast {
            serverStart(server, "", hostname)
        }
    }
}

private def await(Process proc) {
    def out = new StringBuilder()
    def err = new StringBuilder()
    proc.waitForProcessOutput(out, err)
    return [out, err, proc.exitValue()]
}

private def shell(String command) {
    if (operatingSystem == "unix") {
        return ['bash', '-c', command].execute()
    } else {
        return ["cmd", "/c", command].execute()
    }
}

private def serverStart(String type, String hostname, String worldName, String pluginFolder) {
    def proc = shell("ssh -t ${hostname} \"./binarys/dev.py ${type} -w ${worldName} -p ${pluginFolder}\"")

    Set<String> strings = new HashSet<>()
    File file = new File("${projectDir}/ignoredlog");
    if (file.exists()) {
        new BufferedReader(new InputStreamReader(new FileInputStream(file))).readLines().forEach({ s ->
            strings.add(s)
        })
    }

    Thread outputThread = new Thread({
        Reader reader = proc.getInputStream().newReader();
        Writer writer = System.out.newWriter();
        try {
            while (proc.alive) {
                String s = reader.readLine()
                if (s == null) {
                    return
                }
                if (strings.stream().anyMatch({check -> s.contains(check)})) {
                    continue
                }
                writer.write(s + "\n")
                writer.flush()
            }
        } catch (IOException e) {
            // Ignored
        }
    })
    outputThread.setName("${type} - OutputThread")
    outputThread.start()

    Writer writer
    Thread inputThread = new Thread({
        Reader reader = System.in.newReader()
        writer = proc.getOutputStream().newWriter()
        try {
            while (proc.alive) {
                String s = reader.readLine()
                writer.write(s + "\n")
                writer.flush()
            }
        } catch (IOException e) {
            // Ignored
        }
    })
    inputThread.setName("${type} - InputThread")
    inputThread.start()

    gradle.buildFinished { buildResult ->
        if (!proc.alive) {
            return
        }
        writer = proc.getOutputStream().newWriter()
        writer.write("stop\n")
        writer.flush()
        awaitClose(proc, outputThread, inputThread)
    }
    awaitClose(proc, outputThread, inputThread)
};

private static def awaitClose(Process proc, Thread outputThread, Thread inputThread) {
    while (proc.alive) {
        Thread.sleep(10)
    }
    proc.closeStreams()
    outputThread.interrupt()
    inputThread.interrupt()
}

private def answer(String question) {
    while (System.in.available() > 0) System.in.read()
    println(question)
    boolean valid = "Yy".contains(((char) System.in.read()).toString())
    while (System.in.available() > 0) System.in.read()
    return valid
}