// @effect-diagnostics nodeBuiltinImport:off -- GNOME's per-user installation is a native adapter boundary.
// @effect-diagnostics globalTimers:off -- Bound calls into the user's desktop session.
import * as NodeFSP from "node:fs/promises";
import * as NodePath from "node:path";
import { Message, sessionBus, type MessageBus, type MessageLike } from "dbus-next";
import * as Schema from "effect/Schema";
import type { DesktopCaptureExtensionState } from "@t3tools/contracts";

import { GNOME_CAPTURE_FILES, GNOME_CAPTURE_UUID } from "./gnomeCaptureBundle.ts";
export { isGnomeCaptureSession } from "./linuxCaptureSession.ts";

const SHELL = "org.gnome.Shell";
const SHELL_PATH = "/org/gnome/Shell";
const EXTENSIONS = "org.gnome.Shell.Extensions";
const NumberValue = Schema.Struct({ value: Schema.Number });
const decodeInfo = Schema.decodeUnknownSync(
  Schema.Struct({
    state: Schema.optional(NumberValue),
    version: Schema.optional(NumberValue),
    error: Schema.optional(Schema.Struct({ value: Schema.String })),
  }),
);
const decodeProperties = Schema.decodeUnknownSync(
  Schema.Struct({
    ShellVersion: Schema.Struct({ value: Schema.String }),
    UserExtensionsEnabled: Schema.Struct({ value: Schema.Boolean }),
  }),
);
const Metadata = Schema.Struct({
  uuid: Schema.Literal(GNOME_CAPTURE_UUID),
  version: Schema.Number,
  "shell-version": Schema.Array(Schema.String),
});
const decodeMetadata = Schema.decodeUnknownSync(Schema.fromJsonString(Metadata));

type SetupPaths = { readonly bundle: string; readonly dataHome: string };

/** Copies only the shipped extension, offline. Replaced versions are kept for recovery. */
export async function installGnomeCaptureBundle({ bundle, dataHome }: SetupPaths) {
  const metadata = decodeMetadata(
    await NodeFSP.readFile(NodePath.join(bundle, "metadata.json"), "utf8"),
  );
  const parent = NodePath.join(dataHome, "gnome-shell", "extensions");
  const target = NodePath.join(parent, GNOME_CAPTURE_UUID);
  await NodeFSP.mkdir(parent, { recursive: true });
  const existing = await NodeFSP.lstat(target).catch((error: NodeJS.ErrnoException) => {
    if (error.code !== "ENOENT") throw error;
    return undefined;
  });
  if (existing && (!existing.isDirectory() || existing.isSymbolicLink()))
    throw new Error(
      "The extension installation is not a regular directory. Manage it in GNOME Extensions instead.",
    );
  if (existing) {
    const installed = decodeMetadata(
      await NodeFSP.readFile(NodePath.join(target, "metadata.json"), "utf8"),
    );
    if (installed.version > metadata.version)
      throw new Error("A newer extension is installed. Update T3 Code instead of replacing it.");
  }
  const staged = await NodeFSP.mkdtemp(NodePath.join(parent, ".t3-capture-install-"));
  let backup: string | undefined;
  try {
    for (const name of GNOME_CAPTURE_FILES) {
      await NodeFSP.copyFile(NodePath.join(bundle, name), NodePath.join(staged, name));
      await NodeFSP.chmod(NodePath.join(staged, name), 0o644);
    }
    await NodeFSP.chmod(staged, 0o755);
    if (existing) {
      const backupParent = NodePath.join(dataHome, "t3code", "extension-backups");
      await NodeFSP.mkdir(backupParent, { recursive: true });
      backup = NodePath.join(
        await NodeFSP.mkdtemp(NodePath.join(backupParent, "capture-")),
        GNOME_CAPTURE_UUID,
      );
      await NodeFSP.rename(target, backup);
    }
    try {
      await NodeFSP.rename(staged, target);
    } catch (error) {
      if (backup) await NodeFSP.rename(backup, target);
      throw error;
    }
  } finally {
    await NodeFSP.rm(staged, { recursive: true, force: true });
  }
}

/** A short-lived, read-only probe unless the user explicitly invokes an action. */
export class GnomeCaptureSetup {
  private readonly disconnected: Promise<never>;
  private readonly paths: SetupPaths;
  private readonly bus: MessageBus;
  private failure: Error | undefined;
  constructor(paths: SetupPaths, bus: MessageBus = sessionBus()) {
    this.paths = paths;
    this.bus = bus;
    this.disconnected = new Promise((_, reject) =>
      bus.on("error", (error: Error) => {
        this.failure = error;
        reject(error);
      }),
    );
    void this.disconnected.catch(() => undefined);
  }

  close() {
    this.bus.disconnect();
  }

  private async call(message: Omit<MessageLike, "destination" | "path">) {
    if (this.failure) throw this.failure;
    let timer: ReturnType<typeof setTimeout> | undefined;
    try {
      const reply = await Promise.race([
        this.bus.call(new Message({ destination: SHELL, path: SHELL_PATH, ...message })),
        this.disconnected,
        new Promise<never>((_, reject) => {
          timer = setTimeout(
            () =>
              reject(
                new Error(
                  "GNOME did not respond. Sign in to a GNOME Wayland session and try again.",
                ),
              ),
            5_000,
          );
        }),
      ]);
      if (!reply) throw new Error("GNOME returned no setup information.");
      return reply.body[0] as unknown;
    } finally {
      clearTimeout(timer);
    }
  }

  async state(): Promise<DesktopCaptureExtensionState> {
    try {
      const [properties, info, bundled, installed] = await Promise.all([
        this.call({
          interface: "org.freedesktop.DBus.Properties",
          member: "GetAll",
          signature: "s",
          body: [EXTENSIONS],
        }).then(decodeProperties),
        this.call({
          interface: EXTENSIONS,
          member: "GetExtensionInfo",
          signature: "s",
          body: [GNOME_CAPTURE_UUID],
        }).then(decodeInfo),
        NodeFSP.readFile(NodePath.join(this.paths.bundle, "metadata.json"), "utf8").then(
          decodeMetadata,
        ),
        NodeFSP.readFile(
          NodePath.join(
            this.paths.dataHome,
            "gnome-shell",
            "extensions",
            GNOME_CAPTURE_UUID,
            "metadata.json",
          ),
          "utf8",
        )
          .then(decodeMetadata)
          .catch((error: NodeJS.ErrnoException) => {
            if (error.code !== "ENOENT") throw error;
            return undefined;
          }),
      ]);
      const major = properties.ShellVersion.value.split(".")[0]!;
      if (!bundled["shell-version"].includes(major))
        return {
          status: "unsupported",
          message: `The bundled extension supports GNOME ${bundled["shell-version"].join(", ")}. This session runs GNOME ${major}.`,
        };
      if (!info.state && !installed)
        return {
          status: "not-installed",
          message:
            "Install the bundled extension to capture the active window without a picker. No download or administrator password is needed.",
        };
      if (installed && (!info.state || (info.version && installed.version > info.version.value)))
        return {
          status: "restart-required",
          message:
            "Installed. Save your work, sign out of GNOME and sign back in, then return here to enable the extension. Restarting T3 Code alone is not enough.",
        };
      if ((installed?.version ?? info.version?.value ?? 0) < bundled.version)
        return {
          status: "update-required",
          message:
            "A newer extension is bundled with this app. Install it, then sign out and back in to load the update.",
        };
      if (!properties.UserExtensionsEnabled.value)
        return {
          status: "extensions-disabled",
          message:
            "GNOME has disabled user extensions. Turn on Extensions in the GNOME Extensions app, then check again. T3 Code will not enable your other extensions for you.",
        };
      if (info.state?.value === 1)
        return {
          status: "enabled",
          message: "The T3 Code extension is running. Active-window snapshots are available.",
        };
      if (info.state?.value === 3 || info.state?.value === 4)
        return {
          status: "error",
          message:
            info.error?.value ||
            "GNOME could not load the extension. Check GNOME Extensions for details, or sign out and back in.",
        };
      return {
        status: "disabled",
        message:
          "Enable the T3 Code extension to allow active-window snapshots. You can disable it here at any time.",
      };
    } catch (error) {
      return {
        status: "error",
        message: error instanceof Error ? error.message : "Could not check GNOME extension setup.",
      };
    }
  }

  async perform(action: "install-extension" | "enable-extension" | "disable-extension") {
    const state = await this.state();
    if (action === "install-extension") {
      if (state.status !== "not-installed" && state.status !== "update-required")
        throw new Error(state.message);
      await installGnomeCaptureBundle(this.paths);
      // GNOME discovers a newly installed local extension at the next login.
      return;
    }
    if (action === "enable-extension" && state.status !== "disabled")
      throw new Error(state.message);
    const result = await this.call({
      interface: EXTENSIONS,
      member: action === "enable-extension" ? "EnableExtension" : "DisableExtension",
      signature: "s",
      body: [GNOME_CAPTURE_UUID],
    });
    if (result !== true)
      throw new Error("GNOME has not loaded the extension. Sign out and back in, then try again.");
  }
}