import { execFile } from 'node:child_process';
import { promisify } from 'node:util';

const run = promisify(execFile);

export interface HotkeyRequest {
  /** Touche à envoyer : « f », « F11 », « space »… */
  key: string;
  /** Fragment du titre de la fenêtre cible (insensible à la casse). */
  windowMatch: string;
}

export interface HotkeyResult {
  method: string;
  window?: string;
}

/**
 * Jeu de touches autorisé. Ces valeurs viennent de la configuration serveur et
 * finissent dans une ligne de commande : on refuse tout ce qui sort du lot
 * plutôt que d'échapper au cas par cas.
 */
const KEY_PATTERN = /^(?:[A-Za-z0-9]|F[1-9]|F1[0-2]|space|Return|Escape|Tab)$/;

function assertKey(key: string): string {
  if (!KEY_PATTERN.test(key)) {
    throw new Error(
      `Touche « ${key} » non autorisée (lettres, chiffres, F1-F12, space, Return, Escape, Tab)`,
    );
  }
  return key;
}

/**
 * Envoie une touche au lecteur vidéo, par exemple pour rebasculer en plein
 * écran après un show privé.
 *
 * Limite assumée : sous X11 comme sous Windows, la fenêtre cible doit passer au
 * premier plan. Les navigateurs ignorent les évènements clavier synthétiques
 * envoyés par XSendEvent (`xdotool key --window`), donc on active la fenêtre et
 * on injecte la touche via XTEST. Sur une VM d'enregistrement dédiée c'est sans
 * conséquence, mais ça vole le focus si quelqu'un est en train de s'en servir.
 */
export async function sendHotkey(request: HotkeyRequest): Promise<HotkeyResult> {
  const key = assertKey(request.key);
  const match = request.windowMatch.trim();
  if (!match) throw new Error('Aucun titre de fenêtre à cibler (windowMatch vide)');

  switch (process.platform) {
    case 'linux':
      return sendLinux(key, match);
    case 'win32':
      return sendWindows(key, match);
    case 'darwin':
      return sendDarwin(key, match);
    default:
      throw new Error(`Envoi de touche non supporté sur ${process.platform}`);
  }
}

// --- X11 --------------------------------------------------------------------

async function sendLinux(key: string, match: string): Promise<HotkeyResult> {
  const env = { ...process.env, DISPLAY: process.env.DISPLAY ?? ':0' };

  let ids: string[];
  try {
    const { stdout } = await run(
      'xdotool',
      ['search', '--onlyvisible', '--name', match],
      { env, timeout: 5000 },
    );
    ids = stdout.split('\n').map((line) => line.trim()).filter(Boolean);
  } catch (err) {
    const code = (err as NodeJS.ErrnoException).code;
    if (code === 'ENOENT') {
      throw new Error('xdotool est absent — installe-le : apt install xdotool');
    }
    // xdotool sort en code 1 quand rien ne correspond.
    throw new Error(`Aucune fenêtre visible ne correspond à « ${match} »`);
  }
  if (ids.length === 0) throw new Error(`Aucune fenêtre visible ne correspond à « ${match} »`);

  // La dernière fenêtre listée est en général la plus récemment mappée.
  const windowId = ids[ids.length - 1]!;

  let title = windowId;
  try {
    const { stdout } = await run('xdotool', ['getwindowname', windowId], { env, timeout: 5000 });
    title = stdout.trim() || windowId;
  } catch {
    /* le titre n'est qu'informatif */
  }

  await run('xdotool', ['windowactivate', '--sync', windowId], { env, timeout: 5000 });
  await run('xdotool', ['key', '--clearmodifiers', key], { env, timeout: 5000 });

  return { method: 'xdotool', window: title };
}

// --- Windows ----------------------------------------------------------------

/** Échappe une valeur pour une chaîne littérale PowerShell entre apostrophes. */
function psLiteral(value: string): string {
  return `'${value.replace(/'/g, "''")}'`;
}

async function sendWindows(key: string, match: string): Promise<HotkeyResult> {
  // SendKeys interprète certains caractères ; les touches nommées se notent {F11}.
  const sendKeysArg = key.length === 1 ? key.toLowerCase() : `{${key.toUpperCase()}}`;

  const script = `
$ErrorActionPreference = 'Stop'
Add-Type @"
using System;
using System.Runtime.InteropServices;
using System.Text;
public class Win32 {
  [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
  [DllImport("user32.dll")] public static extern int GetWindowTextLength(IntPtr hWnd);
  [DllImport("user32.dll", CharSet=CharSet.Unicode)] public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
  [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr hWnd);
  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr hWnd);
  [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
  public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
}
"@
$needle = ${psLiteral(match)}
$found = [IntPtr]::Zero
$foundTitle = ''
$callback = [Win32+EnumWindowsProc]{
  param($hWnd, $lParam)
  if (-not [Win32]::IsWindowVisible($hWnd)) { return $true }
  $len = [Win32]::GetWindowTextLength($hWnd)
  if ($len -eq 0) { return $true }
  $sb = New-Object System.Text.StringBuilder($len + 1)
  [void][Win32]::GetWindowText($hWnd, $sb, $sb.Capacity)
  $title = $sb.ToString()
  if ($title -like ('*' + $needle + '*')) { $script:found = $hWnd; $script:foundTitle = $title; return $false }
  return $true
}
[void][Win32]::EnumWindows($callback, [IntPtr]::Zero)
if ($script:found -eq [IntPtr]::Zero) { Write-Error ('Aucune fenetre ne correspond a ' + $needle); exit 1 }
[void][Win32]::ShowWindow($script:found, 9)
[void][Win32]::SetForegroundWindow($script:found)
Start-Sleep -Milliseconds 300
Add-Type -AssemblyName System.Windows.Forms
[System.Windows.Forms.SendKeys]::SendWait(${psLiteral(sendKeysArg)})
Write-Output $script:foundTitle
`;

  // -EncodedCommand évite tout problème de guillemets entre cmd.exe et PowerShell.
  const encoded = Buffer.from(script, 'utf16le').toString('base64');

  try {
    const { stdout } = await run(
      'powershell.exe',
      ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded],
      { timeout: 20_000, windowsHide: true },
    );
    return { method: 'SendKeys', window: stdout.trim() || undefined };
  } catch (err) {
    const stderr = (err as { stderr?: string }).stderr?.trim();
    throw new Error(stderr || `Envoi de « ${key} » impossible vers « ${match} »`);
  }
}

// --- macOS (confort de développement) ---------------------------------------

async function sendDarwin(key: string, match: string): Promise<HotkeyResult> {
  const script = `
tell application "System Events"
  set matches to (every process whose name contains "${match.replace(/["\\]/g, '')}")
  if (count of matches) = 0 then error "Aucun processus ne correspond"
  set target to item 1 of matches
  set frontmost of target to true
  delay 0.3
  keystroke "${key.toLowerCase()}"
end tell`;

  try {
    await run('osascript', ['-e', script], { timeout: 15_000 });
    return { method: 'osascript', window: match };
  } catch (err) {
    const stderr = (err as { stderr?: string }).stderr?.trim();
    throw new Error(stderr || `Envoi de « ${key} » impossible vers « ${match} »`);
  }
}