export interface WindowsForegroundApi {
  readonly getCurrentThreadId: () => number;
  readonly getForegroundWindow: () => bigint;
  readonly getWindowClassName: (windowHandle: bigint) => string;
  readonly getWindowThreadId: (windowHandle: bigint) => number;
  readonly getWindowThreadAndProcessId: (windowHandle: bigint) => {
    readonly threadId: number;
    readonly processId: number;
  };
  readonly getWindowText: (windowHandle: bigint) => string;
  readonly getWindowRect: (
    windowHandle: bigint,
  ) =>
    | { readonly x: number; readonly y: number; readonly width: number; readonly height: number }
    | undefined;
  readonly getProcessImagePath: (processId: number) => string;
  /** High bit of `GetAsyncKeyState`: whether the virtual key is currently down. */
  readonly isKeyDown: (virtualKey: number) => boolean;
  readonly attachThreadInput: (
    sourceThreadId: number,
    targetThreadId: number,
    attach: boolean,
  ) => boolean;
  readonly setForegroundWindow: (windowHandle: bigint) => boolean;
}

const WINDOWS_SHELL_HOSTED_WINDOW_CLASSES = new Set(["ApplicationFrameWindow"]);

function nativeWindowHandle(buffer: Buffer): bigint {
  if (buffer.length === 8) return buffer.readBigUInt64LE();
  if (buffer.length === 4) return BigInt(buffer.readUInt32LE());
  throw new Error(`Unsupported Windows window handle size: ${String(buffer.length)} bytes.`);
}

export function activateWindowsForegroundWithApi(
  handleBuffer: Buffer,
  api: WindowsForegroundApi,
): boolean {
  const targetWindow = nativeWindowHandle(handleBuffer);
  const foregroundWindow = api.getForegroundWindow();
  if (targetWindow === foregroundWindow) return true;

  const currentThreadId = api.getCurrentThreadId();
  const foregroundThreadId = foregroundWindow === 0n ? 0 : api.getWindowThreadId(foregroundWindow);
  const shouldAttach =
    currentThreadId !== 0 && foregroundThreadId !== 0 && currentThreadId !== foregroundThreadId;
  const attached = shouldAttach && api.attachThreadInput(currentThreadId, foregroundThreadId, true);

  try {
    return api.setForegroundWindow(targetWindow);
  } finally {
    if (attached) {
      api.attachThreadInput(currentThreadId, foregroundThreadId, false);
    }
  }
}

export function isWindowsShellHostedForegroundWithApi(api: WindowsForegroundApi): boolean {
  const foregroundWindow = api.getForegroundWindow();
  return (
    foregroundWindow !== 0n &&
    WINDOWS_SHELL_HOSTED_WINDOW_CLASSES.has(api.getWindowClassName(foregroundWindow))
  );
}

let windowsForegroundApiPromise: Promise<WindowsForegroundApi> | undefined;

const PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;

export function loadWindowsForegroundApi(): Promise<WindowsForegroundApi> {
  windowsForegroundApiPromise ??= import("ffi-rs").then(({ DataType, load, open }) => {
    const kernel32 = "t3-kernel32";
    const user32 = "t3-user32";
    open({ library: kernel32, path: "kernel32.dll" });
    open({ library: user32, path: "user32.dll" });

    return {
      getCurrentThreadId: () =>
        load({
          library: kernel32,
          funcName: "GetCurrentThreadId",
          retType: DataType.U32,
          paramsType: [],
          paramsValue: [],
        }),
      getForegroundWindow: () =>
        load({
          library: user32,
          funcName: "GetForegroundWindow",
          retType: DataType.BigInt,
          paramsType: [],
          paramsValue: [],
        }) as bigint,
      getWindowClassName: (windowHandle) => {
        const buffer = Buffer.alloc(512);
        const length = load({
          library: user32,
          funcName: "GetClassNameW",
          retType: DataType.I32,
          paramsType: [DataType.BigInt, DataType.U8Array, DataType.I32],
          paramsValue: [windowHandle, buffer, buffer.byteLength / 2],
        });
        return length > 0 ? buffer.subarray(0, length * 2).toString("utf16le") : "";
      },
      getWindowThreadId: (windowHandle) =>
        load({
          library: user32,
          funcName: "GetWindowThreadProcessId",
          retType: DataType.U32,
          paramsType: [DataType.BigInt, DataType.BigInt],
          paramsValue: [windowHandle, 0n],
        }),
      getWindowThreadAndProcessId: (windowHandle) => {
        const out = Buffer.alloc(4);
        const threadId = load({
          library: user32,
          funcName: "GetWindowThreadProcessId",
          retType: DataType.U32,
          paramsType: [DataType.BigInt, DataType.U8Array],
          paramsValue: [windowHandle, out],
        });
        return { threadId, processId: out.readUInt32LE(0) };
      },
      getWindowText: (windowHandle) => {
        const buffer = Buffer.alloc(2 * 1024);
        const length = load({
          library: user32,
          funcName: "GetWindowTextW",
          retType: DataType.I32,
          paramsType: [DataType.BigInt, DataType.U8Array, DataType.I32],
          paramsValue: [windowHandle, buffer, buffer.byteLength / 2],
        });
        return length > 0 ? buffer.subarray(0, length * 2).toString("utf16le") : "";
      },
      getWindowRect: (windowHandle) => {
        const rect = Buffer.alloc(16);
        const ok = load({
          library: user32,
          funcName: "GetWindowRect",
          retType: DataType.Boolean,
          paramsType: [DataType.BigInt, DataType.U8Array],
          paramsValue: [windowHandle, rect],
        });
        if (!ok) return undefined;
        const left = rect.readInt32LE(0);
        const top = rect.readInt32LE(4);
        return {
          x: left,
          y: top,
          width: Math.max(0, rect.readInt32LE(8) - left),
          height: Math.max(0, rect.readInt32LE(12) - top),
        };
      },
      getProcessImagePath: (processId) => {
        const handle = load({
          library: kernel32,
          funcName: "OpenProcess",
          retType: DataType.BigInt,
          paramsType: [DataType.U32, DataType.Boolean, DataType.U32],
          paramsValue: [PROCESS_QUERY_LIMITED_INFORMATION, false, processId],
        }) as bigint;
        if (handle === 0n) return "";
        try {
          const buffer = Buffer.alloc(2 * 32_768);
          const size = Buffer.alloc(4);
          size.writeUInt32LE(buffer.byteLength / 2, 0);
          const ok = load({
            library: kernel32,
            funcName: "QueryFullProcessImageNameW",
            retType: DataType.Boolean,
            paramsType: [DataType.BigInt, DataType.U32, DataType.U8Array, DataType.U8Array],
            paramsValue: [handle, 0, buffer, size],
          });
          return ok ? buffer.subarray(0, size.readUInt32LE(0) * 2).toString("utf16le") : "";
        } finally {
          load({
            library: kernel32,
            funcName: "CloseHandle",
            retType: DataType.Boolean,
            paramsType: [DataType.BigInt],
            paramsValue: [handle],
          });
        }
      },
      isKeyDown: (virtualKey) =>
        (load({
          library: user32,
          funcName: "GetAsyncKeyState",
          retType: DataType.I16,
          paramsType: [DataType.I32],
          paramsValue: [virtualKey],
        }) &
          0x8000) !==
        0,
      attachThreadInput: (sourceThreadId, targetThreadId, attach) =>
        load({
          library: user32,
          funcName: "AttachThreadInput",
          retType: DataType.Boolean,
          paramsType: [DataType.U32, DataType.U32, DataType.Boolean],
          paramsValue: [sourceThreadId, targetThreadId, attach],
        }),
      setForegroundWindow: (windowHandle) =>
        load({
          library: user32,
          funcName: "SetForegroundWindow",
          retType: DataType.Boolean,
          paramsType: [DataType.BigInt],
          paramsValue: [windowHandle],
        }),
    } satisfies WindowsForegroundApi;
  });
  return windowsForegroundApiPromise;
}

export async function activateWindowsForeground(handleBuffer: Buffer): Promise<void> {
  const api = await loadWindowsForegroundApi();
  if (activateWindowsForegroundWithApi(handleBuffer, api)) return;
  throw new Error("Windows refused to activate the T3 Code window.");
}

export async function isWindowsShellHostedForeground(): Promise<boolean> {
  return isWindowsShellHostedForegroundWithApi(await loadWindowsForegroundApi());
}