import { exec, execFile } from 'child_process';
import { promisify } from 'util';
import * as fs from 'fs';
import * as path from 'path';
import {
  abgleichMisserfolg,
  alsIsoDatum,
  dateiVorhanden,
  ersetzeDateiSicher,
  inhaltBeanstanden,
  type Abgleichauftrag,
  type Bezugsquelle,
  type GeheimnisBedarf,
  type QuellenAbgleich,
} from './basis';

const execAsync = promisify(exec);
const execFileAsync = promisify(execFile);

/** Ein Bau darf lange dauern (z. B. PyInstaller mit vielen Abhängigkeiten). */
const BAU_ZEITGRENZE_MS = 30 * 60 * 1000;
const GIT_ZEITGRENZE_MS = 10 * 60 * 1000;

/** Name der Bauanleitung, die ein Repository selbst mitbringt. */
export const BAUANLEITUNG_DATEI = 'software-bibliothek.json';

interface Bauanleitung {
  bauBefehl: string;
  ergebnis: string;
  geheimnisse: GeheimnisBedarf[];
}

/**
 * Aufbau der Anleitung, wie sie im Repository steht. Die Feldnamen sind englisch,
 * weil sie ein Vertrag nach außen sind — jedes anzubindende Tool schreibt sie.
 * Beschrieben im Skill „build-secrets" des Repos dh-claude-rules.
 */
interface AnleitungImRepo {
  buildCommand?: string;
  artifact?: string;
  secrets?: Array<{ name?: string; description?: string }>;
}

/**
 * Interne Tools aus einem Git-Repository: Arbeitskopie holen bzw. aktualisieren,
 * bauen und das erzeugte Programm bereitstellen.
 *
 * Angabe der Quelle: nur die Repo-URL, optional mit `#zweig` (z. B. `ssh://…/tool.git#main`).
 * Wie gebaut wird, beschreibt das Repository selbst in `software-bibliothek.json`:
 *
 *   { "buildCommand": "powershell -ExecutionPolicy Bypass -File build_exe.ps1",
 *     "artifact":     "dist/MeinTool.exe" }
 *
 * So bleibt die Bauanleitung dort, wo sie hingehört — beim Tool. In der Bibliothek
 * lassen sich beide Angaben bei Bedarf überschreiben (für fremde Repos, die man
 * nicht ändern kann).
 *
 * Die Arbeitskopie legt die Anwendung selbst an (`<Datenordner>\quellen\<id>`) — es
 * wird nichts vorausgesetzt, was auf dem jeweiligen Rechner schon vorhanden sein müsste.
 *
 * Hinweis zur Sicherheit: Der Bau-Befehl wird auf dem Server mit den Rechten des
 * Dienstbenutzers ausgeführt. Pflegen kann ihn nur, wer lokal am Server arbeitet
 * bzw. wer ins Repository schreiben darf.
 */
export class GitBuildQuelle implements Bezugsquelle {
  async gleicheAb(auftrag: Abgleichauftrag): Promise<QuellenAbgleich> {
    const [repoUrl, gewuenschterZweig] = auftrag.wert.split('#');
    let commit = '';
    try {
      commit = await arbeitskopieAktualisieren(repoUrl.trim(), gewuenschterZweig?.trim() ?? '', auftrag.arbeitsordner, auftrag.gitSshBefehl);
    } catch (fehler) {
      return abgleichMisserfolg(auftrag.aktuelleVersion, gitFehlertext(fehler));
    }

    const veroeffentlichtAm = await commitZeitpunkt(auftrag.arbeitsordner);
    const anleitung = leseBauanleitung(auftrag);
    if (!anleitung.bauBefehl || !anleitung.ergebnis) {
      return abgleichMisserfolg(
        auftrag.aktuelleVersion,
        `Im Repository fehlt die Datei ${BAUANLEITUNG_DATEI} mit „buildCommand" und „artifact" — alternativ beides in der Bibliothek hinterlegen.`
      );
    }

    // Nur bauen, wenn sich seit dem letzten Mal etwas geändert hat.
    const bekannterDateiname = ergebnisDateiname(anleitung.ergebnis);
    if (commit === auftrag.aktuelleVersion && dateiVorhanden(auftrag.zielordner, bekannterDateiname)) {
      return { erfolg: true, geaendert: false, version: commit, dateiname: bekannterDateiname, meldung: 'Bereits aktuell (unveränderter Stand).', veroeffentlichtAm, benoetigteGeheimnisse: anleitung.geheimnisse };
    }

    const fehlende = anleitung.geheimnisse.filter((bedarf) => !auftrag.geheimnisse[bedarf.name]).map((bedarf) => bedarf.name);
    try {
      // Geheimnisse gehen als Umgebungsvariablen in den Bau — das Tool entscheidet selbst,
      // was es daraus macht. Sie landen dadurch nirgends auf der Platte.
      await execAsync(anleitung.bauBefehl, {
        cwd: auftrag.arbeitsordner,
        timeout: BAU_ZEITGRENZE_MS,
        windowsHide: true,
        maxBuffer: 32 * 1024 * 1024,
        env: { ...process.env, ...auftrag.geheimnisse },
      });
    } catch (fehler) {
      const hinweis = fehlende.length > 0 ? ` Nicht hinterlegte Schlüssel: ${fehlende.join(', ')}.` : '';
      return abgleichMisserfolg(auftrag.aktuelleVersion, `Bau fehlgeschlagen: ${kurzeFehlermeldung(fehler)}${hinweis}`);
    }

    const ergebnisPfad = findeErgebnis(auftrag.arbeitsordner, anleitung.ergebnis);
    if (!ergebnisPfad) {
      return abgleichMisserfolg(auftrag.aktuelleVersion, `Der Bau lief durch, aber unter „${anleitung.ergebnis}" liegt keine Datei.`);
    }

    const dateiname = path.basename(ergebnisPfad);
    const inhalt = fs.readFileSync(ergebnisPfad);
    const beanstandung = inhaltBeanstanden(inhalt, dateiname, null, auftrag.vorherigeGroesse);
    if (beanstandung) {
      return abgleichMisserfolg(auftrag.aktuelleVersion, beanstandung);
    }

    ersetzeDateiSicher(auftrag.zielordner, dateiname, inhalt);
    return {
      erfolg: true,
      geaendert: true,
      version: commit,
      dateiname,
      meldung: `Aus Git gebaut (Stand ${commit.slice(0, 8)}).`,
      veroeffentlichtAm,
      benoetigteGeheimnisse: anleitung.geheimnisse,
    };
  }
}

/**
 * Bauanleitung ermitteln: bevorzugt aus dem Repository selbst, ersatzweise aus den
 * in der Bibliothek hinterlegten Angaben (die dort gepflegten haben Vorrang, damit
 * sich fremde Repos übersteuern lassen).
 */
function leseBauanleitung(auftrag: Abgleichauftrag): Bauanleitung {
  let ausRepo: AnleitungImRepo = {};
  const anleitungsPfad = path.join(auftrag.arbeitsordner, BAUANLEITUNG_DATEI);
  if (fs.existsSync(anleitungsPfad)) {
    try {
      ausRepo = JSON.parse(fs.readFileSync(anleitungsPfad, 'utf8')) as AnleitungImRepo;
    } catch {
      // Unlesbare Anleitung wie „nicht vorhanden" behandeln — die Angaben aus der
      // Bibliothek können den Bau trotzdem ermöglichen.
    }
  }
  const angeforderte = Array.isArray(ausRepo.secrets) ? ausRepo.secrets : [];
  return {
    bauBefehl: auftrag.bauBefehl.trim() || (ausRepo.buildCommand ?? '').trim(),
    ergebnis: auftrag.bauErgebnis.trim() || (ausRepo.artifact ?? '').trim(),
    geheimnisse: angeforderte
      .filter((bedarf): bedarf is { name: string; description?: string } => typeof bedarf?.name === 'string' && !!bedarf.name.trim())
      .map((bedarf) => ({ name: bedarf.name.trim(), beschreibung: String(bedarf.description ?? '') })),
  };
}

/** Klont die Arbeitskopie oder bringt sie auf den neuesten Stand. Liefert den Commit. */
async function arbeitskopieAktualisieren(repoUrl: string, gewuenschterZweig: string, arbeitsordner: string, sshBefehl: string): Promise<string> {
  // Die Kennung kommt aus den Einstellungen, nicht aus der URL — so bleibt der
  // Katalogeintrag frei von Konto-Angaben und ein Kontowechsel ist eine Änderung.
  const umgebung = sshBefehl ? { ...process.env, GIT_SSH_COMMAND: sshBefehl } : process.env;
  const git = (argumente: string[], cwd?: string) =>
    execFileAsync('git', argumente, { cwd, timeout: GIT_ZEITGRENZE_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024, env: umgebung });

  if (!fs.existsSync(path.join(arbeitsordner, '.git'))) {
    fs.rmSync(arbeitsordner, { recursive: true, force: true });
    fs.mkdirSync(path.dirname(arbeitsordner), { recursive: true });
    await git(['clone', repoUrl, arbeitsordner]);
  } else {
    await git(['remote', 'set-url', 'origin', repoUrl], arbeitsordner);
    await git(['fetch', '--prune', 'origin'], arbeitsordner);
  }

  const zweig = gewuenschterZweig || (await ermittleStandardZweig(arbeitsordner));
  // Harter Abgleich auf den Fernstand — lokale Reste aus einem früheren Bau stören sonst.
  await git(['checkout', '-B', zweig, `origin/${zweig}`], arbeitsordner);
  await git(['reset', '--hard', `origin/${zweig}`], arbeitsordner);
  await git(['clean', '-ffdx', '-e', 'node_modules', '-e', '.venv'], arbeitsordner);

  const { stdout } = await git(['rev-parse', 'HEAD'], arbeitsordner);
  return stdout.trim();
}

/** Zeitpunkt des ausgecheckten Commits — das ist der „Stand" des internen Tools. */
async function commitZeitpunkt(arbeitsordner: string): Promise<string> {
  try {
    const { stdout } = await execFileAsync('git', ['log', '-1', '--format=%cI'], {
      cwd: arbeitsordner,
      timeout: 30000,
      windowsHide: true,
    });
    return alsIsoDatum(stdout.trim());
  } catch {
    return '';
  }
}

async function ermittleStandardZweig(arbeitsordner: string): Promise<string> {
  try {
    const { stdout } = await execFileAsync('git', ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], {
      cwd: arbeitsordner,
      timeout: 30000,
      windowsHide: true,
    });
    return stdout.trim().replace(/^origin\//, '') || 'main';
  } catch {
    return 'main'; // Repos ohne gesetzten HEAD-Zeiger
  }
}

/** Löst den Ergebnis-Pfad auf; im Dateinamen ist ein `*` erlaubt. */
function findeErgebnis(arbeitsordner: string, muster: string): string | undefined {
  const vollstaendig = path.resolve(arbeitsordner, muster);
  if (!muster.includes('*')) {
    return fs.existsSync(vollstaendig) ? vollstaendig : undefined;
  }
  const ordner = path.dirname(vollstaendig);
  if (!fs.existsSync(ordner)) {
    return undefined;
  }
  const regel = new RegExp(`^${path.basename(vollstaendig).replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i');
  const treffer = fs.readdirSync(ordner).filter((name) => regel.test(name));
  return treffer.length > 0 ? path.join(ordner, treffer[0]) : undefined;
}

function ergebnisDateiname(muster: string): string {
  const name = path.basename(muster);
  return name.includes('*') ? '' : name;
}

function gitFehlertext(fehler: unknown): string {
  const text = kurzeFehlermeldung(fehler);
  if (/authenticat|permission denied|could not read|host key|publickey/i.test(text)) {
    return `Git-Anmeldung fehlgeschlagen. Der Dienstbenutzer braucht Zugriff auf das Repository (SSH-Schlüssel bzw. einmalige Anmeldung im Windows-Anmeldespeicher). Ursprüngliche Meldung: ${text}`;
  }
  return `Git fehlgeschlagen: ${text}`;
}

/** Kommandozeilen-Fehler enthalten oft seitenlange Ausgaben — auf das Wesentliche kürzen. */
function kurzeFehlermeldung(fehler: unknown): string {
  const roh = fehler instanceof Error ? ((fehler as Error & { stderr?: string }).stderr || fehler.message) : String(fehler);
  const zeilen = roh.split('\n').map((zeile) => zeile.trim()).filter(Boolean);
  return zeilen.slice(-4).join(' | ').slice(0, 500);
}