import { LogFunctions } from "electron-log";
import { BrowserWindow, Rectangle } from "electron/main";

export const WINDOW_STATES = {
  FullScreen: "fullscreen",
  Maximized: "maximized",
  Minimized: "minimized"
} as const;
export type WindowStates = typeof WINDOW_STATES;
export type WindowState = WindowStates[keyof WindowStates];

export type WindowPosition = Rectangle | WindowState;

export class WindowPositionWatcher {
  private readonly logger: LogFunctions;
  private updateWindowPositionTimeout: null | NodeJS.Timeout;
  private readonly UPDATE_WINDOW_POSITION_TIMEOUT_DELAY_MS: number;

  public constructor(logger: LogFunctions, timeoutDelayMs = 500) {
    this.logger = logger;
    this.logger.debug(`Initialising new Window Position Watcher with timeout delay: ${timeoutDelayMs.toString()} ms.`);
    this.updateWindowPositionTimeout = null;
    this.UPDATE_WINDOW_POSITION_TIMEOUT_DELAY_MS = timeoutDelayMs;
  }

  public watchWindowPosition(window: BrowserWindow, onWindowPositionChange: (position: WindowPosition) => void): void {
    this.logger.debug("Starting watching window.");
    window.on("move", (): void => {
      this.onWindowBoundsChanged(window, onWindowPositionChange);
    });
    window.on("resize", (): void => {
      this.onWindowBoundsChanged(window, onWindowPositionChange);
    });
  }

  private onWindowBoundsChanged(window: BrowserWindow, onWindowPositionChange: (position: WindowPosition) => void): void {
    // Move and resize events fire very often while the window is moving
    // Debounce window position updates
    if (this.updateWindowPositionTimeout !== null) {
      clearTimeout(this.updateWindowPositionTimeout);
    }
    this.updateWindowPositionTimeout = setTimeout((): void => {
      const NEW_WINDOW_POSITION: WindowPosition = this.getNewWindowPosition(window);
      this.logger.silly(
        `New window position: ${typeof NEW_WINDOW_POSITION === "string" ? `"${NEW_WINDOW_POSITION}"` : JSON.stringify(NEW_WINDOW_POSITION, null, 2)}.`
      );
      onWindowPositionChange(NEW_WINDOW_POSITION);
      this.updateWindowPositionTimeout = null;
    }, this.UPDATE_WINDOW_POSITION_TIMEOUT_DELAY_MS);
  }

  private getNewWindowPosition(window: BrowserWindow): WindowPosition {
    this.logger.debug("Getting new window position.");
    let newWindowPosition: WindowPosition;
    if (window.isFullScreen()) {
      newWindowPosition = WINDOW_STATES.FullScreen;
    } else if (window.isMaximized()) {
      newWindowPosition = WINDOW_STATES.Maximized;
    } else if (window.isMinimized()) {
      newWindowPosition = WINDOW_STATES.Minimized;
    } else {
      newWindowPosition = window.getBounds();
    }
    return newWindowPosition;
  }
}

import { LogFunctions } from "electron-log";
import { Rectangle } from "electron/main";

export function adjustWindowBounds(screenBounds: Rectangle, windowBounds: Rectangle, logger: LogFunctions): Rectangle {
  let newWidth: number;
  let newHeight: number;
  let newX: number;
  let newY: number;
  // Ensure window is not wider than the screen
  if (windowBounds.width > screenBounds.width) {
    logger.silly("Window width greater than screen width. Setting to screen width.");
    newWidth = screenBounds.width;
  } else {
    logger.silly("Window width smaller than screen width. No change.");
    newWidth = windowBounds.width;
  }
  // Ensure window is not taller than the screen
  if (windowBounds.height > screenBounds.height) {
    logger.silly("Window height greater than screen height. Setting to screen height.");
    newHeight = screenBounds.height;
  } else {
    logger.silly("Window height smaller than screen height. No change.");
    newHeight = windowBounds.height;
  }
  // Ensure no leftwards overflow
  if (windowBounds.x < screenBounds.x) {
    logger.silly("Left window border extends beyond left screen edge. Setting to left screen edge.");
    newX = screenBounds.x;
  } else {
    logger.silly("Left window border inside screen area. No change.");
    newX = windowBounds.x;
  }
  // Ensure no rightwards overflow
  if (windowBounds.x + windowBounds.width > screenBounds.x + screenBounds.width) {
    logger.silly("Right window border extends beyond right screen edge. Setting to right screen edge.");
    newX = screenBounds.x + screenBounds.width - newWidth;
  } else {
    logger.silly("Right window border inside screen area. No change.");
  }
  // Ensure no upwards overflow
  if (windowBounds.y < screenBounds.y) {
    logger.silly("Top window border extends beyond top screen edge. Setting to top screen edge.");
    newY = screenBounds.y;
  } else {
    logger.silly("Top window border inside screen area. No change.");
    newY = windowBounds.y;
  }
  // Ensure no downwards overflow
  if (windowBounds.y + windowBounds.height > screenBounds.y + screenBounds.height) {
    logger.silly("Bottom window border extends beyond bottom screen edge. Setting to bottom screen edge.");
    newY = screenBounds.y + screenBounds.height - newHeight;
  } else {
    logger.silly("Bottom window border inside screen area. No change.");
  }

  // Final adjustment to ensure dimensions are correctly set within the screen bounds
  // This accounts for potential rounding issues
  newWidth = Math.min(newWidth, screenBounds.width);
  newHeight = Math.min(newHeight, screenBounds.height);

  return { x: newX, y: newY, width: newWidth, height: newHeight };
}