import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs"
import SmallLicense from "../src/Models/smallLicense"
import ScriptUtils from "./ScriptUtils"
import Script from "./Script"
import { Utils } from "../src/Utils"

const prompt = require("prompt-sync")()

export class GenerateLicenseInfo extends Script {
    private static readonly needsLicenseRef = new Set(
        ScriptUtils.readDirRecSync("./LICENSES")
            .map((p) => p.substring(p.lastIndexOf("/") + 1))
            .filter((p) => p.startsWith("LicenseRef-"))
            .map((p) => p.substring("LicenseRef-".length))
            .map((p) => p.substring(0, p.lastIndexOf(".")))
    )

    constructor() {
        super("Validates the licenses and compiles them into one single asset file")
    }

    static defaultLicenses() {
        const knownLicenses = new Map<string, SmallLicense>()
        knownLicenses.set("me", {
            authors: ["Pieter Vander Vennet"],
            path: undefined,
            license: "CC0",
            sources: [],
        })
        knownLicenses.set("streetcomplete", {
            authors: ["Tobias Zwick (westnordost)"],
            path: undefined,
            license: "CC0",
            sources: [
                "https://github.com/streetcomplete/StreetComplete/tree/master/res/graphics",
                "https://f-droid.org/packages/de.westnordost.streetcomplete/",
            ],
        })

        knownLicenses.set("temaki", {
            authors: ["Temaki"],
            path: undefined,
            license: "CC0",
            sources: [
                "https://github.com/ideditor/temaki",
                "https://ideditor.github.io/temaki/docs/",
            ],
        })

        knownLicenses.set("maki", {
            authors: ["Maki"],
            path: undefined,
            license: "CC0",
            sources: ["https://labs.mapbox.com/maki-icons/"],
        })

        knownLicenses.set("t", {
            authors: [],
            path: undefined,
            license: "CC0; trivial",
            sources: [],
        })
        knownLicenses.set("na", {
            authors: [],
            path: undefined,
            license: "CC0",
            sources: [],
        })
        knownLicenses.set("carto", {
            authors: ["OSM-Carto"],
            path: undefined,
            license: "CC0",
            sources: [""],
        })
        knownLicenses.set("tv", {
            authors: ["Toerisme Vlaanderen"],
            path: undefined,
            license: "CC0",
            sources: [
                "https://toerismevlaanderen.be/pinjepunt",
                "https://mapcomplete.org/toerisme_vlaanderenn",
            ],
        })
        knownLicenses.set("tvf", {
            authors: ["Jo De Baerdemaeker "],
            path: undefined,
            license: "All rights reserved",
            sources: ["https://www.studiotype.be/fonts/flandersart"],
        })
        knownLicenses.set("twemoji", {
            authors: ["Twemoji"],
            path: undefined,
            license: "CC-BY 4.0",
            sources: ["https://github.com/twitter/twemoji"],
        })
        return knownLicenses
    }

    validateLicenseInfo(l: SmallLicense) {
        l.sources.map((s) => {
            try {
                return new URL(s)
            } catch (e) {
                throw "Could not parse URL " + s + " for a license for " + l.path + " due to " + e
            }
        })
    }

    /**
     * Sweeps the entire 'assets/' (except assets/generated) directory for image files and any 'license_info.json'-file.
     * Checks that the license info is included for each of them and generates a compiles license_info.json for those
     */

    generateLicenseInfos(paths: string[]): SmallLicense[] {
        const licenses = []
        for (const path of paths) {
            try {
                const parsed = JSON.parse(readFileSync(path, { encoding: "utf8" }))
                if (Array.isArray(parsed)) {
                    const l: SmallLicense[] = parsed
                    for (const smallLicens of l) {
                        smallLicens.path =
                            path.substring(0, path.length - "license_info.json".length) +
                            smallLicens.path
                    }
                    licenses.push(...l)
                } else {
                    const smallLicens: SmallLicense = parsed
                    smallLicens.path =
                        path.substring(0, 1 + path.lastIndexOf("/")) + smallLicens.path
                    licenses.push(smallLicens)
                }
            } catch (e) {
                console.error("Error: ", e, "while handling", path)
            }
        }
        return licenses
    }

    async mostlyWhite(allIcons: string[]) {
        const whitePaths = new Set<string>()
        for (const icon of allIcons) {
            if (!icon.endsWith(".svg")) {
                continue
            }

            const svg = await ScriptUtils.ReadSvg(icon)

            const colours = new Set<string>()
            Utils.WalkObject(
                svg,
                (leaf) => {
                    const style = leaf["style"].split(";")
                    for (const styleElement of style) {
                        const [key, value] = styleElement.split(":").map((x) => x.trim())
                        if (value === "none") {
                            continue
                        }
                        if (key === "fill" || key === "stroke") {
                            colours.add(value)
                        }
                        return colours
                    }
                },
                (leaf) => typeof leaf["style"] === "string"
            )
            if (colours.size === 0) {
                continue
            }
            const whiteColours = Array.from(colours).map((c) => {
                const rgb = Utils.color(c)
                if (!rgb) {
                    console.log("Could not parse ", c)
                    return false
                }
                const { r, g, b } = rgb
                return r > 245 && g > 245 && b > 245
            })
            const hasDark = whiteColours.some((isWhite) => !isWhite)
            if (!hasDark) {
                whitePaths.add(icon)
            }
        }
        return whitePaths
    }

    missingLicenseInfos(licenseInfos: SmallLicense[], allIcons: string[]) {
        const missing = []

        const knownPaths = new Set<string>()
        for (const licenseInfo of licenseInfos) {
            knownPaths.add(licenseInfo.path)
        }

        for (const iconPath of allIcons) {
            if (iconPath.indexOf("license_info.json") >= 0) {
                continue
            }
            if (knownPaths.has(iconPath)) {
                continue
            }
            missing.push(iconPath)
        }
        return missing
    }

    promptLicenseFor(path): SmallLicense {
        const knownLicenses = GenerateLicenseInfo.defaultLicenses()
        console.log("License abbreviations:")
        knownLicenses.forEach((value, key) => {
            console.log(key, " => ", value)
        })
        const author = prompt(
            "What is the author for artwork " + path + "? (or: [Q]uit, [S]kip)  > "
        )
        path = path.substring(path.lastIndexOf("/") + 1)

        if (knownLicenses.has(author)) {
            const license = knownLicenses.get(author)
            license.path = path
            return license
        }

        if (author == "s") {
            return null
        }
        if (author == "Q" || author == "q" || author == "") {
            throw "Quitting now!"
        }
        return {
            authors: author.split(";"),
            path: path,
            license: prompt("What is the license for artwork " + path + "?  > "),
            sources: prompt("Where was this artwork found?  > ").split(";"),
        }
    }

    createLicenseInfoFor(path): void {
        const li = this.promptLicenseFor(path)
        if (li == null) {
            return
        }
        writeFileSync(path + ".license_info.json", JSON.stringify(li, null, "  "))
    }

    /**
     * Rewrites a license into a SPDX-valid-ID.
     * Might involve some guesswork (e.g. 'CC-BY-SA' --> 'CC-BY-SA 4.0"
     * @param licenseId
     */
    toSPDXCompliantLicense(licenseId: string): string {
        licenseId = licenseId.trim()
        // https://spdx.org/licenses/
        const mappings: Record<string, string> = {
            "CC-0": "CC0-1.0",
            CC0: "CC0-1.0",
            "CC-BY-4.0-INTERNATIONAL": "CC-BY-4.0",
            "CC-4.0": "CC-BY-4.0",
            "CC-BY": "CC-BY-4.0",
            "CC-BY-SA-4.0-INTERNATIONAL": "CC-BY-SA-4.0",
            "CC-BY-SA": "CC-BY-SA-4.0",
            "CREATIVE-COMMONS-4.0-BY-NC": "CC-BY-NC-4.0",
            "CC-BY-SA-3.0-UNPORTED": "CC-BY-SA-3.0",
            "ISC-LICENSE": "ISC",
            "LOGO-BY-THE-GOVERNMENT": "LOGO",
            PD: "PUBLIC-DOMAIN",
            "LOGO-(ALL-RIGHTS-RESERVED)": "LOGO",
            /*  ALL-RIGHTS-RESERVED:
            PD:
                PUBLIC-DOMAIN:
        TRIVIAL: //*/
        }

        return mappings[licenseId] ?? licenseId
    }

    cleanLicenseInfo(allPaths: string[], allLicenseInfos: SmallLicense[]) {
        // Read the license info file from the generated assets, creates a compiled license info in every directory
        // Note: this removes all the old license infos
        for (const licensePath of allPaths) {
            unlinkSync(licensePath)
        }

        const perDirectory = new Map<string, SmallLicense[]>()

        for (const license of allLicenseInfos) {
            const p = license.path
            const dir = p.substring(0, p.lastIndexOf("/"))
            license.path = p.substring(dir.length + 1)
            if (!perDirectory.has(dir)) {
                perDirectory.set(dir, [])
            }
            const cloned: SmallLicense = {
                // We make a clone to force the order of the keys
                path: license.path,
                license: license.license,
                authors: license.authors,
                sources: license.sources,
            }

            cloned.license = Utils.Dedup(
                cloned.license.split(";").map((l) => this.toSPDXCompliantLicense(l))
            ).join("; ")
            if (cloned.license === "CC0-1.0; TRIVIAL") {
                cloned.license = "TRIVIAL"
            }
            if (cloned.license === "LOGO; ALL-RIGHTS-RESERVED") {
                cloned.license = "LOGO"
            }
            cloned.license = cloned.license.split("; ").join(" AND ")

            perDirectory.get(dir).push(cloned)
        }

        perDirectory.forEach((licenses, dir) => {
            for (let i = licenses.length - 1; i >= 0; i--) {
                const license = licenses[i]
                const path = dir + "/" + license.path
                if (!existsSync(path)) {
                    console.log(
                        "Found license for now missing file: ",
                        path,
                        " - removing this license"
                    )
                    licenses.splice(i, 1)
                }
            }

            licenses.sort((a, b) => (a.path < b.path ? -1 : 1))
            const path = dir + "/license_info.json"
            if (licenses.length === 0) {
                console.log("Removing", path, "as it is empty")
                // No need to _actually_ unlik, this is done above
            } else {
                writeFileSync(path, JSON.stringify(licenses, null, 2))
            }
        })
    }

    queryMissingLicenses(missingLicenses: string[]) {
        process.on("SIGINT", function () {
            console.log("Aborting... Bye!")
            process.exit()
        })

        let i = 1
        for (const missingLicens of missingLicenses) {
            console.log(i + " / " + missingLicenses.length)
            i++
            if (i < missingLicenses.length - 5) {
                //    continue
            }
            this.createLicenseInfoFor(missingLicens)
        }

        console.log("You're through!")
    }

    /**
     * Creates the humongous license_info in the generated assets, containing all licenses with a path relative to the root
     * @param licensePaths
     */
    createFullLicenseOverview(licensePaths: string[], mostlyWhite: string[]) {
        const allLicenses: SmallLicense[] = []
        for (const licensePath of licensePaths) {
            if (!existsSync(licensePath)) {
                continue
            }
            const licenses = <SmallLicense[]>(
                JSON.parse(readFileSync(licensePath, { encoding: "utf8" }))
            )
            for (const license of licenses) {
                this.validateLicenseInfo(license)
                const dir = licensePath.substring(
                    0,
                    licensePath.length - "license_info.json".length
                )
                license.path = dir + license.path
                if (mostlyWhite.some((l) => license.path === l)) {
                    license["mostly_white"] = true
                }
                allLicenses.push(license)
            }
        }

        writeFileSync(
            "./src/assets/generated/license_info.json",
            JSON.stringify(allLicenses, null, "  ")
        )
    }

    async main(args: string[]) {
        console.log("Checking and compiling license info")

        if (!existsSync("./src/assets/generated")) {
            mkdirSync("./src/assets/generated")
        }

        const contents = ScriptUtils.readDirRecSync("./assets").filter(
            (entry) => entry.indexOf("./assets/generated") != 0
        )
        const licensePaths = contents.filter((entry) => entry.indexOf("license_info.json") >= 0)
        const licenseInfos = this.generateLicenseInfos(licensePaths)

        const artwork = contents.filter(
            (pth) => pth.match(/(.svg|.png|.jpg|.ttf|.otf|.woff|.jpeg)$/i) != null
        )
        const missingLicenses = this.missingLicenseInfos(licenseInfos, artwork)
        const mostlyWhite: Set<string> = await this.mostlyWhite(artwork)
        if (args.indexOf("--prompt") >= 0 || args.indexOf("--query") >= 0) {
            this.queryMissingLicenses(missingLicenses)
            return this.main([])
        }

        const invalidLicenses = licenseInfos
            .filter((l) => (l.license ?? "") === "")
            .map((l) => `License for artwork ${l.path} is empty string or undefined`)

        for (const licenseInfo of licenseInfos) {
            const isTrivial = licenseInfo.license
                .split(";")
                .map((l) => l.trim().toLowerCase())
                .some((s) => s.endsWith("trivial"))
            if (licenseInfo.sources.length + licenseInfo.authors.length == 0 && !isTrivial) {
                invalidLicenses.push(
                    "Invalid license: No sources nor authors given in the license for " +
                        JSON.stringify(licenseInfo)
                )
                continue
            }

            for (const source of licenseInfo.sources) {
                if (source == "") {
                    invalidLicenses.push(
                        "Invalid license: empty string in " + JSON.stringify(licenseInfo)
                    )
                }
                try {
                    new URL(source)
                } catch {
                    invalidLicenses.push("Not a valid URL: " + source)
                }
            }

            const spdxPath = licenseInfo.path + ".license"

            const spdxContent = [
                "SPDX-FileCopyrightText: " + licenseInfo.authors.join("; "),
                "SPDX-License-Identifier: " +
                    licenseInfo.license
                        .split(" AND ")
                        .map((s) => this.addLicenseRef(s))
                        .join(" AND "),
            ]
            writeFileSync(spdxPath, spdxContent.join("\n"))
        }

        if (missingLicenses.length > 0 || invalidLicenses.length) {
            const msg = `There are ${missingLicenses.length} licenses missing and ${invalidLicenses.length} invalid licenses.`
            console.log(missingLicenses.concat(invalidLicenses).join("\n"))
            console.error(msg)
            if (args.indexOf("--no-fail") < 0) {
                throw msg
            }
        }

        this.cleanLicenseInfo(licensePaths, licenseInfos)
        this.createFullLicenseOverview(licensePaths, Array.from(mostlyWhite))
    }

    /**
     * Some licenses need "LicenseRef-" to be added to make reuse lint work
     * @param s
     * @private
     */
    private addLicenseRef(s: string): string {
        if (GenerateLicenseInfo.needsLicenseRef.has(s)) {
            return "LicenseRef-" + s
        }
        return s
    }
}

new GenerateLicenseInfo().run()