/*
 * Pruefungen fuer die Postfachanbindung: `npm test` im Verzeichnis server/.
 *
 * Absichtlich ohne Test-Framework - reines Node, kein zusaetzliches Paket. Es
 * geht um zwei Teile, die unbeaufsichtigt laufen und sich von Hand kaum pruefen
 * lassen:
 *
 *   1. extract.js  - was aus einer Mail als Kontakt herausfaellt. Fehler hier
 *                    landen still in der Kontaktliste.
 *   2. graph.js    - Token, Wiederholungen, Fehlerbehandlung. Der echte Dienst
 *                    liefert 429 und 401 erst dann, wenn es unpassend ist.
 *
 * Alles, was eine Datenbank braucht (store.js, contacts.js, sync.js), ist hier
 * nicht abgedeckt.
 */

process.env.MS_TENANT_ID ||= 'test-tenant';
process.env.MS_CLIENT_ID ||= 'test-client';
process.env.MS_CLIENT_SECRET ||= 'test-secret';
process.env.MS_MAILBOX ||= 'crm@perinco.de';

const { htmlToText, sanitizeHtml } = await import('../src/mail/html.js');
const { extractCandidates, parsePersonName, parseSignature, isFunctionalAddress } = await import(
  '../src/mail/extract.js'
);
const { accessToken, graphRequest, resetTokenCache, testConnection, GraphError, mailboxPath } =
  await import('../src/mail/graph.js');

let failures = 0;
let currentGroup = '';

function group(name) {
  currentGroup = name;
  console.log(`\n${name}`);
}

function check(name, condition, detail = '') {
  if (condition) {
    console.log(`  ok   ${name}${detail ? ` - ${detail}` : ''}`);
  } else {
    console.log(`  FAIL ${name}${detail ? ` - ${detail}` : ''}`);
    failures += 1;
  }
}

const OPTIONS = {
  internalDomains: ['perinco.de', 'perinco.onmicrosoft.com'],
  mailbox: 'crm@perinco.de',
};

const byEmail = (candidates, email) => candidates.find((entry) => entry.email === email);
const byName = (candidates, name) =>
  candidates.find((entry) => [entry.firstName, entry.lastName].filter(Boolean).join(' ') === name);

// ---------------------------------------------------------------------------
group('HTML in Text');

const outlookHtml = `<html><head><style>p{margin:0}</style></head><body>
<div>Hallo Herr Wolf,</div><div><br></div>
<div>vielen Dank f&uuml;r das Gespr&auml;ch.</div><div><br></div>
<div>Mit freundlichen Gr&uuml;&szlig;en</div>
<table><tr><td>Dr. Michael Wagner<br>Head of IT Sourcing<br>
Beispiel Consulting GmbH<br>Musterstra&szlig;e 12a<br>60311 Frankfurt am Main<br>
Tel.: +49 69 1234-567<br>Mobil: +49 171 9876543<br>
michael.wagner@beispiel-consulting.de<br>
<a href="https://www.linkedin.com/in/mwagner">LinkedIn</a></td></tr></table>
</body></html>`;

const text = htmlToText(outlookHtml);
check('Zeilenumbrueche bleiben erhalten', text.split('\n').length > 5, `${text.split('\n').length} Zeilen`);
check('Style-Block ist entfernt', !text.includes('margin:0'));
check('Entitaeten sind aufgeloest', text.includes('Grüßen') && text.includes('Musterstraße'));
check(
  'Linkziel steht hinter dem Linktext',
  text.includes('LinkedIn (https://www.linkedin.com/in/mwagner)')
);
check('Keine drei Leerzeilen in Folge', !/\n\s*\n\s*\n/.test(text));

const dirty = `<div onclick="steal()">Text</div><script>alert(1)</script>
<iframe src="https://evil.example"></iframe><a href="javascript:alert(1)">Klick</a>`;
const clean = sanitizeHtml(dirty);
check('Skript ist entfernt', !clean.includes('<script') && !clean.includes('alert(1)</script'));
check('Rahmen ist entfernt', !clean.toLowerCase().includes('<iframe'));
check('Ereignis-Attribut ist entfernt', !clean.includes('onclick'));
check('javascript:-Adresse ist entfernt', !clean.includes('javascript:'));
check('Nutzinhalt bleibt', clean.includes('Text'));

// ---------------------------------------------------------------------------
group('Namen zerlegen');

const nameCases = [
  ['Dr. Michael Wagner', 'm.wagner@x.de', 'Michael', 'Wagner'],
  ['Wolf, Sascha', null, 'Sascha', 'Wolf'],
  ['Sascha van der Berg', null, 'Sascha', 'van der Berg'],
  ['Prof. Dr. Klaus Meier, MBA', null, 'Klaus', 'Meier'],
  ['Wagner, Michael (Beispiel Consulting)', null, 'Michael', 'Wagner'],
  [null, 'anna.mueller@x.de', 'Anna', 'Mueller'],
  ['sascha.wolf@perinco.de', 'sascha.wolf@perinco.de', 'Sascha', 'Wolf'],
];

for (const [display, email, expectedFirst, expectedLast] of nameCases) {
  const parsed = parsePersonName(display, email);
  check(
    `${display ?? '(kein Anzeigename)'} + ${email ?? '(keine Adresse)'}`,
    parsed.firstName === expectedFirst && parsed.lastName === expectedLast,
    `${parsed.firstName} / ${parsed.lastName}`
  );
}

// Umlaut aus dem Anzeigenamen schlaegt die Umschrift aus der Adresse.
const umlaut = parsePersonName('Müller', 'k.mueller@x.de');
check('Umlaut des Anzeigenamens gewinnt', umlaut.lastName === 'Müller', umlaut.lastName ?? '-');

check('Anrede wird erkannt', parsePersonName('Herr Klaus Meier').salutation === 'Herr');
check('Funktionsadresse wird erkannt', isFunctionalAddress('info@x.de') && isFunctionalAddress('no-reply@x.de'));
check('Personenadresse gilt nicht als Funktionsadresse', !isFunctionalAddress('anna.mueller@x.de'));

// ---------------------------------------------------------------------------
group('Signatur lesen');

const signature = parseSignature(text);
check('Festnetz trotz "Tel.:"', signature.phone === '+49 69 1234-567', signature.phone ?? '-');
check('Mobil getrennt erkannt', signature.mobile === '+49 171 9876543', signature.mobile ?? '-');
check('Firma an der Rechtsform', signature.company === 'Beispiel Consulting GmbH', signature.company ?? '-');
check('Position erkannt', signature.position === 'Head of IT Sourcing', signature.position ?? '-');
check('Strasse erkannt', signature.street === 'Musterstraße 12a', signature.street ?? '-');
check('Ort mit Zusatz', signature.city === 'Frankfurt am Main', signature.city ?? '-');
check('PLZ erkannt', signature.zip === '60311', signature.zip ?? '-');
check('LinkedIn erkannt', signature.linkedin === 'https://www.linkedin.com/in/mwagner', signature.linkedin ?? '-');

// ---------------------------------------------------------------------------
group('Kontakte aus einer Mail');

const external = extractCandidates(
  {
    fromName: 'Wagner, Michael (Beispiel Consulting)',
    fromEmail: 'Michael.Wagner@beispiel-consulting.de',
    to: [{ name: 'Sascha Wolf', email: 'sascha.wolf@perinco.de' }],
    cc: [{ name: null, email: 'crm@perinco.de' }],
    bcc: [],
    bodyText: text,
  },
  OPTIONS
);

check('genau ein Vorschlag', external.length === 1, `${external.length}`);
const wagner = byEmail(external, 'michael.wagner@beispiel-consulting.de');
check('Absender gefunden', Boolean(wagner));
check('Signatur bestaetigt den Absender', wagner?.confidence === 95, String(wagner?.confidence));
check('Firma uebernommen', wagner?.company === 'Beispiel Consulting GmbH');
check('Eigene Domain wird uebersprungen', !byEmail(external, 'sascha.wolf@perinco.de'));
check('Postfach selbst wird uebersprungen', !byEmail(external, 'crm@perinco.de'));

// Interne Mail mit dem CRM auf Cc: die externen Empfaenger sind die Kontakte.
const carbonCopy = extractCandidates(
  {
    fromName: 'Sascha Wolf',
    fromEmail: 'sascha.wolf@perinco.de',
    to: [
      { name: 'Anna Müller', email: 'a.mueller@kunde-ag.de' },
      { name: null, email: 'thomas.schmidt@kunde-ag.de' },
    ],
    cc: [
      { name: 'CRM', email: 'crm@perinco.de' },
      { name: 'Info', email: 'info@kunde-ag.de' },
    ],
    bcc: [],
    bodyText: 'Hallo zusammen,\n\nanbei das Angebot.\n\nViele Grüße\nSascha Wolf\nCEO\nperinco GmbH',
  },
  OPTIONS
);

check('beide externen Empfaenger', carbonCopy.length === 2, `${carbonCopy.length}`);
check('Anzeigename genutzt', byEmail(carbonCopy, 'a.mueller@kunde-ag.de')?.lastName === 'Müller');
check('Name aus der Adresse abgeleitet', byEmail(carbonCopy, 'thomas.schmidt@kunde-ag.de')?.firstName === 'Thomas');
check('Funktionsadresse verworfen', !byEmail(carbonCopy, 'info@kunde-ag.de'));
check(
  'Empfaenger duerfen automatisch uebernommen werden',
  carbonCopy.every((entry) => entry.confidence >= 70)
);

// Automat: darf nichts liefern.
const automated = extractCandidates(
  {
    fromName: 'freelancermap Newsletter',
    fromEmail: 'no-reply@news.freelancermap.de',
    to: [{ name: null, email: 'crm@perinco.de' }],
    cc: [],
    bcc: [],
    bodyText: 'Neue Projekte für Sie.\n\nAbmelden: https://news.freelancermap.de/unsubscribe',
  },
  OPTIONS
);
check('Automat liefert keinen Kontakt', automated.length === 0, `${automated.length}`);

// Personen im Fliesstext - nur mit Anrede, und nie automatisch.
const mentioned = extractCandidates(
  {
    fromName: 'Petra Klein',
    fromEmail: 'p.klein@vermittler.de',
    to: [{ name: null, email: 'crm@perinco.de' }],
    cc: [],
    bcc: [],
    bodyText:
      'Guten Tag,\n\nbitte melden Sie sich bei Herrn Max Mustermann Tel. 0221/3456789.\n' +
      'Zweiter Ansprechpartner ist Frau Julia Berg, 0170 1122334.\n' +
      'Das Angebot Neue Leistung Zwei liegt bei 0221/111111.\n\n' +
      'Mit freundlichen Grüßen\nPetra Klein\nVermittler GmbH\nTel: 030/998877',
  },
  OPTIONS
);

check('Anrede-Treffer erkannt', Boolean(byName(mentioned, 'Max Mustermann') && byName(mentioned, 'Julia Berg')));
check('Beschriftung nicht im Namen', !mentioned.some((entry) => /Tel/.test(entry.lastName ?? '')));
check(
  'Wortfolge ohne Anrede wird nicht zum Kontakt',
  !byName(mentioned, 'Neue Leistung Zwei') && !byName(mentioned, 'Zweiter Ansprechpartner')
);
check(
  'Textfunde bleiben zur Durchsicht',
  mentioned.filter((entry) => entry.origin === 'text').every((entry) => entry.confidence < 70)
);
check('Absender behaelt seine Rufnummer', byEmail(mentioned, 'p.klein@vermittler.de')?.phone === '030/998877');

// ---------------------------------------------------------------------------
group('Graph-Client');

let calls = [];
let handlers = [];
const originalFetch = globalThis.fetch;

globalThis.fetch = async (url, options) => {
  calls.push({ url: String(url), method: options?.method ?? 'GET' });
  const handler = handlers.shift();
  if (!handler) throw new Error(`Kein Handler mehr fuer ${url}`);
  return typeof handler === 'function' ? handler(String(url), options) : handler;
};

const json = (status, body, headers = {}) =>
  new Response(JSON.stringify(body), {
    status,
    headers: { 'content-type': 'application/json', ...headers },
  });
const tokenOk = () => json(200, { access_token: 'TOKEN-A', expires_in: 3600 });
const networkError = () => {
  throw new TypeError('fetch failed');
};

function arrange(list) {
  calls = [];
  handlers = list;
  resetTokenCache();
}

arrange([tokenOk()]);
const first = await accessToken();
const second = await accessToken();
check('Token wird zwischengespeichert', calls.length === 1 && first === second, `${calls.length} Aufruf(e)`);

arrange([json(400, { error: 'invalid_client', error_description: 'AADSTS7000215: Invalid client secret provided.' })]);
try {
  await accessToken();
  check('Anmeldefehler wird gemeldet', false);
} catch (err) {
  check(
    'Anmeldefehler nennt den Grund',
    err instanceof GraphError && err.message.includes('AADSTS7000215'),
    err.message
  );
}

arrange([tokenOk(), json(429, { error: {} }, { 'retry-after': '0' }), json(200, { value: [1, 2] })]);
const throttled = await graphRequest('/users/x/messages');
check('429 wird wiederholt', throttled.value.length === 2 && calls.length === 3, `${calls.length} Aufruf(e)`);

arrange([tokenOk(), json(401, { error: { code: 'InvalidAuthenticationToken' } }), tokenOk(), json(200, { ok: true })]);
const renewed = await graphRequest('/users/x/messages');
check('401 holt ein neues Token', renewed.ok === true && calls.length === 4, `${calls.length} Aufruf(e)`);

arrange([
  tokenOk(),
  json(401, { error: { code: 'InvalidAuthenticationToken' } }),
  tokenOk(),
  json(401, { error: { code: 'InvalidAuthenticationToken', message: 'weg' } }),
]);
try {
  await graphRequest('/users/x/messages');
  check('Zweites 401 bricht ab', false);
} catch (err) {
  check('Zweites 401 bricht ab', err.status === 401 && calls.length === 4, `${calls.length} Aufruf(e)`);
}

arrange([tokenOk(), json(403, { error: { code: 'ErrorAccessDenied', message: 'Access is denied.' } })]);
try {
  await graphRequest('/users/x/messages');
  check('403 wird durchgereicht', false);
} catch (err) {
  check('403 wird nicht wiederholt', err.code === 'ErrorAccessDenied' && calls.length === 2, `${calls.length} Aufruf(e)`);
}

arrange([tokenOk(), json(200, { value: [] })]);
const deltaUrl = 'https://graph.microsoft.com/v1.0/users/x/messages/delta?$deltatoken=abc';
await graphRequest(deltaUrl);
check('Absolute Delta-URL bleibt unveraendert', calls[1].url === deltaUrl, calls[1].url);

check(
  'Postfachpfad kodiert die Adresse',
  mailboxPath('/messages') === '/users/crm%40perinco.de/messages',
  mailboxPath('/messages')
);

arrange([tokenOk(), json(403, { error: { code: 'ErrorAccessDenied', message: 'Access is denied.' } })]);
const denied = await testConnection();
check(
  'Test erkennt fehlende Berechtigung',
  denied.ok === false && denied.stage === 'mailbox' && denied.hint.includes('Mail.Read')
);

arrange([tokenOk(), json(200, { displayName: 'Posteingang', totalItemCount: 1842, unreadItemCount: 3 })]);
const granted = await testConnection();
check('Test bestaetigt Postfachzugriff', granted.ok === true && granted.totalItems === 1842);

arrange([tokenOk(), networkError, networkError, networkError, networkError]);
try {
  await graphRequest('/users/x/messages');
  check('Netzwerkfehler wird gemeldet', false);
} catch (err) {
  check('Netzwerkfehler wird gemeldet', err instanceof GraphError && err.status === 0, err.message);
}

globalThis.fetch = originalFetch;

// ---------------------------------------------------------------------------
console.log(
  failures === 0
    ? '\nAlle Pruefungen bestanden.'
    : `\n${failures} Pruefung(en) fehlgeschlagen (letzte Gruppe: ${currentGroup}).`
);
process.exit(failures === 0 ? 0 : 1);