const dll = Deno.dlopen('KernelBase.dll', {
    'GetCommPorts': {
        parameters: [
            'pointer',
            'u32',
            'u32'
        ],
        result: 'u32'
    }
})

const ports = 0;

const ptr = Deno.UnsafePointer.create(ports)

const portsWritten = 0

const result = dll.symbols.GetCommPorts(ptr, 20, portsWritten)
console.log(result, ports, portsWritten);

export type BooleanMap = [
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean,
    boolean
]

export function symbolFromArray(array : BooleanMap) : string {
    const restructuredArray = [
        array[0], array[2],
        array[4], array[1],
        array[3], array[5],
        array[6], array[7]
    ]
    const base = 0x2800
    const code = restructuredArray.reduceRight((lastBoolean, currentBoolean) => lastBoolean << 1 | + currentBoolean, 0)
    return String.fromCharCode(base + code)
}

console.log('\x1b[1m' + Deno.cwd() + '\x1b[0m');

const symbols = {
    EDGE: `└─ `,
    BLANK: '   ',
    STRAIGHT: '│  ',
    CROSSING: '├─ '
}

function readDirRecursive(path : string, indents : string[]) {
    [...Deno.readDirSync(path)].forEach((dirEntry, dirIndex, dir) => {

        const isLast = dirIndex == (dir.length - 1);
        const indentsString = indents.join('');

        if (isLast) {
            console.log(`${indentsString}${symbols.EDGE}${dirEntry.isDirectory ? '\x1b[1;34m' + dirEntry.name + '\x1b[0m' : '\x1b[32m' + dirEntry.name + '\x1b[0m'}`);
            indents.push(symbols.BLANK);
        } else {
            console.log(`${indentsString}${symbols.CROSSING}${dirEntry.isDirectory ? '\x1b[1;34m' + dirEntry.name + '\x1b[0m' : '\x1b[32m' + dirEntry.name + '\x1b[0m'}`);
            indents.push(symbols.STRAIGHT);
        }

        if (dirEntry.isDirectory) {
            readDirRecursive(`${path}/${dirEntry.name}`, indents);
        }

        indents.pop();
    })
}

readDirRecursive('./', []);

Deno.stdin.setRaw(true)

Deno.stdout.write(new TextEncoder().encode('\x9b6n'));

for await (const chunk of Deno.stdin.readable) {
    const text = new TextDecoder().decode(chunk.slice(2));
    console.log(text);
    break;
}

Deno.stdin.setRaw(true)
function write(str : string) {
    Deno.stdout.write(new TextEncoder().encode(str))
}

write('\x1b[?1003h\x1b[?1006h\x1b[2J\x1b[H\x1b[?25l')

write('ANSI/xTerm control codes are now monitored.\n')

const controlCharactersMap : {[key : number] : string} = {
    0x00: 'NUL',
    0x01: 'SOH',
    0x02: 'STX',
    0x03: 'ETX',
    0x04: 'EOT',
    0x05: 'ENQ',
    0x06: 'ACK',
    0x07: 'BEL',
    0x08: 'BS',
    0x09: 'TAB',
    0x0a: 'LF',
    0x0b: 'VT',
    0x0c: 'FF',
    0x0d: 'CR',
    0x0e: 'SO',
    0x0f: 'SI',
    0x10: 'DLE',
    0x11: 'DC1',
    0x12: 'DC2',
    0x13: 'DC3',
    0x14: 'DC4',
    0x15: 'NAK',
    0x16: 'SYN',
    0x17: 'ETB',
    0x18: 'CAN',
    0x19: 'EM',
    0x1a: 'SUB',
    0x1b: 'ESC',
    0x1c: 'FS',
    0x1d: 'GS',
    0x1e: 'RS',
    0x1f: 'US',
    0x20: 'SP',
    0x7f: 'DEL'
}

const conductors = [
    '['
]

const sequences = [
    '<',
    '~',
    '?'
]

const instructionDividers = [
    ';'
]

const ends = [
    'm',
    'M',
    'A',
    'B',
    'C',
    'D',
    'F',
    'H'
]

for await (const chunk of Deno.stdin.readable) {

    const coloredArray : string[] = [];
    const coloredString : string[] = [];

    chunk.forEach((char, index, {length}) => {
        const charCode = String.fromCharCode(char)
        let color = '\x1b[38;5;15m'
        let escapeCode = false;

        if (
            (
                char >= 0x00
                &&
                char <= 0x1f
            ) || (
                char === 0x7f
            ) || (
                char === 0x20
            )
        ) {
            escapeCode = true;
            color = '\x1b[38;5;5m'
        } else if ( conductors.includes(charCode) ) {
            color = '\x1b[38;5;4m'
        } else if ( 
            sequences.includes(charCode)
            &&
            length != 1
        ) {
            color = '\x1b[38;5;3m'
        } else if ( instructionDividers.includes(charCode) ) {
            color = '\x1b[38;5;8m'
        } else if (
            ends.includes(charCode)
            && 
            (length > 1)
            &&
            (index === length - 1)
        ) {
            color = '\x1b[38;5;2m'
        }

        if (escapeCode) {
            coloredArray.push(`${color}\x1b[4m${char.toString(16).toUpperCase()}\x1b[24m(${controlCharactersMap[char]})\x1b[0m`)
            coloredString.push(`${color}${controlCharactersMap[char]}\x1b[0m`)
        } else {
            coloredArray.push(`${color}\x1b[4m${char.toString(16).toUpperCase()}\x1b[24m(${charCode})\x1b[0m`)
            coloredString.push(`${color}${charCode}\x1b[0m`)
        }
        
    })

    console.log(`${coloredString.join('')} \x1b[38;5;8m[\x1b[0m${coloredArray.join('\x1b[38;5;8m, \x1b[0m')}\x1b[38;5;8m]\x1b[0m`);
}

import { walk } from "https://deno.land/[email protected]/fs/walk.ts";
import { parse } from "https://deno.land/[email protected]/flags/mod.ts";
import { relative, join } from "https://deno.land/[email protected]/path/mod.ts";
import { copySync, ensureFileSync } from "https://deno.land/[email protected]/fs/mod.ts";

const args = parse(Deno.args)

const srcPath = args._[0].toString() ?? './'
const distPath = args._[1].toString() ?? './dist/'
const exts = (args.exts as string).split(',')

for await (const entry of walk(srcPath, {includeDirs: false, exts: exts})) {
    const from = entry.path;
    const to = join(distPath, relative(srcPath, entry.path));
    console.log(from, '=>', to);
    
    ensureFileSync(to)
    copySync(from, to, {overwrite: true});
}

// https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
const ANSI_PATTERN = new RegExp(
  [
    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
    "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TXZcf-nq-uy=><~]))",
  ].join("|"),
  "g",
);