import { BrowserWindow } from "electron";
import { RuntimeOptionState, WindowGeometry } from "../../types";
import { updateOverlayWindowBounds } from "./overlay-window";

type OverlayLayer = "visible" | "invisible";

export interface OverlayManager {
  getMainWindow: () => BrowserWindow | null;
  setMainWindow: (window: BrowserWindow | null) => void;
  getInvisibleWindow: () => BrowserWindow | null;
  setInvisibleWindow: (window: BrowserWindow | null) => void;
  getOverlayWindow: (layer: OverlayLayer) => BrowserWindow | null;
  setOverlayWindowBounds: (
    layer: OverlayLayer,
    geometry: WindowGeometry,
  ) => void;
  getVisibleOverlayVisible: () => boolean;
  setVisibleOverlayVisible: (visible: boolean) => void;
  getInvisibleOverlayVisible: () => boolean;
  setInvisibleOverlayVisible: (visible: boolean) => void;
  getOverlayWindows: () => BrowserWindow[];
  broadcastToOverlayWindows: (channel: string, ...args: unknown[]) => void;
}

export function createOverlayManager(): OverlayManager {
  let mainWindow: BrowserWindow | null = null;
  let invisibleWindow: BrowserWindow | null = null;
  let visibleOverlayVisible = false;
  let invisibleOverlayVisible = false;

  return {
    getMainWindow: () => mainWindow,
    setMainWindow: (window) => {
      mainWindow = window;
    },
    getInvisibleWindow: () => invisibleWindow,
    setInvisibleWindow: (window) => {
      invisibleWindow = window;
    },
    getOverlayWindow: (layer) =>
      layer === "visible" ? mainWindow : invisibleWindow,
    setOverlayWindowBounds: (layer, geometry) => {
      updateOverlayWindowBounds(
        geometry,
        layer === "visible" ? mainWindow : invisibleWindow,
      );
    },
    getVisibleOverlayVisible: () => visibleOverlayVisible,
    setVisibleOverlayVisible: (visible) => {
      visibleOverlayVisible = visible;
    },
    getInvisibleOverlayVisible: () => invisibleOverlayVisible,
    setInvisibleOverlayVisible: (visible) => {
      invisibleOverlayVisible = visible;
    },
    getOverlayWindows: () => {
      const windows: BrowserWindow[] = [];
      if (mainWindow && !mainWindow.isDestroyed()) {
        windows.push(mainWindow);
      }
      if (invisibleWindow && !invisibleWindow.isDestroyed()) {
        windows.push(invisibleWindow);
      }
      return windows;
    },
    broadcastToOverlayWindows: (channel, ...args) => {
      const windows: BrowserWindow[] = [];
      if (mainWindow && !mainWindow.isDestroyed()) {
        windows.push(mainWindow);
      }
      if (invisibleWindow && !invisibleWindow.isDestroyed()) {
        windows.push(invisibleWindow);
      }
      for (const window of windows) {
        window.webContents.send(channel, ...args);
      }
    },
  };
}

export function broadcastRuntimeOptionsChangedRuntime(
  getRuntimeOptionsState: () => RuntimeOptionState[],
  broadcastToOverlayWindows: (channel: string, ...args: unknown[]) => void,
): void {
  broadcastToOverlayWindows(
    "runtime-options:changed",
    getRuntimeOptionsState(),
  );
}

export function setOverlayDebugVisualizationEnabledRuntime(
  currentEnabled: boolean,
  nextEnabled: boolean,
  setState: (enabled: boolean) => void,
  broadcastToOverlayWindows: (channel: string, ...args: unknown[]) => void,
): boolean {
  if (currentEnabled === nextEnabled) return false;
  setState(nextEnabled);
  broadcastToOverlayWindows("overlay-debug-visualization:set", nextEnabled);
  return true;
}