// file: crates/ksp-app-config-desk/frontend/ts/logging_test.ts
// version: 1

//! Controlled Logging test panel for proving backend routing and the frontend bridge.

import type { LoggingTestRequestDto } from "./bindings/ksp_app_config_desk/logging_test/LoggingTestRequestDto";
import type { LoggingTestResultDto } from "./bindings/ksp_app_config_desk/logging_test/LoggingTestResultDto";
import { emitFrontendLog, frontendTrace, type FrontendLogLevel } from "./frontend_log";
import { invokeKsp } from "./invoke";

const FRONTEND_BRIDGE_TARGET = "ksp-app-config-desk.frontend.main";
const FRONTEND_BRIDGE_DOMAIN = "frontend";

function inputValue(selector: string): string {
    return document.querySelector<HTMLInputElement>(selector)?.value ?? "";
}

function selectedValue(selector: string): string {
    return document.querySelector<HTMLSelectElement>(selector)?.value ?? "";
}

function setStatus(message: string, tone: "secondary" | "success" | "warning" | "danger" = "secondary"): void {
    const status = document.querySelector<HTMLElement>("#loggingTestStatus");
    if (!status) {
        return;
    }
    status.className = `alert alert-${tone} mb-0`;
    status.textContent = message;
}

function updateDomainControls(): void {
    const mode = selectedValue("#loggingTestDomainMode");
    const known = document.querySelector<HTMLSelectElement>("#loggingTestKnownDomain");
    const custom = document.querySelector<HTMLInputElement>("#loggingTestCustomDomain");
    if (known) {
        known.disabled = mode !== "known";
    }
    if (custom) {
        custom.disabled = mode !== "custom";
    }
}

function effectiveDomain(): string {
    const mode = selectedValue("#loggingTestDomainMode");
    if (mode === "known") {
        return selectedValue("#loggingTestKnownDomain");
    }
    if (mode === "custom") {
        return inputValue("#loggingTestCustomDomain");
    }
    return "";
}

function buildRequest(): LoggingTestRequestDto {
    return {
        level: selectedValue("#loggingTestLevel"),
        targetId: selectedValue("#loggingTestTarget"),
        domainMode: selectedValue("#loggingTestDomainMode"),
        domain: effectiveDomain(),
        message: inputValue("#loggingTestMessage"),
    };
}

async function emitBackendTest(): Promise<void> {
    const request = buildRequest();
    setStatus("Émission backend en cours...");
    try {
        const result = await invokeKsp<LoggingTestResultDto>("main", "emit_logging_test", { request });
        const domain = result.domain ?? "<absent>";
        const summary = `${result.emittedEventCount} événement(s) backend émis · niveau=${result.requestedLevel} · target=${result.target}`
            + ` · domain=${domain} · génération=${result.loggingGeneration}.`;
        setStatus(summary, "success");
    } catch {
        setStatus("Émission backend refusée. Vérifie le message, le target et le domain sélectionnés.", "danger");
    }
}

async function emitFrontendLevel(level: FrontendLogLevel, message: string): Promise<void> {
    await emitFrontendLog(level, "main", message);
}

async function emitFrontendBridgeTest(): Promise<void> {
    const message = inputValue("#loggingTestMessage").trim();
    if (message.length === 0 || message.length > 500) {
        setStatus("Le message de test frontend doit contenir entre 1 et 500 caractères.", "danger");
        return;
    }
    const level = selectedValue("#loggingTestLevel");
    setStatus("Émission via bridge frontend en cours...");
    try {
        if (level === "all") {
            for (const item of ["trace", "debug", "info", "warn", "error"] as const) {
                await emitFrontendLevel(item, `[logging-test frontend/${item}] ${message}`);
            }
            setStatus(
                `5 événements acceptés par le bridge frontend · target=${FRONTEND_BRIDGE_TARGET} · domain=${FRONTEND_BRIDGE_DOMAIN}.`,
                "success",
            );
            return;
        }
        if (level === "trace" || level === "debug" || level === "info" || level === "warn" || level === "error") {
            await emitFrontendLevel(level, `[logging-test frontend/${level}] ${message}`);
            setStatus(
                `1 événement accepté par le bridge frontend · target=${FRONTEND_BRIDGE_TARGET} · domain=${FRONTEND_BRIDGE_DOMAIN}.`,
                "success",
            );
            return;
        }
        setStatus("Le niveau de test frontend sélectionné n'est pas supporté.", "danger");
    } catch {
        setStatus("Le bridge frontend n'a pas accepté l'événement de test.", "danger");
    }
}

/// Initializes the controlled Logging test surface.
export function initializeLoggingTestPanel(): void {
    document.querySelector<HTMLSelectElement>("#loggingTestDomainMode")?.addEventListener("change", updateDomainControls);
    document.querySelector<HTMLButtonElement>("#emitLoggingTestBackend")?.addEventListener("click", () => void emitBackendTest());
    document.querySelector<HTMLButtonElement>("#emitLoggingTestFrontend")?.addEventListener("click", () => void emitFrontendBridgeTest());
    updateDomainControls();
    frontendTrace("main", "Logging test panel handlers installed");
}