import * as fs from 'node:fs';
import * as path from 'node:path';

// Constants
export const INDENT = '    ';
export const POINTER_SIZE = 4;
export const RTTI_SIZE = POINTER_SIZE;
export const EXTENSION = '.def';
export const STRUCTURE_FILES: Record<string, string> = {};
export const COMMENT = '//';
export const INTERNAL = '__';
export const LEAN_HEADER_GUARD = '#ifndef LEAN_SYMBOLS_HEADER\n';
// Read Definition File
export function readDefinition(name: string) {
    if (!STRUCTURE_FILES[name]) {
        throw new Error(`Missing Definition File: ${name}${EXTENSION}`);
    }
    return fs.readFileSync(STRUCTURE_FILES[name], {encoding: 'utf8'});
}
// Error Handling
export function extendErrorMessage(e: unknown, message: string) {
    let extra: string | null = null;
    if (typeof e === 'string') {
        extra = e;
    } else if (e instanceof Error) {
        extra = e.message;
    }
    if (extra) {
        message += ': ' + extra;
    }
    return message;
}
export function syntaxError(message?: string): never {
    throw new Error(extendErrorMessage(message, 'Syntax Error'));
}
// Convert 'int x' Into {type: 'int', name: 'x'}
const POINTER_TOKENS = ['*', '&'];
export function parseTypeAndName(piece: string) {
    // Split On Last Space
    const index = piece.lastIndexOf(' ');
    if (index === -1) {
        syntaxError('Unable To Find Name/Type Divider');
    }
    let name = piece.substring(index + 1);
    let type = piece.substring(0, index);
    // Move Asterisks From Name To Type
    while (POINTER_TOKENS.some(x => name.startsWith(x))) {
        const x = name.substring(0, 1);
        name = name.substring(1);
        if (!POINTER_TOKENS.some(x => type.endsWith(x))) {
            type += ' ';
        }
        type += x;
    }
    // Return
    return {type, name};
}
// Convert To Uppercase-Snake-Case
export function toUpperSnakeCase(str: string) {
    let wasUpper = false;
    let nextIsUpper = false;
    let out = '';
    for (let i = 0; i < str.length; i++) {
        let character = str.charAt(i);
        if (character === '_') {
            wasUpper = false;
            nextIsUpper = true;
            continue;
        }
        const isUpper = character === character.toUpperCase() || nextIsUpper;
        nextIsUpper = false;
        character = character.toUpperCase();
        if (isUpper && i > 0 && !wasUpper) {
            out += '_';
        }
        out += character;
        wasUpper = isUpper;
    }
    return out;
}
// Convert 'int' To 'int ' But Leave 'int *' As Is
export function formatType(type: string) {
    if (!POINTER_TOKENS.some(x => type.endsWith(x))) {
        type += ' ';
    }
    return type;
}
// Convert Number To Hexadecimal
export function toHex(x: number) {
    return '0x' + x.toString(16);
}
// Generate C++ Size Assertion
export function assertSize(name: string, size: number) {
    return `static_assert(sizeof(${name}) == ${toHex(size)}, "Invalid Size");\n`;
}
// Parse Integer With Error Checking
export function safeParseInt(str: string) {
    const x = parseInt(str);
    if (isNaN(x)) {
        throw new Error('Invalid Integer: ' + str);
    }
    return x;
}
// Generate "Self" Argument For Functions
export function getSelfArg(type: string) {
    return `${type} *self`;
}
// Prepend Argument To Function
export function prependArg(args: string, arg: string) {
    if (args !== '()') {
        arg += ', ';
    }
    return '(' + arg + args.substring(1);
}
// Get Data Directory
export function getDataDir() {
    return path.join(__dirname, '..', 'data');
}
// Format File From Data Directory
export function formatFile(file: string, options: Record<string, string>) {
    // Include Other Files
    const dataDir = getDataDir();
    const otherFiles = fs.readdirSync(dataDir);
    for (let otherFile of otherFiles) {
        otherFile = path.join(dataDir, otherFile);
        options[`include ${otherFile}`] = fs.readFileSync(otherFile, 'utf8');
    }
    // Format
    file = path.join(dataDir, file);
    let data = fs.readFileSync(file, 'utf8');
    for (const key in options) {
        const value = options[key];
        if (value) {
            data = data.replace(`{{ ${key} }}`, value);
        }
    }
    return data.trim() + '\n';
}
// Generate Code That Will Disable C++ Construction
export function preventConstruction(self: string) {
    let out = '';
    out += `${INDENT}${INTERNAL}PREVENT_CONSTRUCTION(${self});\n`;
    out += `${INDENT}${INTERNAL}PREVENT_COPY(${self});\n`;
    return out;
}