import java.nio.file.Files
import java.nio.file.Paths
import java.util.regex.Pattern
import java.util.stream.Stream

class VersionComparator implements Comparator<String> {

    static private final List<String> SNAPSHOT_SUFFIXES = ["-SNAPSHOT", ".BUILD-SNAPSHOT"].asImmutable()

    int compare(String o1, String o2) {
        int result = 0
        if (o1 == '*') {
            result = 1
        }
        else if (o2 == '*') {
            result = -1
        }
        else {
            def nums1
            try {
                def tokens = deSnapshot(o1).split(/\./)
                tokens = tokens.findAll { String it -> it.trim() ==~ /\d+/ }
                nums1 = tokens*.toInteger()
            }
            catch (NumberFormatException e) {
                throw new Exception("Cannot compare versions, left side [$o1] is invalid: ${e.message}")
            }
            def nums2
            try {
                def tokens = deSnapshot(o2).split(/\./)
                tokens = tokens.findAll { String it -> it.trim() ==~ /\d+/ }
                nums2 = tokens*.toInteger()
            }
            catch (NumberFormatException e) {
                throw new Exception("Cannot compare versions, right side [$o2] is invalid: ${e.message}")
            }
            boolean bigRight = nums2.size() > nums1.size()
            boolean bigLeft = nums1.size() > nums2.size()
            for (int i in 0..<nums1.size()) {
                if (nums2.size() > i) {
                    result = nums1[i].compareTo(nums2[i])
                    if (result != 0) {
                        break
                    }
                    if (i == (nums1.size()-1) && bigRight) {
                        if (nums2[i+1] != 0)
                            result = -1; break
                    }
                }
                else if (bigLeft) {
                    if (nums1[i] != 0)
                        result = 1; break
                }
            }
        }

        if (result == 0) {
            // Versions are equal, but one may be a snapshot.
            // A snapshot version is considered less than a non snapshot version
            def o1IsSnapshot = isSnapshot(o1)
            def o2IsSnapshot = isSnapshot(o2)

            if (o1IsSnapshot && !o2IsSnapshot) {
                result = -1
            } else if (!o1IsSnapshot && o2IsSnapshot) {
                result = 1
            }
        }

        result
    }

    boolean equals(obj) { false }

    /**
     * Removes any suffixes that indicate that the version is a kind of snapshot
     */
    protected String deSnapshot(String version) {
        String suffix = SNAPSHOT_SUFFIXES.find { String it -> version?.endsWith(it) }
        if (suffix) {
            return version[0..-(suffix.size() + 1)]
        } else {
            return version
        }
    }

    protected boolean isSnapshot(String version) {
        SNAPSHOT_SUFFIXES.any { String it -> version?.endsWith(it) }
    }


}

class adxetools {
    static int compareVersion(String ver1, String ver2) {
        return new VersionComparator().compare(ver1, ver2);
    }

    static String[] findNDK(String ndkVer){
        def allowNewerNdk = false
        if(ndkVer.endsWith('+')) {
            allowNewerNdk = true
            ndkVer = ndkVer.substring(0, ndkVer.length() - 1)
        }

        def ndkRoot = Paths.get("${System.env.ANDROID_NDK}")
        if(Files.exists(ndkRoot)) {
            ndkRoot = ndkRoot.toAbsolutePath().toString()
            def properties = new Properties()
            File propertiesFile = new File("$ndkRoot/source.properties")
            propertiesFile.withInputStream {
                properties.load(it)
                def foundNdkVer = properties['Pkg.Revision']
                def ret = adxetools.compareVersion(foundNdkVer, ndkVer)
                if(ret == 0) {
                    println("Using found ndk (revision=$foundNdkVer,path=$ndkRoot)")
                }
                else if(ret > 0){
                    if(allowNewerNdk) {
                        println("Using found newer ndk (revision=$foundNdkVer,path=$ndkRoot), (minimum required is: ${ndkVer})")
                        ndkVer = foundNdkVer
                    }
                    else {
                        throw new GradleException("The ndk ${ndkVer} is required, but $foundNdkVer found!")
                    }
                }
                else {
                    throw new GradleException("The ndk ${ndkVer}+ is required, but $foundNdkVer found!")
                }
            }
        }
        else {
            ndkRoot = null
            println("No installed ndk found, the gradle will install ndk: $ndkVer automatically")
        }

        def rets = new String[2]
        rets[0] = ndkVer
        rets[1] = ndkRoot
        return rets
    }

    static String findCMake(String cmakeVer, rootProject) {
        def allowNewerCMake = false
        if(cmakeVer.endsWith('+')) {
            allowNewerCMake = true
            cmakeVer = cmakeVer.substring(0, cmakeVer.length() - 1)
        }

        def cmakeBinDirs = []

        def cmakeBinDir = getCMakeBinFromLocal(rootProject)
        if(cmakeBinDir != null) {
            cmakeBinDirs.add(cmakeBinDir);
        }

        def sdkRoot = Paths.get("${System.env.ANDROID_SDK}")

        if(Files.exists(sdkRoot)) {
            sdkRoot = sdkRoot.toAbsolutePath().toString()
            def verList = ["3.10.2.4988404", "3.18.1"]
            for(foundVer in verList){
                cmakeBinDir = sdkRoot + File.separator + "cmake" + File.separator + foundVer + File.separator + "bin"

                if(new File(cmakeBinDir).isDirectory()) {
                    cmakeBinDirs.add(cmakeBinDir)
                }
            }
        }

        cmakeBinDir = getCMakeBinFromPath()
        if(cmakeBinDir != null) {
            cmakeBinDirs.add(cmakeBinDir)
        }

        // find in cmakeBinDirs
        def foundCMakeVer = null
        for(item in cmakeBinDirs) {
            foundCMakeVer = findCMakeFromBinDir(cmakeVer, item, allowNewerCMake)
            if(foundCMakeVer != null) {
                break
            }
        }

        if(foundCMakeVer == null) {
            println("No suitable cmake found, required $cmakeVer, the gradle will install it")
            foundCMakeVer = cmakeVer
        }

        return foundCMakeVer
    }
    
    static String findCMakeFromBinDir(String cmakeVer, String cmakeBin, boolean allowNewerCMake) {
        def foundCMakeVer = null
        
        String ninjaPath = cmakeBin + File.separator + getNinjaProgramName()
        if(!new File(ninjaPath).isFile()) {
            println("The required ninja program is not present in cmake bin dir!")
            return null
        }

        try {
            def programPath = cmakeBin + File.separator + getCMakeProgramName()
            Process proc = isWindows() ? Runtime.getRuntime().exec("\"$programPath\" --version") : Runtime.getRuntime().exec("$programPath --version")
            proc.waitFor()
            int exitVal = proc.exitValue()
            if (exitVal == 0) {
                InputStream stdIn = proc.getInputStream();
                InputStreamReader isr = new InputStreamReader(stdIn);
                BufferedReader br = new BufferedReader(isr);
                String verLine = br.readLine();
                def verInfo = verLine.split("\\s")
                if (verInfo.length >= 3) {
                    def foundVer = verInfo[2]
                    def minusIdx = foundVer.indexOf('-')
                    def canonVer = minusIdx == -1 ? foundVer : foundVer.substring(0, minusIdx)
                    def ret = adxetools.compareVersion(canonVer, cmakeVer)
                    if (ret == 0) {
                        println("Using found cmake version: $canonVer")
                        foundCMakeVer = canonVer
                    }
                    else if(ret > 0) {
                        if(allowNewerCMake) {
                            println("Using found newer cmake (version=$canonVer,path=$programPath), (minimum required is: ${cmakeVer})")
                            foundCMakeVer = canonVer
                        }
                        else {
                            println("The cmake ${cmakeVer} is required, but $canonVer found!")
                        }
                    }
                }
            }
        }
        catch(Exception ex) {
            println("Execute cmake failed: " + ex.message)
        }

        return foundCMakeVer
    }

    static String getCMakeBinFromLocal(rootProject) {
        String programName = getCMakeProgramName();
        Properties properties = new Properties()
        try {
            properties.load(rootProject.file("local.properties"))
            def cmakeDir = properties.getProperty("cmake.dir")
            if(cmakeDir != null) {
                def cmakeBin = "$cmakeDir/bin"
                if(new File("$cmakeBin/$programName").isFile())
                    return cmakeBin;
            }
        }
        catch(Exception) {
        }

        return null
    }

    static String getCMakeBinFromPath() {
        String cmakeExecName = getCMakeProgramName();
        def foundBinPath = null
        Stream.of(System.getenv("PATH").split(Pattern.quote(File.pathSeparator)))
                .map(Paths::get)
                .anyMatch(path -> {
                    def programPath = path.resolve(cmakeExecName);
                    boolean fileExist = Files.exists(path.resolve(cmakeExecName))
                    if(fileExist) {
                        foundBinPath = path.toAbsolutePath().toString()
                    }
                    return fileExist
                });

        return foundBinPath
    }

    static String getCMakeProgramName() {
        return isWindows() ? "cmake.exe" : "cmake"
    }
    
    static String getNinjaProgramName() {
        return isWindows() ? "ninja.exe" : "ninja"
    } 
    
    static boolean isWindows() {
        return System.getProperty("os.name").toLowerCase().contains("windows");
    }
}

ext.adxetools = adxetools