'use strict';

const http = require('http');
const crypto = require('crypto');
const { Readable, Transform, pipeline } = require('stream');

const KEY = (process.env.CF_API_KEY || '').trim();
const PORT = Number(process.env.PORT || 8420);
const HOST = process.env.HOST || '0.0.0.0';

const TOKENS = new Set(
  String(process.env.CF_PROXY_TOKEN || '')
    .split(',').map((t) => t.trim()).filter(Boolean),
);
const LIMIT_PRO_MIN = Number(process.env.RATE_LIMIT_PER_MIN || 60);
const MAX_MB = Number(process.env.MAX_DOWNLOAD_MB || 512);
// gleichzeitige Downloads insgesamt – schützt die Bandbreite, falls jemand mit dem
// (im Launcher steckenden) Token viele große Dateien parallel zieht. 0 = keine Grenze.
const MAX_PARALLEL = Number(process.env.MAX_PARALLEL_DOWNLOADS ?? 8);
// wie lange CurseForge für eine Antwort brauchen darf, bevor die Anfrage abgebrochen wird
const UPSTREAM_TIMEOUT_MS = 30_000;
let laufendeDownloads = 0;
const SELFTEST_ABSTAND_MS = 30_000;
let selftestErgebnis = null;
let selftestZeit = 0;

const PROXY_STUFEN = Math.max(0, Number(process.env.TRUST_PROXY || 0) || 0);

const CF_API = 'https://api.curseforge.com/v1';

const UA = 'AeroMC-Launcher-Proxy/1.0 (+https://git.viper.ipv64.net)';

function cfKopfzeilen(weitere) {
  return Object.assign({ 'x-api-key': KEY, Accept: 'application/json', 'User-Agent': UA }, weitere || {});
}

const ERLAUBTE_HOSTS = new Set([
  'edge.forgecdn.net',
  'mediafilez.forgecdn.net',
  'media.forgecdn.net',
]);

if (!KEY) {
  console.error('CF_API_KEY fehlt. Bitte setzen (siehe .env.example) und neu starten.');
  process.exit(1);
}

// Ohne Token wäre der Dienst für jeden offen, der die Adresse kennt – und damit
// auch der API-Key und das Download-Kontingent dahinter. Deshalb startet er
// ohne CF_PROXY_TOKEN gar nicht erst. Wer ihn bewusst offen betreiben will
// (z. B. nur im eigenen Netz), muss das ausdrücklich sagen: CF_PROXY_OFFEN=1.
const OFFEN_ERLAUBT = process.env.CF_PROXY_OFFEN === '1';
if (!TOKENS.size && !OFFEN_ERLAUBT) {
  console.error('CF_PROXY_TOKEN fehlt. Ohne Token könnte jeder den Dienst (und deinen API-Key) benutzen.');
  console.error('Token setzen (siehe .env.example) – oder, nur für ein abgeschottetes Netz, CF_PROXY_OFFEN=1.');
  process.exit(1);
}

// ---------------------------------------------------------------------------
// Ratenbegrenzung: einfaches Zeitfenster je Absender
// ---------------------------------------------------------------------------

const zaehler = new Map();   // ip -> { anzahl, bis }

/*
 * Ermittelt den Absender – die Grundlage der Ratenbegrenzung.
 *
 * nginx & Co. hängen die echte Adresse hinten an X-Forwarded-For an, statt
 * den Kopfeintrag zu ersetzen. Alles davor kann der Aufrufer frei erfinden.
 * Vertrauenswürdig ist deshalb nur der Eintrag, den die letzte eigene
 * Proxy-Stufe geschrieben hat: von rechts gezählt.
 *
 *   Aufrufer schickt "1.2.3.4", ein Proxy davor
 *   -> "1.2.3.4, <echte-IP>"  ->  mit TRUST_PROXY=1 zählt <echte-IP>
 */
function absender(req) {
  if (PROXY_STUFEN > 0) {
    const kette = String(req.headers['x-forwarded-for'] || '')
      .split(',').map((s) => s.trim()).filter(Boolean);
    const i = kette.length - PROXY_STUFEN;
    if (i >= 0 && kette[i]) return kette[i];
    // Kette kürzer als erwartet -> nicht dem Aufrufer glauben
  }
  return req.socket.remoteAddress || 'unbekannt';
}

function darfNoch(ip) {
  if (LIMIT_PRO_MIN <= 0) return true;
  const jetzt = Date.now();
  const e = zaehler.get(ip);
  if (!e || jetzt > e.bis) { zaehler.set(ip, { anzahl: 1, bis: jetzt + 60000 }); return true; }
  e.anzahl++;
  return e.anzahl <= LIMIT_PRO_MIN;
}

// alte Einträge regelmäßig wegräumen, sonst wächst die Liste unbegrenzt
setInterval(() => {
  const jetzt = Date.now();
  for (const [ip, e] of zaehler) if (jetzt > e.bis) zaehler.delete(ip);
}, 60000).unref();

// ---------------------------------------------------------------------------
// Hilfen
// ---------------------------------------------------------------------------

function sendeJson(res, code, daten) {
  const koerper = JSON.stringify(daten);
  res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': Buffer.byteLength(koerper) });
  res.end(koerper);
}

// Vergleich in gleichbleibender Zeit, damit sich ein Token nicht Zeichen für
// Zeichen über die Antwortdauer erraten lässt
function gleich(a, b) {
  const x = crypto.createHash('sha256').update(a).digest();
  const y = crypto.createHash('sha256').update(b).digest();
  return crypto.timingSafeEqual(x, y);
}

function tokenOk(req) {
  if (!TOKENS.size) return OFFEN_ERLAUBT;   // ohne Token nur mit ausdrücklicher Freigabe
  const erhalten = String(req.headers['x-aeromc-token'] || '').trim();
  if (!erhalten) return false;
  let ok = false;
  for (const t of TOKENS) if (gleich(t, erhalten)) ok = true;
  return ok;
}

function leseKoerper(req, maxBytes = 1_000_000) {
  return new Promise((resolve, reject) => {
    let daten = '';
    let laenge = 0;
    req.on('data', (d) => {
      laenge += d.length;
      if (laenge > maxBytes) { reject(new Error('Anfrage zu groß')); req.destroy(); return; }
      daten += d;
    });
    req.on('end', () => resolve(daten));
    req.on('error', reject);
  });
}

// prüft die Zieladresse einer Download-Anfrage
function pruefeDownloadZiel(roh) {
  let u;
  try { u = new URL(roh); } catch { return null; }
  if (u.protocol !== 'https:') return null;
  if (!ERLAUBTE_HOSTS.has(u.hostname)) return null;
  return u;
}

// ---------------------------------------------------------------------------
// Wege
// ---------------------------------------------------------------------------

async function dateilisteAufloesen(req, res) {
  let rumpf;
  try { rumpf = JSON.parse(await leseKoerper(req)); }
  catch { return sendeJson(res, 400, { error: 'Ungültiger Rumpf.' }); }

  const ids = Array.isArray(rumpf && rumpf.fileIds) ? rumpf.fileIds.map(Number).filter(Boolean) : [];
  if (!ids.length) return sendeJson(res, 400, { error: 'fileIds fehlen.' });
  if (ids.length > 100) return sendeJson(res, 400, { error: 'Höchstens 100 fileIds je Anfrage.' });

  const antwort = await fetch(CF_API + '/mods/files', {
    method: 'POST',
    headers: cfKopfzeilen({ 'Content-Type': 'application/json' }),
    body: JSON.stringify({ fileIds: ids }),
    signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
  });
  if (!antwort.ok) {
    // Schlüsselprobleme nicht im Wortlaut weiterreichen
    const code = antwort.status === 401 || antwort.status === 403 ? 502 : antwort.status;
    return sendeJson(res, code, { error: 'CurseForge antwortet mit HTTP ' + antwort.status });
  }
  sendeJson(res, 200, await antwort.json());
}

/*
 * Katalog-Wege: Suche, Kategorien und Dateiliste einer Mod. Es wird nur durchgereicht,
 * was der Launcher dafür braucht – jeder Weg hat eine feste Liste erlaubter Parameter,
 * andere werden verworfen. gameId ist immer Minecraft (432), damit sich der Dienst nicht
 * für andere Spiele missbrauchen lässt. Antworten werden NICHT zwischengespeichert
 * (die CurseForge-Bedingungen verbieten es, Daten aus der API zu speichern).
 */
const MC_SPIEL = '432';
const ganz = (min, max) => (v) => /^\d{1,9}$/.test(v) && Number(v) >= min && Number(v) <= max;
const text = (maxLaenge) => (v) => v.length > 0 && v.length <= maxLaenge && !/[\u0000-\u001f]/.test(v);
const KATALOG_PARAMETER = {
  suche: {
    classId: ganz(0, 100000), categoryId: ganz(0, 100000),
    searchFilter: text(100), gameVersion: text(32),
    modLoaderType: ganz(0, 6), sortField: ganz(1, 8),
    sortOrder: (v) => v === 'asc' || v === 'desc',
    pageSize: ganz(1, 50), index: ganz(0, 10000),
  },
  kategorien: { classId: ganz(0, 100000) },
  dateien: { gameVersion: text(32), modLoaderType: ganz(0, 6), pageSize: ganz(1, 50), index: ganz(0, 10000) },
};
const MAX_KATALOG_BYTES = 4 * 1024 * 1024;

async function katalogAnfrage(res, url, cfPfad, erlaubt) {
  const ziel = new URL(CF_API + cfPfad);
  if (erlaubt === KATALOG_PARAMETER.suche || erlaubt === KATALOG_PARAMETER.kategorien) ziel.searchParams.set('gameId', MC_SPIEL);
  for (const [name, wert] of url.searchParams) {
    const pruefer = erlaubt[name];
    if (!pruefer || !pruefer(wert)) continue;   // unbekannte oder ungültige Parameter einfach weglassen
    ziel.searchParams.set(name, wert);
  }
  const antwort = await fetch(ziel, { headers: cfKopfzeilen(), signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS) });
  if (!antwort.ok) {
    // Schlüsselprobleme nicht im Wortlaut weiterreichen
    const code = antwort.status === 401 || antwort.status === 403 ? 502 : antwort.status;
    return sendeJson(res, code, { error: 'CurseForge antwortet mit HTTP ' + antwort.status });
  }
  const roh = await antwort.text();
  if (roh.length > MAX_KATALOG_BYTES) return sendeJson(res, 502, { error: 'Antwort von CurseForge zu groß.' });
  res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8', 'Content-Length': Buffer.byteLength(roh) });
  res.end(roh);
}

async function dateiDurchreichen(req, res, url) {
  const ziel = pruefeDownloadZiel(url.searchParams.get('url') || '');
  if (!ziel) return sendeJson(res, 400, { error: 'Adresse fehlt oder zeigt nicht auf das CurseForge-CDN.' });

  // Weiterleitungen selbst verfolgen und jedes Mal den Host neu prüfen
  if (MAX_PARALLEL > 0 && laufendeDownloads >= MAX_PARALLEL) {
    res.setHeader('Retry-After', '5');
    return sendeJson(res, 503, { error: 'Gerade zu viele Downloads, bitte gleich erneut versuchen.' });
  }
  laufendeDownloads++;
  let frei = false;
  const freigeben = () => { if (!frei) { frei = true; laufendeDownloads--; } };

  try {
    // Zeitlimit nur bis die Antwort-Köpfe da sind – der eigentliche Download darf länger dauern
    const abbruch = new AbortController();
    const frist = setTimeout(() => abbruch.abort(), UPSTREAM_TIMEOUT_MS);
    res.on('close', () => abbruch.abort());   // Aufrufer weg -> CurseForge-Verbindung schließen

    let aktuell = ziel;
    let antwort = null;
    let umgeleitet = true;
    try {
      for (let sprung = 0; sprung < 4 && umgeleitet; sprung++) {
        antwort = await fetch(aktuell, { headers: cfKopfzeilen(), redirect: 'manual', signal: abbruch.signal });
        const weiter = antwort.headers.get('location');
        if (antwort.status >= 300 && antwort.status < 400 && weiter) {
          const naechste = pruefeDownloadZiel(new URL(weiter, aktuell).toString());
          if (!naechste) { freigeben(); return sendeJson(res, 502, { error: 'Weiterleitung führt aus dem CurseForge-CDN heraus.' }); }
          aktuell = naechste;
        } else {
          umgeleitet = false;
        }
      }
    } finally {
      clearTimeout(frist);
    }
    if (umgeleitet) { freigeben(); return sendeJson(res, 502, { error: 'Zu viele Weiterleitungen.' }); }
    if (!antwort || !antwort.ok) {
      freigeben();
      return sendeJson(res, antwort && antwort.status >= 400 ? antwort.status : 502, { error: 'Download fehlgeschlagen.' });
    }

    const laenge = Number(antwort.headers.get('content-length')) || 0;
    const grenze = MAX_MB > 0 ? MAX_MB * 1024 * 1024 : 0;
    if (grenze && laenge > grenze) {
      freigeben();
      return sendeJson(res, 413, { error: `Datei größer als erlaubt (${MAX_MB} MB).` });
    }

    res.writeHead(200, {
      'Content-Type': antwort.headers.get('content-type') || 'application/octet-stream',
      ...(laenge ? { 'Content-Length': String(laenge) } : {}),
    });

    // Auch ohne Content-Length (chunked) mitzählen und bei Überschreitung abbrechen,
    // sonst ließe sich die Größengrenze umgehen
    let gesamt = 0;
    const zaehlen = new Transform({
      transform(stueck, _enc, fertig) {
        gesamt += stueck.length;
        if (grenze && gesamt > grenze) return fertig(new Error('Datei größer als erlaubt'));
        fertig(null, stueck);
      },
    });
    // pipeline räumt auf, wenn eine Seite abbricht (statt wie pipe() offen zu bleiben)
    pipeline(Readable.fromWeb(antwort.body), zaehlen, res, () => freigeben());
  } catch (err) {
    freigeben();
    throw err;
  }
}

// ---------------------------------------------------------------------------

const server = http.createServer(async (req, res) => {
  let url;
  try { url = new URL(req.url, 'http://localhost'); }
  catch { return sendeJson(res, 400, { error: 'Ungültige Anfrage.' }); }

  if (url.pathname === '/health') {
    return sendeJson(res, 200, { ok: true, dienst: 'aeromc-cf-proxy' });
  }

  if (!tokenOk(req)) {
    // Fehlversuche je Absender begrenzen, damit sich das Token nicht in Ruhe erraten lässt
    if (!darfNoch('falsch:' + absender(req))) return sendeJson(res, 429, { error: 'Zu viele Anfragen, bitte kurz warten.' });
    return sendeJson(res, 401, { error: 'Nicht berechtigt.' });
  }

  /*
   * Hilfe beim Einstellen von TRUST_PROXY: zeigt, was der Dienst von DIESER
   * Anfrage sieht. Steht bewusst hinter der Token-Prüfung, damit Scanner
   * nichts über den Aufbau erfahren. Aufruf von außen:
   *
   *   curl -s -H 'x-aeromc-token: DEIN-TOKEN' https://deine-adresse/whoami
   *
   *   erkannt == deine echte öffentliche IP  -> TRUST_PROXY stimmt
   *   erkannt == eine interne Adresse        -> zu niedrig
   *   erkannt == eine erfundene Adresse      -> zu hoch
   *
   * Vor der Ratenbegrenzung, damit die Diagnose auch dann noch antwortet,
   * wenn man sich gerade selbst ausgesperrt hat.
   */
  if (url.pathname === '/whoami') {
    const kette = String(req.headers['x-forwarded-for'] || '')
      .split(',').map((s) => s.trim()).filter(Boolean);
    return sendeJson(res, 200, {
      erkannt: absender(req),
      proxyStufen: PROXY_STUFEN,
      kette,
      verbindungVon: req.socket.remoteAddress || null,
      hinweis: 'Stimmt "erkannt" mit deiner echten öffentlichen IP überein, ist TRUST_PROXY richtig gesetzt.',
    });
  }

  /*
   * Selbsttest: prüft den API-Schlüssel, den DIESER Prozess wirklich geladen
   * hat, direkt gegen CurseForge. Beantwortet die zwei Fragen, die man von
   * außen sonst nicht auseinanderhalten kann:
   *   - hat der Prozess überhaupt den neuen Schlüssel?
   *   - akzeptiert CurseForge ihn?
   * Gibt nur Länge und die ersten Zeichen aus (bei CurseForge immer "$2a$10$"),
   * niemals den Schlüssel selbst.
   */
  if (url.pathname === '/selftest') {
    /*
     * Das Token steckt im Launcher und ist auslesbar. Jeder Selbsttest kostet fünf
     * CurseForge-Anfragen und läuft vor der Ratenbegrenzung – ohne Bremse ließe sich
     * damit das Kontingent des Schlüssels aufbrauchen. Deshalb höchstens alle
     * 30 Sekunden wirklich ausführen, dazwischen das letzte Ergebnis zeigen.
     */
    const jetzt = Date.now();
    if (selftestErgebnis && jetzt - selftestZeit < SELFTEST_ABSTAND_MS) {
      return sendeJson(res, 200, Object.assign({}, selftestErgebnis, { zwischengespeichert: true }));
    }
    const roh = process.env.CF_API_KEY || '';
    const befund = {
      schluessel: {
        laenge: KEY.length,
        beginntMit: KEY.slice(0, 7),
        randzeichenEntfernt: roh !== KEY,
        sahAusWieCurseForge: /^\$2[aby]\$\d\d\$/.test(KEY),
      },
      curseforge: null,
      urteil: '',
    };
    /*
     * Mehrere Zugänge nacheinander prüfen. Erst der Vergleich zeigt, ob der
     * Schlüssel grundsätzlich abgelehnt wird oder nur für bestimmte Bereiche
     * fehlt – ein einzelner Aufruf kann das nicht unterscheiden.
     */
    const PROBEN = [
      { name: 'games – Liste aller Spiele', method: 'GET', pfad: '/games' },
      { name: 'games/432 – Minecraft', method: 'GET', pfad: '/games/432' },
      { name: 'categories – Minecraft-Kategorien', method: 'GET', pfad: '/categories?gameId=432' },
      { name: 'mods/search – Modsuche', method: 'GET', pfad: '/mods/search?gameId=432&searchFilter=jei' },
      { name: 'mods/files – was der Import braucht', method: 'POST', pfad: '/mods/files', body: { fileIds: [4959679] } },
    ];

    befund.proben = [];
    for (const p of PROBEN) {
      try {
        const a = await fetch(CF_API + p.pfad, {
          method: p.method,
          headers: cfKopfzeilen(p.body ? { 'Content-Type': 'application/json' } : undefined),
          body: p.body ? JSON.stringify(p.body) : undefined,
          signal: AbortSignal.timeout(UPSTREAM_TIMEOUT_MS),
        });
        let text = '';
        try { text = (await a.text()).replace(/\s+/g, ' ').trim().slice(0, 160); } catch { /* egal */ }
        befund.proben.push({
          name: p.name,
          status: a.status,
          server: a.headers.get('server') || null,
          antwortAnfang: a.ok ? '(ok)' : text,
        });
      } catch (err) {
        befund.proben.push({ name: p.name, fehler: err.message });
      }
    }

    const stati = befund.proben.map((p) => p.status);
    const alleAbgelehnt = stati.every((s) => s === 401 || s === 403);
    const alleGut = stati.every((s) => s >= 200 && s < 300);
    const nurDateien = befund.proben.find((p) => p.name.startsWith('mods/files'));

    if (alleGut) befund.urteil = 'Alle Zugänge offen – der Schlüssel ist in Ordnung.';
    else if (alleAbgelehnt) {
      befund.urteil = 'Kein einziger Zugang offen: Dieser Schlüssel gilt bei CurseForge nicht. '
        + 'Entweder wurde er nach dem Kopieren erneut erzeugt („Regenerate" macht den alten sofort ungültig), '
        + 'oder das Organisationskonto ist nicht freigeschaltet. Kein Fehler im Launcher oder auf diesem Server.';
    } else if (nurDateien && (nurDateien.status === 401 || nurDateien.status === 403)) {
      befund.urteil = 'Der Schlüssel gilt grundsätzlich, aber nicht für die Dateiabfrage. '
        + 'Das deutet auf einen Schlüssel, der nur für ein einzelnes Spiel gilt – für Minecraft-Modpacks '
        + 'wird der Organisationsschlüssel gebraucht.';
    } else befund.urteil = 'Gemischtes Bild – siehe die einzelnen Proben.';

    // Kurzfassung für den schnellen Blick
    befund.kurz = befund.proben.map((p) => `${p.name}: ${p.status ?? p.fehler}`);
    selftestErgebnis = befund;
    selftestZeit = Date.now();
    return sendeJson(res, 200, befund);
  }

  if (!darfNoch(absender(req))) return sendeJson(res, 429, { error: 'Zu viele Anfragen, bitte kurz warten.' });

  try {
    if (req.method === 'POST' && url.pathname === '/v1/mods/files') return await dateilisteAufloesen(req, res);
    if (req.method === 'GET' && url.pathname === '/v1/download') return await dateiDurchreichen(req, res, url);
    if (req.method === 'GET' && url.pathname === '/v1/mods/search') return await katalogAnfrage(res, url, '/mods/search', KATALOG_PARAMETER.suche);
    if (req.method === 'GET' && url.pathname === '/v1/categories') return await katalogAnfrage(res, url, '/categories', KATALOG_PARAMETER.kategorien);
    const modDateien = req.method === 'GET' && /^\/v1\/mods\/(\d{1,9})\/files$/.exec(url.pathname);
    if (modDateien) return await katalogAnfrage(res, url, '/mods/' + modDateien[1] + '/files', KATALOG_PARAMETER.dateien);
    sendeJson(res, 404, { error: 'Unbekannter Weg.' });
  } catch (err) {
    console.error('[Fehler]', err.message);
    if (!res.headersSent) sendeJson(res, 500, { error: 'Interner Fehler.' });
    else res.destroy();
  }
});

server.listen(PORT, HOST, () => {
  console.log(`AeroMC CurseForge-Weiterleitung läuft auf ${HOST}:${PORT}`);
  console.log(`  Ratenbegrenzung: ${LIMIT_PRO_MIN > 0 ? LIMIT_PRO_MIN + '/Minute je Absender' : 'aus'}`);
  // niemals die Token selbst ausgeben – Protokolle wandern schnell woanders hin
  console.log(`  Token verlangt : ${TOKENS.size ? 'ja (' + TOKENS.size + ' gültige)' : 'NEIN – offen für jeden (CF_PROXY_OFFEN=1)'}`);
  console.log(`  Proxy-Stufen   : ${PROXY_STUFEN} (${PROXY_STUFEN ? 'Absender aus X-Forwarded-For' : 'Absender aus der Verbindung'})`);
});

module.exports = { server, pruefeDownloadZiel, darfNoch, absender, ERLAUBTE_HOSTS };