import java.nio.file.Files
import java.nio.file.Paths

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")
                }
                else if(ret > 0){
                    if(allowNewerNdk) {
                        println("Using found newer ndk revision=$foundNdkVer, required is: ${ndkVer}")
                        ndkVer = foundNdkVer
                    }
                    else {
                        throw new GradleException("${ndkVer} is required, but $foundNdkVer found!")
                    }
                }
                else {
                    throw new GradleException("${ndkVer}+ is required, but $foundNdkVer found!")
                }
            }
        }
        else {
            ndkRoot = null
            println("The gradle will install ndk: $ndkVer automatically")
        }

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

ext.adxetools = adxetools