import { rmSync } from "node:fs";
import { resolve } from "node:path";
import { FileDataStore } from "../db/fileStore";
import { loadEnv } from "../env";
import { issueToken, listStreamTokens, resolveToken, revokeToken } from "../hub/auth";

async function main(): Promise<void> {
    const env = loadEnv();
    const smokeDataFile = resolve(
        process.cwd(),
        "data",
        `phase3-smoke-${process.pid}-${Date.now()}.json`
    );
    const store = new FileDataStore(smokeDataFile);

    try {
        await store.init();

        const stream = await store.createStream({ name: `phase3-smoke-${Date.now()}` });
        const issued = await issueToken(store, stream.id, "admin", env.TOKEN_PEPPER);

        const resolved = await resolveToken(store, issued.plainToken, env.TOKEN_PEPPER);
        if (!resolved || resolved.streamId !== stream.id || resolved.role !== "admin") {
            throw new Error("Expected valid token to resolve to stream + role context.");
        }

        const invalid = await resolveToken(store, "cdt_invalid_token", env.TOKEN_PEPPER);
        if (invalid !== null) {
            throw new Error("Expected invalid token to be rejected.");
        }

        const revoked = await revokeToken(store, issued.token.id);
        if (!revoked) {
            throw new Error("Expected revokeToken to return true for active token.");
        }

        const afterRevoke = await resolveToken(store, issued.plainToken, env.TOKEN_PEPPER);
        if (afterRevoke !== null) {
            throw new Error("Expected revoked token to be rejected.");
        }

        const streamTokens = await listStreamTokens(store, stream.id);

        console.log(
            JSON.stringify(
                {
                    ok: true,
                    streamId: stream.id,
                    issuedTokenId: issued.token.id,
                    listedTokenCount: streamTokens.length
                },
                null,
                2
            )
        );
    } finally {
        rmSync(smokeDataFile, { force: true });
    }
}

main().catch((error: unknown) => {
    const message = error instanceof Error ? error.message : String(error);
    console.error(message);
    process.exit(1);
});