argv.ts

import assert from "node:assert";
import fs from "fs-extra";
import * as dotenv from "dotenv";
import * as path from "node:path";
import camelCase from "camelcase";
import {Utils} from "./utils.js";
import {WriteStreams} from "./write-streams.js";
import chalkBase from "chalk";
import chalk from "chalk-template";

export function splitSemicolonEnvVars (argv: Record<string, any>, arrayKeys: Set<string>, env: Record<string, string | undefined>): void {
    for (const [envKey, envValue] of Object.entries(env)) {
        if (!envKey.startsWith("GCL_") || envValue == null) continue;
        const optionName = camelCase(envKey.slice(4));
        if (!arrayKeys.has(optionName)) continue;
        const currentVal = argv[optionName];
        if (!Array.isArray(currentVal) || currentVal.length !== 1 || currentVal[0] !== envValue) continue;
        argv[optionName] = envValue.split(";");
    }
}

async function isInGitRepository () {
    try {
        await Utils.spawn(["git", "rev-parse", "--is-inside-work-tree"]);
        return true;
    } catch {
        return false;
    }
}

async function gitRootPath () {
    const {stdout} = await Utils.spawn(["git", "rev-parse", "--show-toplevel"]);
    return stdout;
}

const GCL_VARIABLE_PREFIX = "GCL_VARIABLE_";

// Removes GCL_VARIABLE_* entries from env (mutates) and returns the removed entries
export function stripGclVariableEnvVars (env: Record<string, string | undefined>): Record<string, string> {
    const stripped: Record<string, string> = {};
    for (const key of Object.keys(env)) {
        if (!key.startsWith(GCL_VARIABLE_PREFIX) || env[key] == null) continue;
        if (key.length > GCL_VARIABLE_PREFIX.length) {
            stripped[key] = env[key]!;
        }
        delete env[key];
    }
    return stripped;
}

// Prepends env vars so CLI --variable (later in array) takes precedence via last-wins
export function injectGclVariableEnvVars (argv: {variable?: string[]; [key: string]: unknown}, gclVars: Record<string, string>): void {
    for (const [envKey, envValue] of Object.entries(gclVars)) {
        const varName = envKey.slice(GCL_VARIABLE_PREFIX.length);
        argv.variable ??= [];
        argv.variable.unshift(`${varName}=${envValue}`);
    }
}

export class Argv {
    static readonly default = {
        "variablesFile": ".gitlab-ci-local-variables.yml",
        "inputsFile": ".gitlab-ci-local-inputs.yml",
        "evaluateRuleChanges": true,
        "ignoreSchemaPaths": [] as string[],
        "ignorePredefinedVars": [] as string[],
    };

    map: Map<string, any> = new Map<string, any>();
    private readonly writeStreams: WriteStreams | undefined;

    private async fallbackCwd (args: any) {
        if (args.cwd !== undefined || args.file !== undefined) return;
        if (fs.existsSync(`${process.cwd()}/.gitlab-ci.yml`)) return;
        if (!(await isInGitRepository())) return;

        this.writeStreams?.stderr(chalk`{yellow .gitlab-ci.yml not found in cwd, falling back to git root directory}\n`);
        this.map.set("cwd", path.relative(process.cwd(), await gitRootPath()));
    }

    static async build (args: any, writeStreams?: WriteStreams) {
        const argv = new Argv(args, writeStreams);
        await argv.fallbackCwd(args);

        argv.injectDotenv(`${argv.home}/.gitlab-ci-local/.env`, args);
        argv.injectDotenv(`${argv.cwd}/.gitlab-ci-local-env`, args);

        if (!argv.shellExecutorNoImage && argv.shellIsolation) {
            writeStreams?.stderr(chalk`{black.bgYellowBright  WARN } --shell-isolation does not work with --no-shell-executor-no-image\n`);
        }

        if (argv.defaultImageExplicitlySet && argv.shellIsolation) {
            writeStreams?.stderr(chalk`{black.bgYellowBright  WARN } --default-image does not work with --shell-isolation=true\n`);
        }

        if (argv.defaultImageExplicitlySet && argv.shellExecutorNoImage) {
            writeStreams?.stderr(chalk`{black.bgYellowBright  WARN } --default-image does not work with --shell-executor-no-image=true\n`);
        }

        if (argv.defaultImageExplicitlySet && argv.forceShellExecutor) {
            writeStreams?.stderr(chalk`{black.bgYellowBright  WARN } --default-image does not work with --force-shell-executor=true\n`);
        }

        return argv;
    }

    private constructor (argv: any, writeStreams?: WriteStreams) {
        if (argv.noColor || argv.color === false || (process.env.NO_COLOR ?? "") !== "") {
            chalkBase.level = 0;
        }
        this.writeStreams = writeStreams;
        for (const [key, value] of Object.entries(argv)) {
            this.map.set(key, value);
        }
    }

    private injectDotenv (potentialDotenvFilepath: string, argv: any) {
        if (!fs.existsSync(potentialDotenvFilepath)) return;

        const config = dotenv.parse(fs.readFileSync(potentialDotenvFilepath));
        for (const [key, value] of Object.entries(config)) {
            const argKey = camelCase(key);

            // variable is additive — merge dotenv values with CLI values
            if (argKey === "variable") {
                let currentVal = argv[argKey];
                if (currentVal == null) {
                    currentVal = [];
                    this.map.set(argKey, currentVal);
                }
                if (!Array.isArray(currentVal)) {
                    continue;
                }
                for (const pair of value.split(" ")) {
                    currentVal.unshift(pair);
                }
            } else if (argv[argKey] == null) {
                // Work around `dotenv.parse` limitation https://github.com/motdotla/dotenv/issues/51#issuecomment-552559070
                if (value === "true") this.map.set(argKey, true);
                else if (value === "false") this.map.set(argKey, false);
                else if (value === "null") this.map.set(argKey, null);
                else if (Number.isFinite(Number(value))) this.map.set(argKey, Number(value));
                else this.map.set(argKey, value);
            }
        }
    }

    private getStringArray (key: string): string[] {
        const val = this.map.get(key) ?? [];
        if (Array.isArray(val)) return val;
        if (typeof val === "string") return val.split(" ");
        return [];
    }

    get cwd (): string {
        let cwd = this.map.get("cwd") ?? ".";
        assert(typeof cwd != "object", "--cwd option cannot be an array");
        assert(!path.isAbsolute(cwd), "Please use relative path for the --cwd option");
        cwd = path.normalize(`${process.cwd()}/${cwd}`);
        cwd = cwd.replace(/\/$/, "");
        assert(fs.pathExistsSync(cwd), `${cwd} is not a directory`);
        return cwd;
    }

    get variablesFile (): string {
        return this.map.get("variablesFile") ?? Argv.default.variablesFile;
    }

    get inputsFile (): string {
        return this.map.get("inputsFile") ?? Argv.default.inputsFile;
    }

    get evaluateRuleChanges (): boolean {
        return this.map.get("evaluateRuleChanges") ?? Argv.default.evaluateRuleChanges;
    }

    get file (): string {
        return this.map.get("file") ?? ".gitlab-ci.yml";
    }

    get stateDir (): string {
        return (this.map.get("stateDir") ?? ".gitlab-ci-local").replace(/\/$/, "");
    }

    get home (): string {
        return (this.map.get("home") ?? process.env.HOME ?? "").replace(/\/$/, "");
    }

    get volume (): string[] { return this.getStringArray("volume"); }

    get network (): string[] { return this.getStringArray("network"); }

    get extraHost (): string[] { return this.getStringArray("extraHost"); }

    get caFile (): string | null {
        return this.map.get("caFile") ?? null;
    }

    get ignoreSchemaPaths (): string[] {
        return this.map.get("ignoreSchemaPaths") ?? Argv.default.ignoreSchemaPaths;
    }

    get ignorePredefinedVars (): string[] {
        const val = this.map.get("ignorePredefinedVars");
        if (Array.isArray(val)) return val;
        if (typeof val === "string" && val.length > 0) return val.split(",");
        return Argv.default.ignorePredefinedVars;
    }

    get pullPolicy (): string {
        return this.map.get("pullPolicy") ?? "if-not-present";
    }

    get remoteVariables (): string[] { return this.getStringArray("remoteVariables"); }

    get variable (): {[key: string]: string} {
        const variables: {[key: string]: string} = {};
        for (const pair of this.getStringArray("variable")) {
            const eqIndex = pair.indexOf("=");
            if (eqIndex < 1) continue;
            const key = pair.substring(0, eqIndex);
            if (/^\w+$/.test(key)) {
                variables[key] = pair.substring(eqIndex + 1);
            }
        }
        return variables;
    }

    get input (): {_global: {[key: string]: any}; _components: {[key: string]: {[key: string]: any}}} {
        const val = this.map.get("input");
        const _global: {[key: string]: any} = {};
        const _components: {[key: string]: {[key: string]: any}} = {};
        const pairs = typeof val == "string" ? val.split(" ") : val;
        const dangerousKeys = new Set(["__proto__", "constructor", "prototype"]);
        (pairs ?? []).forEach((inputPair: string) => {
            // Support component-specific syntax: component:key=value or key=value
            // Component names may contain word chars, hyphens, and slashes (e.g. templates/deploy)
            const exec = /(?:(?<component>[\w\-/]+):)?(?<key>[\w-]+)(=)(?<value>(.|\n|\r)*)/.exec(inputPair);
            if (exec?.groups?.key) {
                const value = exec?.groups?.value;
                const key = exec.groups.key;
                const component = exec.groups.component;

                // Guard against prototype pollution
                if (dangerousKeys.has(key) || dangerousKeys.has(component ?? "")) return;

                // Try to parse as JSON for arrays/objects/booleans/numbers
                let parsedValue;
                try {
                    parsedValue = JSON.parse(value);
                } catch {
                    parsedValue = value;
                }

                if (component) {
                    if (!_components[component]) _components[component] = {};
                    _components[component][key] = parsedValue;
                } else {
                    _global[key] = parsedValue;
                }
            }
        });
        return {_global, _components};
    }

    get unsetVariables (): string[] {
        return this.map.get("unsetVariable") ?? [];
    }

    get manual (): string[] { return this.getStringArray("manual"); }

    get job (): string[] {
        return this.map.get("job") ?? [];
    }

    get autoCompleting (): boolean {
        return this.map.get("autoCompleting") ?? false;
    }

    get cleanup (): boolean {
        return this.map.get("cleanup") ?? true;
    }

    get quiet (): boolean {
        return this.map.get("quiet") ?? false;
    }

    get umask (): boolean {
        // TODO: default to false in 5.x.x
        return this.map.get("umask") ?? true;
    }

    get userns (): string | undefined {
        return this.map.get("userns");
    }

    get privileged (): boolean {
        return this.map.get("privileged") ?? false;
    }

    get device (): string[] { return this.getStringArray("device"); }

    get ulimit (): string | null {
        const ulimit = this.map.get("ulimit");
        if (!ulimit) return null;
        return ulimit;
    }

    get shmSize (): string | undefined {
        return this.map.get("shmSize");
    }

    get needs (): boolean {
        return this.map.get("needs") ?? false;
    }

    get onlyNeeds (): boolean {
        return this.map.get("onlyNeeds") ?? false;
    }

    get stage (): string | null {
        return this.map.get("stage") ?? null;
    }

    get completion (): boolean {
        return this.map.get("completion") ?? false;
    }

    get list (): boolean {
        return this.map.get("list") ?? false;
    }

    get listAll (): boolean {
        return this.map.get("listAll") ?? false;
    }

    get listJson (): boolean {
        return this.map.get("listJson") ?? false;
    }

    get listCsv (): boolean {
        return this.map.get("listCsv") ?? false;
    }

    get listCsvAll (): boolean {
        return this.map.get("listCsvAll") ?? false;
    }

    get preview (): boolean {
        return this.map.get("preview") ?? false;
    }

    get validateDependencyChain (): boolean {
        return this.map.get("validateDependencyChain") ?? false;
    }

    get shellIsolation (): boolean {
        // TODO: default to true in 5.x.x
        return this.map.get("shellIsolation") ?? false;
    }

    get fetchIncludes (): boolean {
        return this.map.get("fetchIncludes") ?? false;
    }

    get mountCache (): boolean {
        return this.map.get("mountCache") ?? false;
    }

    get artifactsToSource (): boolean {
        // TODO: default to false in 5.x.x
        return this.map.get("artifactsToSource") ?? true;
    }

    get showTimestamps (): boolean {
        return this.map.get("timestamps") ?? false;
    }

    get maxJobNamePadding (): number | null {
        return this.map.get("maxJobNamePadding") ?? null;
    }

    get containerMacAddress (): string | null {
        return this.map.get("containerMacAddress") ?? null;
    }

    get containerEmulate (): string | null {
        return this.map.get("containerEmulate") ?? null;
    }

    get gpus (): string | null {
        return this.map.get("gpus") ?? null;
    }

    get concurrency (): number | null {
        const concurrency = this.map.get("concurrency");
        if (!concurrency) return null;
        return Number(concurrency);
    }

    get containerExecutable (): string {
        return this.map.get("containerExecutable") ?? "docker";
    }

    get jsonSchemaValidation (): boolean {
        return this.map.get("jsonSchemaValidation") ?? true;
    }

    get shellExecutorNoImage (): boolean {
        // TODO: default to false in 5.x.x
        return this.map.get("shellExecutorNoImage") ?? true;
    }

    get forceShellExecutor (): boolean {
        return this.map.get("forceShellExecutor") ?? false;
    }

    get defaultImage (): string {
        return this.map.get("defaultImage") ?? "docker.io/ruby:3.1";
    }

    get waitImage (): string {
        return this.map.get("waitImage") ?? "docker.io/sumina46/wait-for-it:latest";
    }

    get waitForServicesTimeout (): number {
        return this.map.get("waitForServicesTimeout") ?? 30;
    }

    get helperImage (): string {
        return this.map.get("helperImage") ?? "docker.io/firecow/gitlab-ci-local-util:latest";
    }

    get defaultImageExplicitlySet (): boolean {
        return this.map.get("defaultImage") ?? false;
    }

    get maximumIncludes (): number {
        return this.map.get("maximumIncludes") ?? 150; // https://docs.gitlab.com/ee/administration/settings/continuous_integration.html#maximum-includes
    }

    get childPipelineDepth (): number {
        return this.map.get("childPipelineDepth");
    }

    get registry (): boolean {
        return this.map.get("registry") ?? false;
    }
}