/**
 * Proxmox template selection — shared between `service add proxmox` and
 * `service reconfigure`. Queries Proxmox's live appliance catalog
 * (`pveam available`) and prompts the user to pick an Ubuntu LXC template by
 * canonical name.
 *
 * Why this exists: Proxmox bumps template revisions over time
 * (ubuntu-24.04 went from -1 to -2, 25.04 ships as -1.1) and an older home-lab
 * deployment guide naming `-1` produces 404s on the mirror. Using the catalog
 * means the canonical filename always matches what `pveam download` accepts.
 */

import {
  type ProxmoxAppliance,
  type ProxmoxCredentials,
  checkTaskStatus,
  downloadAppliance,
  listAvailableAppliances,
} from '../../api-clients/proxmox';
import { askSelect, askText } from '../../services/bus-interview';
import { FuelGauge } from '../fuel-gauge';

export interface UbuntuTemplateChoice {
  /** Canonical filename, e.g. "ubuntu-24.04-standard_24.04-2_amd64.tar.zst" */
  template: string;
  /**
   * 'catalog' = filename came from Proxmox's aplinfo, so it's known good for
   * downloadAppliance. 'manual' = user typed it because aplinfo was unavailable;
   * caller should expect they'll need to `pveam download` themselves.
   */
  source: 'catalog' | 'manual';
}

export type TemplateSelectionResult =
  | { kind: 'selected'; choice: UbuntuTemplateChoice }
  | { kind: 'cancelled' }
  | { kind: 'error'; message: string };

interface ParsedUbuntu {
  appliance: ProxmoxAppliance;
  major: number;
  minor: number;
  isLts: boolean;
}

function parseUbuntuPackage(appliance: ProxmoxAppliance): ParsedUbuntu | null {
  const match = appliance.package.match(/^ubuntu-(\d+)\.(\d+)-standard$/);
  if (!match) return null;
  const major = Number(match[1]);
  const minor = Number(match[2]);
  // Ubuntu LTS = even major, .04 minor (20.04, 22.04, 24.04, 26.04, ...).
  const isLts = minor === 4 && major % 2 === 0;
  return { appliance, major, minor, isLts };
}

function compareDescending(a: ParsedUbuntu, b: ParsedUbuntu): number {
  if (a.major !== b.major) return b.major - a.major;
  return b.minor - a.minor;
}

/**
 * Build the option list used by the select prompt and tests.
 * Exported so tests can assert on filtering/sorting without driving a prompt.
 */
export function buildUbuntuOptions(appliances: ProxmoxAppliance[]): ParsedUbuntu[] {
  return appliances
    .map(parseUbuntuPackage)
    .filter((entry): entry is ParsedUbuntu => entry !== null)
    .filter((entry) => (entry.appliance.section ?? 'system') === 'system')
    .sort(compareDescending);
}

/**
 * Pre-select rule:
 *   1. Exact match on currentTemplate (reconfigure with current revision still on mirror).
 *   2. Family match on currentTemplate package (e.g. user has 24.04 -1 cached, mirror has -2).
 *   3. Newest LTS in the catalog.
 *   4. Newest entry overall.
 */
export function pickInitialTemplate(
  options: ParsedUbuntu[],
  currentTemplate?: string,
): string | undefined {
  if (options.length === 0) return undefined;

  if (currentTemplate) {
    const exact = options.find((e) => e.appliance.template === currentTemplate);
    if (exact) return exact.appliance.template;

    const familyName = currentTemplate.match(/^(ubuntu-\d+\.\d+-standard)/)?.[1];
    if (familyName) {
      const family = options.find((e) => e.appliance.package === familyName);
      if (family) return family.appliance.template;
    }
  }

  const newestLts = options.find((e) => e.isLts);
  return (newestLts ?? options[0]).appliance.template;
}

export async function selectUbuntuApplianceFromCatalog(
  credentials: ProxmoxCredentials,
  nodeName: string,
  opts: { scope: string; currentTemplate?: string },
): Promise<TemplateSelectionResult> {
  console.log('\nFetching Proxmox template catalog...');
  const result = await listAvailableAppliances(credentials, nodeName);

  if (!result.success) {
    console.log(`⚠ Could not fetch template catalog from Proxmox: ${result.message}`);
    console.log('  You can still configure the service by entering a template filename manually.');
    console.log(
      '  After saving, run `pveam download <storage> <template>` on the Proxmox host before deploying.',
    );

    // Manual fallback over the bus (ISS-0127) — drivable headlessly by
    // answering `interview.required.<scope>.lxc_template_manual`.
    const manual = await askText({
      scope: opts.scope,
      key: 'lxc_template_manual',
      message: 'Template filename',
      placeholder: 'ubuntu-24.04-standard_24.04-2_amd64.tar.zst',
      required: true,
    });

    if (manual.trim() === '') {
      return { kind: 'cancelled' };
    }

    return { kind: 'selected', choice: { template: manual.trim(), source: 'manual' } };
  }

  const options = buildUbuntuOptions(result.data);

  if (options.length === 0) {
    return {
      kind: 'error',
      message:
        'Proxmox aplinfo returned no Ubuntu standard templates. Run `pveam update` on the Proxmox host and re-try.',
    };
  }

  const initialValue = pickInitialTemplate(options, opts.currentTemplate);

  // Template choice over the bus (ISS-0127), keyed `lxc_template` within scope.
  const selection = await askSelect({
    scope: opts.scope,
    key: 'lxc_template',
    message: 'Default Ubuntu template',
    options: options.map((e) => ({
      value: e.appliance.template,
      label: `Ubuntu ${e.major}.${String(e.minor).padStart(2, '0')}${e.isLts ? ' LTS' : ''}`,
      hint: e.isLts
        ? `revision ${e.appliance.version}`
        : `revision ${e.appliance.version} · non-LTS`,
    })),
    defaultValue: initialValue,
  });

  return { kind: 'selected', choice: { template: selection, source: 'catalog' } };
}

export interface ApplianceDownloadOutcome {
  /** True iff the template ended up available in the chosen storage. */
  ready: boolean;
  /**
   * One of:
   *   'started-failed' — POST to aplinfo failed (Proxmox rejected the request).
   *   'task-failed'    — Download started but pveam exited non-OK (typically exit 8 = HTTP error).
   *   'timeout'        — Polling exhausted the budget without seeing 'stopped'.
   *   'ok'             — pveam exited 0 and template should now exist in storage.
   */
  reason: 'started-failed' | 'task-failed' | 'timeout' | 'ok';
  /** The pveam exit status when reason='task-failed', or null otherwise. */
  exitStatus?: string;
  /** The error message from Proxmox when reason='started-failed'. */
  startError?: string;
}

export interface RunApplianceDownloadInput {
  credentials: ProxmoxCredentials;
  targetNode: string;
  templateStorage: string;
  templateFilename: string;
  /** Polling budget in 5s ticks; defaults to 60 (= 5 minutes). */
  maxAttempts?: number;
  /** Override the default 5000ms tick — primarily to keep tests fast. */
  pollIntervalMs?: number;
}

/**
 * Trigger a `pveam download` on the Proxmox host and poll until it finishes.
 * Drives a FuelGauge for user-visible progress. Distinguishes real failures
 * (Proxmox rejected the start, or pveam exited non-OK) from timeout, so the
 * caller can render an accurate next-steps message instead of always blaming
 * "5-minute timeout" for any non-success path (the bug that motivated this
 * refactor).
 */
export async function runApplianceDownload(
  input: RunApplianceDownloadInput,
): Promise<ApplianceDownloadOutcome> {
  const {
    credentials,
    targetNode,
    templateStorage,
    templateFilename,
    maxAttempts = 60,
    pollIntervalMs = 5000,
  } = input;

  const startResult = await downloadAppliance(
    credentials,
    targetNode,
    templateStorage,
    templateFilename,
  );

  if (!startResult.success) {
    console.log(`\n✗ Failed to start download: ${startResult.message}`);
    return { ready: false, reason: 'started-failed', startError: startResult.message };
  }

  const upid = startResult.data;
  const gauge = new FuelGauge(`Downloading ${templateFilename}`);
  gauge.start();

  let attempts = 0;
  while (attempts < maxAttempts) {
    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
    attempts++;

    const statusResult = await checkTaskStatus(credentials, targetNode, upid);
    if (!statusResult.success) {
      gauge.addOutput(`Waiting for status... (${attempts * 5}s elapsed)`);
      continue;
    }

    if (statusResult.data.status !== 'stopped') {
      gauge.addOutput(`Status: ${statusResult.data.status} (${attempts * 5}s elapsed)`);
      continue;
    }

    const exit = statusResult.data.exitstatus;
    if (exit === 'OK') {
      gauge.stop(true);
      return { ready: true, reason: 'ok' };
    }

    gauge.stop(false);
    console.log(`\n✗ pveam download failed: ${exit ?? 'unknown exit status'}`);
    return { ready: false, reason: 'task-failed', exitStatus: exit ?? undefined };
  }

  gauge.stop(false);
  console.log(
    `\n✗ Template download did not complete within ${(maxAttempts * pollIntervalMs) / 1000}s`,
  );
  return { ready: false, reason: 'timeout' };
}