// The extension's way to Spectra (spec §3): `spectra bridge` signs every

// request as the owner, so no key is ever handled here.

import * as cp from "node:child_process";

import * as vscode from "vscode";

import { binary } from "./cli";

import { SseParser } from "./pure";

export class SpectraError extends Error {

  constructor(public status: number, message: string) {

    super(message);

  }

}

export class Bridge implements vscode.Disposable {

  private child: cp.ChildProcess | undefined;

  private ready: Promise<{ url: string; token: string }> | undefined;

  private disposed = false;

  private streams = new Set<AbortController>();

  private readonly log: vscode.OutputChannel;

  constructor(log: vscode.OutputChannel) {

    this.log = log;

  }

  /** Start the bridge if it is not running. */

  private start(): Promise<{ url: string; token: string }> {

    if (this.ready) return this.ready;

    this.ready = new Promise((resolve, reject) => {

      const bin = binary();

      if (!bin) return reject(new Error("spectra is not installed"));

      const child = cp.spawn(bin, ["bridge"], { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env, NO_COLOR: "1" } });

      this.child = child;

      let out = "";

      let err = "";

      child.stdout!.on("data", (d: Buffer) => {

        out += d.toString();

        const nl = out.indexOf("\n");

        if (nl >= 0) {

          try {

            resolve(JSON.parse(out.slice(0, nl)));

          } catch {

            reject(new Error("the bridge said something unexpected: " + out.slice(0, nl)));

          }

        }

      });

      child.stderr!.on("data", (d: Buffer) => {

        err += d.toString();

        this.log.append(d.toString());

      });

      child.on("exit", (code) => {

        this.log.appendLine(`spectra bridge exited (${code})`);

        reject(new Error(err.trim().split("\n").pop()?.replace(/^error:\s*/, "") || `spectra bridge exited (${code})`));

        this.child = undefined;

        this.ready = undefined;

      });

    });

    return this.ready;

  }

  /** Stop, so the next request starts afresh (after setup changes what it reaches). */

  restart(): void {

    for (const s of this.streams) s.abort();

    this.streams.clear();

    this.child?.stdin?.end();

    this.child = undefined;

    this.ready = undefined;

  }

  async request<T>(method: string, path: string, body?: unknown): Promise<T> {

    const { url, token } = await this.start();

    const r = await fetch(url + path, {

      method,

      headers: { authorization: `Bearer ${token}`, ...(body !== undefined ? { "content-type": "application/json" } : {}) },

      body: body !== undefined ? JSON.stringify(body) : undefined,

    });

    const text = await r.text();

    if (!r.ok) {

      let why = text;

      try {

        const p = JSON.parse(text);

        why = p.detail || p.title || text;

      } catch {

        /* not JSON */

      }

      throw new SpectraError(r.status, why);

    }

    return (text ? JSON.parse(text) : undefined) as T;

  }

  /** Follow an SSE path; each event's data goes to `onData`. Reconnects until disposed. */

  follow(path: string, onData: (data: string) => void, onUp: () => void): vscode.Disposable {

    const ctrl = new AbortController();

    this.streams.add(ctrl);

    const loop = async () => {

      let wait = 1000;

      while (!ctrl.signal.aborted && !this.disposed) {

        try {

          const { url, token } = await this.start();

          const r = await fetch(url + path, { headers: { authorization: `Bearer ${token}` }, signal: ctrl.signal });

          if (!r.ok || !r.body) throw new Error(`the stream answered ${r.status}`);

          onUp();

          wait = 1000;

          const parser = new SseParser();

          const dec = new TextDecoder();

          for await (const chunk of r.body as unknown as AsyncIterable<Uint8Array>) {

            for (const d of parser.push(dec.decode(chunk, { stream: true }))) onData(d);

          }

        } catch (e) {

          if (ctrl.signal.aborted) return;

          this.log.appendLine(`stream: ${(e as Error).message}; again in ${wait / 1000} s`);

        }

        await new Promise((r) => setTimeout(r, wait));

        wait = Math.min(wait * 2, 30000);

      }

    };

    void loop();

    return new vscode.Disposable(() => {

      ctrl.abort();

      this.streams.delete(ctrl);

    });

  }

  dispose(): void {

    this.disposed = true;

    this.restart();

  }

}