import * as vscode from "vscode";

import type { Ctx, Cmd } from "./ctx";
import * as ra from "./lsp_ext";
import { cargoPath } from "./toolchain";
import { log, spawnAsync } from "./util";

type NewProjectKind = "bin" | "lib";
type NewProjectOpenAction = "open" | "openNewWindow" | "addToWorkspace";

type NewProjectTemplate = {
    detail: string;
    id: NewProjectKind;
    label: string;
};

type NewProjectCargo = {
    cargo: string;
    cargoEnv: NodeJS.ProcessEnv;
};

const NEW_PROJECT_TEMPLATES: readonly NewProjectTemplate[] = [
    {
        id: "bin",
        label: "Binary Application",
        detail: "Create a Cargo binary package (`cargo new --bin`)",
    },
    {
        id: "lib",
        label: "Library",
        detail: "Create a Cargo library package (`cargo new --lib`)",
    },
] as const;

export function newProject(ctx: Ctx): Cmd {
    return async () => {
        const cargo = await resolveNewProjectCargo(ctx);

        const selectedKind = await promptForNewProjectTemplate();
        if (!selectedKind) {
            return;
        }

        const parentFolder = await promptForNewProjectParentFolder();
        if (!parentFolder) {
            return;
        }

        const projectName = await promptForNewProjectName(parentFolder);
        if (!projectName) {
            return;
        }

        if (!(await createNewProject(cargo, parentFolder, selectedKind, projectName))) {
            return;
        }

        const projectUri = vscode.Uri.joinPath(parentFolder, projectName);
        const defaultAction = determineNewProjectOpenAction(
            ctx.config.projectCreationOpenAfterCreate,
            Boolean(vscode.workspace.workspaceFolders?.length),
        );
        const action =
            defaultAction === "ask"
                ? await promptForNewProjectOpenAction(
                      projectName,
                      Boolean(vscode.workspace.workspaceFolders?.length),
                  )
                : defaultAction;

        if (action) {
            await executeNewProjectOpenAction(ctx, action, projectUri);
        }
    };
}

async function resolveNewProjectCargo(ctx: Ctx): Promise<NewProjectCargo> {
    // Use the same effective environment rust-analyzer uses elsewhere so project creation sees
    // toolchain wrappers, PATH overrides, and CARGO_HOME changes from configuration.
    const cargoEnv = { ...process.env, ...ctx.config.serverExtraEnv };
    return { cargo: await cargoPath(cargoEnv), cargoEnv };
}

async function promptForNewProjectTemplate(): Promise<NewProjectKind | undefined> {
    const selected = await vscode.window.showQuickPick(NEW_PROJECT_TEMPLATES, {
        placeHolder: "Select a Rust project kind",
    });
    return selected?.id;
}

async function promptForNewProjectParentFolder(): Promise<vscode.Uri | undefined> {
    const selectedFolder = await vscode.window.showOpenDialog({
        title: "Select the parent folder for the new Rust project",
        openLabel: "Select parent folder",
        canSelectFiles: false,
        canSelectFolders: true,
        canSelectMany: false,
    });
    if (!selectedFolder?.length) {
        return undefined;
    }
    return selectedFolder[0];
}

const CARGO_MANIFEST_NAME_PATTERN = /^[\p{Alphabetic}\p{Number}_-]+$/u;

// Keep local validation focused on stable checks that can be reported in the input box, then let
// `cargo new` remain the source of truth for package-name-specific identifier and keyword rules.
export function validateNewProjectName(
    value: string,
    existingNames: readonly string[],
): string | undefined {
    const trimmedValue = value.trim();
    if (trimmedValue.length === 0) {
        return "Project name cannot be empty.";
    }
    if (trimmedValue.includes("/") || trimmedValue.includes("\\")) {
        return "Project name cannot contain '/' or '\\' characters.";
    }
    if (trimmedValue === "." || trimmedValue === "..") {
        return "Project name cannot be '.' or '..'.";
    }
    if (!CARGO_MANIFEST_NAME_PATTERN.test(trimmedValue)) {
        return "Project name can contain only alphanumeric characters, '-' or '_'.";
    }
    if (existingNames.includes(trimmedValue)) {
        return "A file or folder with this name already exists.";
    }
    return undefined;
}

async function promptForNewProjectName(parentFolder: vscode.Uri): Promise<string | undefined> {
    let existingNames: string[] = [];
    try {
        const entries = await vscode.workspace.fs.readDirectory(parentFolder);
        existingNames = entries.map(([name]) => name);
    } catch (error) {
        log.error("Failed to read project parent folder", error);
        void vscode.window.showErrorMessage("Failed to read the selected parent folder.");
        return undefined;
    }

    const projectName = await vscode.window.showInputBox({
        prompt: `Enter the new project name to create inside ${parentFolder.fsPath}`,
        validateInput: async (value) => validateNewProjectName(value, existingNames),
    });
    return projectName?.trim();
}

export function cargoNewArgs(kind: NewProjectKind, name: string): string[] {
    return ["new", kind === "bin" ? "--bin" : "--lib", name];
}

async function createNewProject(
    cargo: NewProjectCargo,
    parentFolder: vscode.Uri,
    kind: NewProjectKind,
    projectName: string,
): Promise<boolean> {
    const args = cargoNewArgs(kind, projectName);
    const createResult = await vscode.window.withProgress(
        {
            location: vscode.ProgressLocation.Notification,
            title: `Creating Rust project ${projectName}`,
        },
        async () =>
            spawnAsync(cargo.cargo, args, {
                cwd: parentFolder.fsPath,
                env: cargo.cargoEnv,
            }),
    );

    if (createResult.error || createResult.status !== 0) {
        const details = formatProcessDetails(createResult);
        await showNewProjectError("Failed to create Rust project.", details || undefined, {
            cargo: cargo.cargo,
            args,
            cwd: parentFolder.fsPath,
            error: createResult.error?.message,
            status: createResult.status,
            stderr: createResult.stderr || undefined,
            stdout: createResult.stdout || undefined,
        });
        return false;
    }

    return true;
}

function formatProcessDetails(result: { error?: Error; stderr: string; stdout: string }): string {
    return [result.stderr, result.stdout, result.error?.message]
        .filter((value): value is string => Boolean(value && value.trim().length > 0))
        .join("\n")
        .trim();
}

async function showNewProjectError(
    message: string,
    details: string | undefined,
    logContext: {
        cargo: string;
        args: string[];
        cwd?: string;
        error?: string;
        status: number | null;
        stderr?: string;
        stdout?: string;
    },
): Promise<void> {
    // Keep command-failure logging focused on the invocation and process output. Environment
    // variables may contain secrets such as API keys, tokens, and credentials, so failure logs
    // must not dump the merged env here.
    const commandLine = [logContext.cargo, ...logContext.args].join(" ");
    log.error(message);
    log.error(`command: ${commandLine}`);
    if (logContext.cwd) {
        log.error(`cwd: ${logContext.cwd}`);
    }
    log.error(`exit status: ${String(logContext.status)}`);
    if (logContext.error) {
        log.error(`error: ${logContext.error}`);
    }
    if (logContext.stderr) {
        log.error(`stderr:\n${logContext.stderr}`);
    }
    if (logContext.stdout) {
        log.error(`stdout:\n${logContext.stdout}`);
    }
    const selection = await vscode.window.showErrorMessage(
        details ? `${message}\n${details}` : message,
        "Open Extension Logs",
    );
    if (selection === "Open Extension Logs") {
        log.show();
    }
}

export function determineNewProjectOpenAction(
    configuredAction: string | undefined,
    hasWorkspaceFolders: boolean,
): "ask" | NewProjectOpenAction {
    switch (configuredAction) {
        case "open":
        case "openNewWindow":
            return configuredAction;
        case "addToWorkspace":
            // Adding to a workspace only makes sense when one is already open. Falling back to
            // "open" keeps the setting usable in empty windows without adding another prompt path.
            return hasWorkspaceFolders ? configuredAction : "open";
        default:
            return "ask";
    }
}

async function promptForNewProjectOpenAction(
    projectName: string,
    hasWorkspaceFolders: boolean,
): Promise<NewProjectOpenAction | undefined> {
    let message = `Would you like to open ${projectName}?`;
    const open = "Open";
    const openNewWindow = "Open in New Window";
    const choices = [open, openNewWindow];

    const addToWorkspace = "Add to VS Code Workspace";
    if (hasWorkspaceFolders) {
        message = `Would you like to open ${projectName}, or add it to the current VS Code workspace?`;
        choices.push(addToWorkspace);
    }

    const result = await vscode.window.showInformationMessage(
        message,
        { modal: true, detail: "The default action can be configured in settings." },
        ...choices,
    );

    const actionMap: Record<string, NewProjectOpenAction> = {
        [open]: "open",
        [openNewWindow]: "openNewWindow",
        [addToWorkspace]: "addToWorkspace",
    };
    return result ? actionMap[result] : undefined;
}

async function executeNewProjectOpenAction(
    ctx: Ctx,
    action: NewProjectOpenAction,
    projectUri: vscode.Uri,
): Promise<void> {
    if (action === "open") {
        await vscode.commands.executeCommand("vscode.openFolder", projectUri, {
            forceReuseWindow: true,
        });
        return;
    }

    if (action === "openNewWindow") {
        await vscode.commands.executeCommand("vscode.openFolder", projectUri, {
            forceNewWindow: true,
        });
        return;
    }

    const index = vscode.workspace.workspaceFolders?.length ?? 0;
    vscode.workspace.updateWorkspaceFolders(index, 0, { uri: projectUri });
    // Reuse the existing workspace window when requested, but nudge rust-analyzer afterwards so
    // the newly added Cargo project is discovered immediately instead of waiting for a later
    // background refresh.
    if (ctx.client?.isRunning()) {
        await ctx.client.sendRequest(ra.reloadWorkspace);
    }
}