import { spawn } from "child_process"
import { readdir } from "fs/promises"

function spawnAsync(command: string) {
    return new Promise<void>((resolve, reject) => {
        const child = spawn(command, { shell: true, stdio: "inherit" })

        child.on("exit", code => {
            if (code !== 0) return reject(new Error(`Command failed with code ${code}`))
            resolve()
        })
    })
}

async function main() {
    const dir = await readdir("./")
    const exts = dir.filter(name => name.endsWith(".vsix"))

    for (const ext of exts) await spawnAsync(`code --install-extension "${ext}"`)
}

main()

// 反斜杠，需要使用[]包裹，并且使用 4 个 \
const slug = "${TM_DIRECTORY/[\\\\]//g}"

// 非反斜杠，也需要使用[]包裹，并且使用 4 个 \
const slug = "${TM_DIRECTORY/[^\\\\]//g}"

import fetch from "node-fetch"
import YAML from "yaml"

export namespace Winget {
    export interface Package {
        PackageIdentifier: string
        PackageVersion: string
        InstallerType: string
        InstallModes: string[]
        InstallerSwitches: InstallerSwitches
        ExpectedReturnCodes: ExpectedReturnCode[]
        UpgradeBehavior: string
        Protocols: string[]
        FileExtensions: string[]
        AppsAndFeaturesEntries: AppsAndFeaturesEntry[]
        Installers: Installer[]
        ManifestType: string
        ManifestVersion: string
    }

    export interface Installer {
        Architecture: string
        Scope: string
        InstallerUrl: string
        InstallerSha256: string
        InstallerSwitches: InstallerSwitches2
        ProductCode: string
    }

    export interface InstallerSwitches2 {
        Custom: string
    }

    export interface AppsAndFeaturesEntry {
        UpgradeCode: string
        InstallerType: string
    }

    export interface ExpectedReturnCode {
        InstallerReturnCode: number
        ReturnResponse: string
    }

    export interface InstallerSwitches {
        Log: string
    }
}

export type WingetDownloadInfo = {
    name: string
    id: string
    dir: string
    architecture?: "x64" | "x86" | "all"
}

export interface GithubContent {
    name: string
    path: string
    sha: string
    size: number
    url: string
    html_url: string
    git_url: string
    download_url?: string | null
    type: string
    _links: Links
}

export interface Links {
    self: string
    git: string
    html: string
}

export type WingetItem = {
    filename: string
    version: string
    ext: string
    architecture: string
}

export async function downloadFromWinget({ name, id, dir, architecture = "x64" }: WingetDownloadInfo) {
    const firstLetter = id[0].toLowerCase()
    const path = id.replace(/\./g, "/")
    const response = await fetch(`https://api.github.com/repos/microsoft/winget-pkgs/contents/manifests/${firstLetter}/${path}`, { agent })
    const data: GithubContent[] = (await response.json()) as any
    const reg2 = /^\d+(\.\d+?)*$/
    const stables = data.filter(item => reg2.test(item.name))

    stables.sort((a, b) => {
        const avs = a.name.split(".")
        const bvs = b.name.split(".")
        const max = Math.max(avs.length, bvs.length)

        for (let i = 0; i < max; i++) {
            const av = avs[i] ? parseInt(avs[i]) : 0
            const bv = bvs[i] ? parseInt(bvs[i]) : 0
            if (av < bv) return 1
            if (av > bv) return -1
        }

        return 0
    })

    const response2 = await fetch(
        `https://raw.githubusercontent.com/microsoft/winget-pkgs/master/manifests/${firstLetter}/${path}/${stables[0].name}/${id}.installer.yaml`,
        { agent },
    )
    const yaml = await response2.text()
    const pkg: Winget.Package = YAML.parse(yaml)

    const installers = pkg.Installers.filter((item, index) => {
        if (item.Architecture !== "x64" && item.Architecture !== "x86") return false
        if (architecture !== "all" && item.Architecture !== architecture) return false
        if (!item.InstallerUrl.endsWith(".exe") && !item.InstallerUrl.endsWith(".msi")) return false
        if (item.InstallerUrl.endsWith(".msi") && pkg.Installers.some(item2 => item2.Architecture === item.Architecture && item2.InstallerUrl.endsWith(".exe")))
            return false
        if (pkg.Installers.findIndex(item2 => item2.Architecture === item.Architecture) !== index) return false
        return true
    })

    const result: WingetItem[] = []

    for (const { InstallerUrl, Architecture } of installers) {
        if (Architecture !== "x64" && Architecture !== "x86") continue
        const filename = await download(InstallerUrl, dir)

        result.push({
            filename,
            version: pkg.PackageVersion,
            ext: InstallerUrl.endsWith(".exe") ? "exe" : "msi",
            architecture: Architecture,
        })
    }

    for (const { version, filename, architecture, ext } of result) {
        await sleep(100)
        await rename(join(dir, filename), join(dir, `${name}_${version}_${architecture}.${ext}`))
    }
}

/** 从 \w 中去除 \d */
const reg: RegExp = /[(?!\d)\w]/

import { HttpsProxyAgent } from "https-proxy-agent"
import fetch from "node-fetch"

// 代理服务器的URL
const proxyUrl = "http://your-proxy-server:port"

// 目标URL，即你想要通过代理服务器访问的URL
const targetUrl = "http://example.com"

// 配置代理服务器
const proxyAgent = new HttpsProxyAgent(proxyUrl)

// 使用fetch发起请求，通过代理服务器访问目标URL
fetch(targetUrl, { agent: proxyAgent })

window.addEventListener(
    "error",
    e => {
        const { target } = e

        // 判断是否是图片元素的错误
        if (!(target instanceof HTMLImageElement)) return

        const url = new URL(target.src)

        // 判断是否是第三方的图片
        if (url.origin === location.origin) return

        // 添加 data-error-image 属性
        target.dataset.errorImage = ""
    },
    true,
)

async function main() {
    const { default: A } = await import("a")
}