import {
    DeviceConfig,
    ArchConfig,
    serializeDcfg,
    decodeDcfg,
    decompileDcfg,
    DcfgSettings,
    parseAnyInt,
    UF2File,
    DCFG_MAGIC0,
    DCFG_MAGIC1,
    expandDcfgJSON,
    jsonToDcfg,
    boardInfos,
    RepoInfo,
    pinsInfo,
} from "@devicescript/compiler"
import { JSON5TryParse } from "@devicescript/interop"
import { HexInt } from "@devicescript/srvcfg"
import { readFile, writeFile } from "fs/promises"
import { read32, toHex } from "jacdac-ts"
import { basename, dirname, join, resolve } from "path"
import { error, isVerbose, log, verboseLog } from "./command"

export interface FileTypes {
    uf2?: string
    bin?: string
}

export interface BinPatchArgs {
    binary: Uint8Array // UF2 or BIN file
    type: keyof FileTypes
    arch: ArchConfig
    board: DeviceConfig
    dcfg?: DcfgSettings
    fstor?: Uint8Array
}

export interface BinPatchOptions extends FileTypes {
    slug?: string
    outdir?: string
    elf?: string
    generic?: boolean
    fake?: boolean
}

function fatal(msg: string) {
    error("fatal: " + msg)
    process.exit(1)
}

function isDCFG(data: Uint8Array, off = 0) {
    return (
        read32(data, off) == DCFG_MAGIC0 && read32(data, off + 4) == DCFG_MAGIC1
    )
}

async function patchUF2File(args: BinPatchArgs) {
    const { binary, arch, board, fstor, dcfg } = args

    if (!UF2File.isUF2(binary)) throw new Error("not a UF2 file")

    const f = UF2File.fromFile(binary)

    // needed for RP2040-E14
    const align = parseAnyInt(arch.uf2Align)
    if (align) {
        const amask = align - 1
        let maxAddr = 0
        for (const b of f.fromBlocks) {
            maxAddr = Math.max(b.targetAddr + b.payloadSize, maxAddr)
        }
        if (maxAddr & amask) {
            const left = align - (maxAddr & amask)
            const filler = new Uint8Array(left)
            filler.fill(0xff)
            f.writeBytes(maxAddr, filler)
        }
    }

    if (dcfg) {
        const dcfgOff = parseAnyInt(arch.dcfgOffset)
        let dcfgBuf = serializeDcfg(dcfg)

        const tmp = f.readBytes(dcfgOff, 12)
        if (tmp) {
            if (isDCFG(tmp)) {
                log(`patching existing config`)
                dcfgBuf = padCfg(dcfgBuf, read32(tmp, 8))
            } else {
                throw new Error(`data already at DCFG`)
            }
        }

        f.writeBytes(dcfgOff, dcfgBuf)
    }

    if (fstor) {
        const fstorOff = parseAnyInt(board.fstorOffset ?? arch.fstorOffset)
        if (f.readBytes(fstorOff, 4))
            throw new Error(`data already at flash offset`)
        f.writeBytes(fstorOff, fstor)
    }

    return f.serialize()
}

function padCfg(cfg: Uint8Array, minsz: number) {
    if (minsz > 1024 * 1024) throw new Error("too large config!")
    const res = new Uint8Array(Math.max(cfg.length, minsz))
    res.set(cfg)
    return res
}

async function patchBinFile(args: BinPatchArgs) {
    const { binary, arch, dcfg, board, fstor } = args
    const shift = parseAnyInt(arch.binFlashOffset) ?? 0
    const dcfgOff = parseAnyInt(arch.dcfgOffset) - shift
    const fstorOff = parseAnyInt(board.fstorOffset ?? arch.fstorOffset) - shift
    const pageSize = board.flashPageSize ?? arch.flashPageSize ?? 4096
    let dcfgBuf = dcfg ? serializeDcfg(dcfg) : null

    if (UF2File.isUF2(binary)) throw new Error("expecting BIN, not UF2 file")
    if (dcfgOff > 16 * 1024 * 1024) throw new Error("offset too large for BIN")
    if (fstorOff > 16 * 1024 * 1024)
        throw new Error("fstor offset too large for BIN")

    let minSize = binary.length
    if (dcfg) minSize = Math.max(minSize, dcfgOff + dcfgBuf.length)
    if (fstor) minSize = Math.max(minSize, fstorOff + fstor.length)
    minSize = (minSize + (pageSize - 1)) & ~(pageSize - 1)

    verboseLog(`size: ${binary.length} -> ${minSize} bytes`)

    const output = new Uint8Array(minSize)
    output.fill(0xff)
    output.set(binary)

    if (dcfg) {
        if (isDCFG(output, dcfgOff)) {
            verboseLog("patching existing")
            dcfgBuf = padCfg(dcfgBuf, read32(output, dcfgOff + 8))
        } else {
            const slice = toHex(output.slice(dcfgOff, dcfgOff + 8))
            if (slice == "0000000000000000" || slice == "ffffffffffffffff")
                verboseLog("patching 00 or ff")
            else throw new Error("data already at patch point!")
        }
        output.set(dcfgBuf, dcfgOff)
    }

    if (fstor) {
        for (let i = 0; i < fstor.length; ++i)
            if (output[fstorOff + i] != 0x00 && output[fstorOff + i] != 0xff)
                throw new Error("data already at fstor patch point!")
        output.set(fstor, fstorOff)
    }

    return output
}

function compileBoard(arch: ArchConfig, devcfg: DeviceConfig) {
    const dcfg = jsonToDcfg(devcfg, true)
    if (!dcfg["devName"]) throw new Error(`no devName`)
    if (!dcfg["productId"]) throw new Error(`no productId`)
    const { desc, errors } = pinsInfo(arch, devcfg)
    if (errors.length) throw new Error(errors.join("\n"))
    if (isVerbose) {
        verboseLog(desc)
        verboseLog(JSON.stringify(dcfg, null, 4))
        const ser = serializeDcfg(dcfg)
        const dec = decodeDcfg(ser)
        verboseLog(dec.errors.join("\n"))
        verboseLog(JSON.stringify(decompileDcfg(dec.settings), null, 4))
    } else if (devcfg.$custom) {
        log(desc)
    }
    return dcfg
}

export async function compileDcfgFile(fn: string) {
    if (!fn.endsWith(".board.json"))
        throw new Error("board file has to match *.board.json")
    const folder = dirname(fn)
    const readF = (f: string) => readFile(resolve(folder, f), "utf-8")
    const arch: ArchConfig = JSON5TryParse(await readF("arch.json"))
    if (arch?.dcfgOffset === undefined || arch?.id === undefined)
        throw new Error(`no dcfgOffset or id in arch.json`)
    const json: DeviceConfig = await expandDcfgJSON(basename(fn), readF)
    for (const s of json.$services ?? []) {
        if (!s.name) s.name = s.service
    }
    for (const s of json.services ?? []) {
        if (!s.name) s.name = s.service
    }
    json.id = basename(fn, ".board.json")
    json.archId = arch.id
    try {
        const dcfg = compileBoard(arch, json)
        return { json, dcfg, arch }
    } catch (e) {
        throw new Error(`${fn}: ${e.message}`)
    }
}

const patch: Record<
    keyof FileTypes,
    (args: BinPatchArgs) => Promise<Uint8Array>
> = {
    bin: patchBinFile,
    uf2: patchUF2File,
}

export async function patchCustomBoard(
    fn: string,
    board: DeviceConfig,
    arch: ArchConfig
) {
    board.$custom = true
    const dcfg = compileBoard(arch, board)
    const type = fn.replace(/.*\./, "") as keyof FileTypes
    if (!patch[type]) throw new Error(`unknown file format: ${type}`)
    const binary = await readFile(fn)
    return await patchFile({ type, binary, arch, board, dcfg })
}

export async function patchFstorToBoard(
    fn: string,
    board: DeviceConfig,
    arch: ArchConfig,
    fstor: Uint8Array
) {
    const type = fn.replace(/.*\./, "") as keyof FileTypes
    if (!patch[type]) throw new Error(`unknown file format: ${type}`)
    const binary = await readFile(fn)
    return await patchFile({ type, binary, arch, board, fstor })
}

async function patchFile(args: BinPatchArgs) {
    const f = patch[args.type]
    return f(args)
}

export async function binPatch(files: string[], options: BinPatchOptions) {
    let binFn = ""
    let ft: keyof FileTypes = undefined
    for (const k of Object.keys(patch) as (keyof FileTypes)[]) {
        const opt = options[k]
        if (!opt) continue
        if (ft) fatal(`both --${ft} and --${k} provided`)
        ft = k
        binFn = opt
    }

    if (!ft) fatal("no file type provided")

    const binary = options.fake ? null : await readFile(binFn)
    const outpath = options.outdir || "dist"
    const outext = options.uf2 ? ".uf2" : ".bin"
    const binext = (off: HexInt) => {
        const v = parseAnyInt(off)
        return v == undefined ? outext : `-0x${v.toString(16)}${outext}`
    }

    const infoPath = join(outpath, "info.json")

    const info: RepoInfo = {
        archs: {},
        boards: {},
    }

    if (options.slug) info.repoUrl = "https://github.com/" + options.slug

    const ex: RepoInfo = JSON5TryParse(
        await readFile(infoPath, "utf-8").then(
            r => r,
            _ => ""
        )
    )
    if (ex) Object.assign(info, ex)

    try {
        for (const fn of files) {
            log(`processing ${fn}...`)
            const { dcfg, json, arch } = await compileDcfgFile(fn)
            const suff = binext(arch.binFlashOffset)
            const outname = (devid: string, ext = suff) =>
                join(outpath, `devicescript-${arch.id}-${devid}${ext}`)
            const outp = outname(json.id)
            if (info.repoUrl)
                json.$fwUrl =
                    info.repoUrl + "/releases/latest/download/" + basename(outp)
            info.archs[arch.id] = arch
            info.boards[json.id] = json
            if (options.fake) continue

            const patched = await patchFile({
                type: ft,
                binary,
                arch,
                board: json,
                dcfg,
            })
            log(`writing ${outp}: ${patched.length} bytes`)
            await writeFile(outp, patched)
            if (options.generic || arch.binGenericFlashOffset !== undefined) {
                const offpatched = parseAnyInt(arch.binFlashOffset)
                const offgen = parseAnyInt(arch.binGenericFlashOffset)
                let off = 0
                if (offgen !== undefined) off = offgen - offpatched
                await writeFile(
                    outname("generic", binext(offgen ?? offpatched)),
                    binary.slice(off)
                )
                const elfFileBuf = await readFile(
                    options.elf ?? binFn.replace(/\.[^\.]+$/, ".elf")
                )
                await writeFile(outname("generic", ".elf"), elfFileBuf)
            }
        }
    } catch (e) {
        verboseLog(e.stack)
        fatal(e.message)
    }

    await writeFile(infoPath, JSON.stringify(info))
    await writeFile(
        join(outpath, "info.md"),
        boardInfos(info)
            .map(b => b.markdown)
            .join("\n\n")
    )
}