import fs, { readFileSync } from "fs"
import path from "path"
import { XrayApi } from "./xray-api.js"

// const subnets = [
//     "192.168.10",
//     "192.168.11",
//     "192.168.12",
//     "192.168.13",
//     "192.168.14"
// ]
const net = {
    6: ["192.168.10"],
    7: ["192.168.11", "192.168.12"],
    8: ["192.168.13", "192.168.14"]
}
const subnets = Object.keys(net).flatMap(i => net[i])
const files = ["US-IPWEB.json", "US-IPMOYU.json"]

const map = {}

subnets.forEach(subnet => {
    files.forEach(file => {
        const data = JSON.parse(
            fs.readFileSync(path.resolve("proxies", subnet, file)).toString()
        )
        let outbounds = []
        let routingRules = []
        data.forEach(([i, url, username, password]) => {
            const tag = `${subnet.replaceAll("192.168.", "")}-${file.replaceAll(
                ".json",
                ""
            )}-${i}`
            const [host, port] = url.split(":")
            outbounds.push({
                tag,
                protocol: "http",
                settings: {
                    servers: [
                        {
                            address: host,
                            port: parseInt(port),
                            users: [
                                {
                                    user: username,
                                    pass: password
                                }
                            ]
                        }
                    ]
                }
            })
            routingRules.push({
                type: "field",
                user: [tag],
                outboundTag: tag
            })
        })
        const name = `${subnet.replaceAll("192.168.", "")}-${file.replace(
            ".json",
            ""
        )}`
        map[name] = {
            outbounds,
            routingRules,
            subnet
        }
    })
})

fs.writeFileSync(path.resolve("dist", "map.json"), JSON.stringify(map, null, 2))

const xray = JSON.parse(
    fs.readFileSync(path.resolve("config", "xray.json")).toString()
)
xray.outbounds = xray.outbounds.concat(
    Object.keys(map).flatMap(name => map[name].outbounds)
)
xray.routing.rules = xray.routing.rules.concat(
    Object.keys(map).flatMap(name => map[name].routingRules)
)

fs.writeFileSync(
    path.resolve("dist", "xray_edited.json"),
    JSON.stringify(xray, null, 2)
)

const accounts = [
    {
        url: "https://laboratory.mesgity.top:2053/KWO7yYJTJ3",
        username: "+jokCah2",
        password: "L9kZkc1j"
    }
]

for (let account of accounts) {
    const xrayApi = new XrayApi(account.url, account.username, account.password)
    await xrayApi.login()
    await xrayApi.update(xray)

    const template = fs
        .readFileSync(path.resolve("config", "template.yaml"))
        .toString()
    for (let name of Object.keys(map)) {
        const ips = [...Array(200).keys()].map(
            i => `${map[name].subnet}.${i + 50}`
        )
        const res = await xrayApi.add(
            name,
            map[name].outbounds.map(outbound => outbound.tag)
        )
        const groups = []
        const rules = []
        let c = 0
        for (let i = 0; i < ips.length; i++) {
            const groupName = `${name}-GROUP-${parseInt(i / 2)}`
            if (i % 2 === 0) {
                groups.push(
                    `  - name: ${groupName}
    type: url-test
    url: http://www.gstatic.com/generate_204
    interval: 150
    tolerance: 50
    proxies:
      - ${name}-${++c}
      - ${name}-${++c}`
                )
            }
            rules.push(`  - SRC-IP-CIDR,${ips[i]}/32,${groupName}`)
        }
        const proxies = res.map(i => `  - ${i.config}`)
        map[name].config = {
            proxies,
            groups,
            rules
        }
        let config_file = template
            .replace("${proxy}", proxies.join("\n"))
            .replace("${group}", groups.join("\n"))
            .replace("${rule}", rules.join("\n"))
        fs.writeFileSync(path.resolve("dist", `${name}.yaml`), config_file)
    }
}

const configs = {}
for (let key of Object.keys(net)) {
    Object.entries(map)
        .filter(([name, value]) => {
            return net[key]
                .map(i => i.replaceAll("192.168.", ""))
                .includes(name.split("-")[0])
        })
        .forEach(([name, value]) => {
            let n = key + "-" + name.split("-").splice(1).join("-")
            if (!configs[n]) {
                configs[n] = {
                    proxies: [],
                    groups: [],
                    rules: []
                }
            }
            configs[n].proxies = configs[n].proxies.concat(value.config.proxies)
            configs[n].groups = configs[n].groups.concat(value.config.groups)
            configs[n].rules = configs[n].rules.concat(value.config.rules)
        })
}

for (let key of Object.keys(configs)) {
    const template = fs
        .readFileSync(path.resolve("config", "template.yaml"))
        .toString()
    let config_file = template
        .replace("${proxy}", configs[key].proxies.join("\n"))
        .replace("${group}", configs[key].groups.join("\n"))
        .replace("${rule}", configs[key].rules.join("\n"))
    fs.writeFileSync(path.resolve("dist", `${key}.yaml`), config_file)
}