const assert = require('node:assert/strict');
const http = require('node:http');
const test = require('node:test');

const { AgrarmonitorConnector, MemoryCookieStore, ZeitbuchungError } = require('../dist');

const loginPage = `
  <html>
    <head><title>Anmeldung - AGRARMONITOR</title></head>
    <body><form><input name="nonce" value="test-nonce" /><button>Einloggen</button></form></body>
  </html>
`;

// "dd.mm.yy (HH:MM)" -> "YYYY-MM-DD HH:MM"
function formularZuVergleich(wert) {
  const [, tag, monat, jahr, uhrzeit] = /^(\d{2})\.(\d{2})\.(\d{2}) \((\d{2}:\d{2})\)$/.exec(wert);
  return `20${jahr}-${monat}-${tag} ${uhrzeit}`;
}

/**
 * Nachbildung der Arbeitszeit-Endpunkte, so wie sie sich am 14.10.2026 im
 * echten Agrarmonitor verhalten haben (siehe docs/zeitbuchung-analyse.md).
 */
function createServer() {
  const requests = [];
  const state = { schichten: new Map(), verteilungen: new Map(), pausen: new Map() };
  let loggedIn = false;
  let naechsteId = 100;
  const neueId = () => (naechsteId += 1);

  const json = (res, status, data) => {
    res.writeHead(status, { 'Content-Type': 'application/json' });
    res.end(data === undefined ? '' : JSON.stringify(data));
  };
  const html = (res, body) => {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end(body);
  };
  const schichtAufraeumen = schichtId => {
    const leer = ![...state.verteilungen.values()].some(v => v.schichtId === schichtId);
    if (leer) {
      state.schichten.get(schichtId).deleted = true;
    }
    return leer;
  };

  const tagesansicht = (mitarbeiterId, datum) =>
    [...state.schichten.entries()]
      .filter(([, s]) => !s.deleted && s.mitarbeiterId === mitarbeiterId && s.datum === datum)
      .map(([schichtId]) => {
        const zeilen = [
          ...[...state.verteilungen.entries()]
            .filter(([, v]) => v.schichtId === schichtId)
            .map(([id, v]) => `<tr id="${id}" class=" betrieb "><td>${v.start.slice(11)} - ${v.ende.slice(11)}</td></tr>`),
          ...[...state.pausen.entries()]
            .filter(([, p]) => p.schichtId === schichtId)
            .map(([id, p]) => `<tr id="${id}" class="pause_betrieb text-orange"><td>${p.start.slice(11)} - ${p.ende.slice(11)}</td></tr>`),
        ];
        return `<table class="alternate verteilung_table table-fixed" id="verteilung_table_${schichtId}" data-schicht="${schichtId}"><tbody>${zeilen.join('')}</tbody></table>`;
      })
      .join('');

  // Buchbar sind nur aktive Taetigkeiten; 999 ist unbekannt.
  const taetigkeitAuswahl = ausgewaehlt => `
    <select name="taetigkeit_id" id="taetigkeit_id">
      <option value="870"${ausgewaehlt === '870' ? ' selected="selected"' : ''}>110 Arbeiten</option>
      <option value="869"${ausgewaehlt === '869' ? ' selected="selected"' : ''}>100 Reparatur</option>
    </select>`;

  const verteilungFormular = id => {
    const v = state.verteilungen.get(id);
    return `
      <form id="verteilung_form" data-id="${id}">
        <input type="text" name="timestamp_start" id="timestamp_start" value="">
        <input type="hidden" name="alte_taetigkeit_id" id="alte_taetigkeit_id" value="${v.taetigkeitId}">
        ${taetigkeitAuswahl(v.taetigkeitId)}
        <select name="projekt_id" id="projekt_id">
          <option value="0">Kein Projekt</option>
          <option value="12"${v.projektId === '12' ? ' selected="selected"' : ''}>Projekt</option>
        </select>
      </form>
      <form id="notiz-form">
        <textarea name="notizfeld" id="notizfeld"></textarea>
        <input type="text" name="verfasser_id" id="verfasser_id" value="6">
      </form>
      <table id="notizen_table"><tbody>
        ${v.notizen.map(n => `<tr data-id="${n.id}"><td>14.10.26 (11:15)</td><td>Connector</td><td class="notiz">${n.text.replace(/\n/g, '<br />\n')}</td></tr>`).join('')}
      </tbody></table>
    `;
  };

  const server = http.createServer((req, res) => {
    let body = '';
    req.on('data', chunk => {
      body += chunk;
    });
    req.on('end', () => {
      const url = new URL(req.url, 'http://localhost');
      const istJson = (req.headers['content-type'] ?? '').includes('application/json');
      const daten = istJson && body ? JSON.parse(body) : body;
      requests.push({ method: req.method, path: url.pathname, body: daten });

      if (req.method === 'POST' && url.pathname === '/login/api/login.php') {
        loggedIn = true;
        res.writeHead(200, { 'Content-Type': 'application/json', 'Set-Cookie': 'agrar_session=test; Path=/' });
        res.end(JSON.stringify({ success: true }));
        return;
      }

      if (!loggedIn) {
        html(res, loginPage);
        return;
      }

      const detail = /^\/arbeitszeit\/detail\/(\d+)\/(\d{4}-\d{2}-\d{2})$/.exec(url.pathname);

      if (detail) {
        html(res, `<html><body>${tagesansicht(Number(detail[1]), detail[2])}</body></html>`);
        return;
      }

      switch (url.pathname) {
        case '/':
          html(res, '<html><body>Mein AM</body></html>');
          return;

        case '/module/arbeitszeit/api/nachtragen-form.php':
          html(res, `<form id="nachtragen_form">${taetigkeitAuswahl('0')}</form>`);
          return;

        case '/module/arbeitszeit/api/getSchicht.php': {
          const id = Number(url.searchParams.get('schicht_id'));
          const s = state.schichten.get(id);
          json(res, 200, {
            id,
            mitarbeiter_id: s.mitarbeiterId,
            timestamp_start: `${s.start}:00`,
            // Laufende Schicht: Agrarmonitor liefert ein Null-Datum.
            timestamp_ende: s.ende === null ? '0000-00-00 00:00:00' : `${s.ende}:00`,
            ist_deleted: s.deleted ? 1 : 0,
          });
          return;
        }

        case '/module/arbeitszeit/api/nachtragen.php': {
          const params = new URLSearchParams(body);
          const datum = params.get('tage[]');
          const schichtId = neueId();
          const start = `${datum} ${params.get('form[arbeitszeit_start]')}`;
          const ende = `${datum} ${params.get('form[arbeitszeit_ende]')}`;
          state.schichten.set(schichtId, { mitarbeiterId: Number(params.get('form[mitarbeiter_id]')), datum, start, ende });
          const notiz = params.get('form[notiz]');
          state.verteilungen.set(neueId(), {
            schichtId,
            start,
            ende,
            taetigkeitId: params.get('form[taetigkeit_id]'),
            maschinenId: params.get('form[maschine_id]'),
            projektId: '0',
            notizen: notiz ? [{ id: neueId(), text: notiz }] : [],
          });
          json(res, 200, { action: 'link', target: 'arbeitszeit/plan' });
          return;
        }

        case '/module/arbeitszeit/api/editVerteilungForm.php': {
          let id = Number(daten.distributionID);
          if (daten.shiftID) {
            // Wie im echten System: Formular fuer "neu" legt sofort einen Platzhalter an.
            const s = state.schichten.get(daten.shiftID);
            id = neueId();
            state.verteilungen.set(id, {
              schichtId: daten.shiftID,
              start: s.start,
              ende: s.start,
              taetigkeitId: '0',
              maschinenId: '0',
              projektId: '0',
              notizen: [],
            });
          }
          html(res, state.verteilungen.has(id) ? verteilungFormular(id) : '');
          return;
        }

        case '/module/arbeitszeit/api/updateVerteilung.php': {
          const form = daten.verteilungForm;
          if (form.ganzertag === undefined) {
            json(res, 422, { verteilungForm: 'ganzertag must be present' });
            return;
          }
          if (form.maschine_id === '999') {
            json(res, 422, { verteilungForm: 'Maschine ungueltig' });
            return;
          }
          const v = state.verteilungen.get(Number(daten.verteilungId));
          Object.assign(v, {
            start: formularZuVergleich(form.timestamp_start),
            ende: formularZuVergleich(form.timestamp_ende),
            taetigkeitId: form.taetigkeit_id,
            maschinenId: form.maschine_id,
            projektId: form.projekt_id,
          });
          if (daten.notizForm.notizfeld) {
            v.notizen.push({ id: neueId(), text: daten.notizForm.notizfeld });
          }
          json(res, 200);
          return;
        }

        case '/module/arbeitszeit/api/deleteVerteilung.php': {
          const v = state.verteilungen.get(daten.distributionID);
          state.verteilungen.delete(daten.distributionID);
          json(res, 200, schichtAufraeumen(v.schichtId) ? { action: 'link', target: 'arbeitszeit' } : null);
          return;
        }

        case '/module/arbeitszeit/api/editPauseForm.php': {
          const s = state.schichten.get(daten.shiftID);
          const id = neueId();
          state.pausen.set(id, { schichtId: daten.shiftID, start: s.start, ende: s.ende });
          html(res, `<form id="pause_form" data-id="${id}"><input name="pause_start" id="timestamp_start"></form>`);
          return;
        }

        case '/module/arbeitszeit/api/updatePause.php': {
          const p = state.pausen.get(Number(daten.pause_id));
          p.start = formularZuVergleich(daten.pauseForm.pause_start);
          p.ende = formularZuVergleich(daten.pauseForm.pause_ende);
          json(res, 200, 0);
          return;
        }

        case '/module/arbeitszeit/api/deletePause.php':
          state.pausen.delete(daten.pauseID);
          json(res, 200, null);
          return;

        case '/module/arbeitszeit/api/updateSchicht.php': {
          const s = state.schichten.get(daten.shiftID);
          s.start = formularZuVergleich(daten.timestampStart);
          s.ende = daten.timestampEnd === '' ? null : formularZuVergleich(daten.timestampEnd);
          json(res, 200, true);
          return;
        }

        case '/module/auftraege/api/saveSchicht.php': {
          const id = neueId();
          const start = formularZuVergleich(daten.formdata.timestamp_start);
          state.schichten.set(id, {
            mitarbeiterId: daten.mitarbeiter_id,
            datum: start.slice(0, 10),
            start,
            ende: daten.formdata.timestamp_ende === '' ? null : formularZuVergleich(daten.formdata.timestamp_ende),
          });
          res.writeHead(200, { 'Content-Type': 'text/html' });
          res.end(String(id));
          return;
        }

        case '/module/arbeitszeit/api/deleteSchicht.php':
          state.schichten.get(daten.shiftID).deleted = true;
          json(res, 200, { action: 'link', target: 'arbeitszeit' });
          return;

        case '/module/notiz/api/delete.php':
          for (const v of state.verteilungen.values()) {
            v.notizen = v.notizen.filter(n => n.id !== daten.noteID);
          }
          json(res, 200, true);
          return;

        default:
          res.writeHead(404);
          res.end('not found');
      }
    });
  });

  return {
    server,
    requests,
    state,
    neueId,
    expireSession() {
      loggedIn = false;
    },
  };
}

async function startConnector(t) {
  const fake = createServer();

  await new Promise(resolve => fake.server.listen(0, '127.0.0.1', resolve));
  t.after(() => new Promise(resolve => fake.server.close(resolve)));

  const connector = new AgrarmonitorConnector({
    baseUrl: `http://127.0.0.1:${fake.server.address().port}`,
    username: 'demo',
    password: 'secret',
    cookieStore: new MemoryCookieStore(),
  });

  await connector.init();

  return { connector, ...fake };
}

/** Legt eine Schicht mit einer Verteilung an, wie nach einem ersten Nachtragen. */
function schichtAnlegen(state, neueId, { start = '2026-10-14 08:00', ende = '2026-10-14 09:00' } = {}) {
  const schichtId = neueId();
  const verteilungId = neueId();
  state.schichten.set(schichtId, { mitarbeiterId: 3309, datum: '2026-10-14', start, ende });
  state.verteilungen.set(verteilungId, {
    schichtId,
    start,
    ende,
    taetigkeitId: '870',
    maschinenId: '0',
    projektId: '12',
    notizen: [{ id: neueId(), text: 'Alte Notiz' }],
  });
  return { schichtId, verteilungId };
}

const posts = (requests, path) => requests.filter(r => r.method === 'POST' && r.path === path);
const schreibendePosts = requests =>
  requests.filter(r => r.method === 'POST' && r.path.startsWith('/module/') && !r.path.endsWith('Form.php'));

// 14.10.2026 ist Sommerzeit: 06:00Z = 08:00 Uhr in Berlin.
const block = (start, ende, extra = {}) => ({
  mitarbeiterId: 3309,
  start: new Date(start),
  ende: new Date(ende),
  taetigkeitId: 870,
  ...extra,
});

test('createZeitbuchung traegt ohne Schicht Schicht und Taetigkeit nach', async t => {
  const { connector, requests, state } = await startConnector(t);

  const { ref } = await connector.createZeitbuchung(
    block('2026-10-14T06:00:00Z', '2026-10-14T07:00:20Z', {
      maschinenId: 5033,
      notiz: 'Hydraulik abgedichtet',
      kostenstelle: '4711',
    })
  );

  const [nachtragen] = posts(requests, '/module/arbeitszeit/api/nachtragen.php');
  const params = new URLSearchParams(nachtragen.body);
  assert.equal(params.get('form[mitarbeiter_id]'), '3309');
  assert.equal(params.get('form[mitarbeitertyp]'), '1');
  assert.equal(params.get('form[taetigkeit_id]'), '870');
  assert.equal(params.get('form[maschine_id]'), '5033');
  assert.equal(params.get('form[arbeitszeit_start]'), '08:00');
  assert.equal(params.get('form[arbeitszeit_ende]'), '09:00', 'Sekunden werden auf die Minute gerundet');
  assert.equal(params.get('form[pause_start]'), '');
  assert.equal(params.get('form[uebernehmen]'), '1');
  assert.equal(params.get('form[notiz]'), 'Hydraulik abgedichtet\nKostenstelle: 4711');
  assert.deepEqual(params.getAll('tage[]'), ['2026-10-14']);

  const [[verteilungId, verteilung]] = [...state.verteilungen.entries()];
  assert.equal(ref, `verteilung:3309:2026-10-14:${verteilungId}`);
  assert.equal(verteilung.start, '2026-10-14 08:00');
  assert.equal(verteilung.ende, '2026-10-14 09:00');
});

test('createZeitbuchung bucht in die vorhandene Schicht und verlaengert sie', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);
  const { schichtId } = schichtAnlegen(state, neueId);

  const { ref } = await connector.createZeitbuchung(
    block('2026-10-14T07:00:00Z', '2026-10-14T08:00:00Z', { taetigkeitId: 869, maschinenId: 5033, notiz: 'Zweiter Block' })
  );

  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/editVerteilungForm.php')[0].body, {
    employeeID: 3309,
    date: '2026-10-14',
    shiftID: schichtId,
  });
  const verteilungId = Number(ref.split(':').at(-1));
  assert.equal(ref, `verteilung:3309:2026-10-14:${verteilungId}`);
  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/updateVerteilung.php')[0].body, {
    mitarbeiterId: 3309,
    verteilungId: String(verteilungId),
    verteilungForm: {
      timestamp_start: '14.10.26 (09:00)',
      timestamp_ende: '14.10.26 (10:00)',
      alte_taetigkeit_id: '0',
      taetigkeit_id: '869',
      ganzertag: '1',
      maschine_id: '5033',
      projekt_id: '0',
    },
    notizForm: { notizfeld: 'Zweiter Block', verfasser_id: '6' },
  });
  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/updateSchicht.php').map(r => r.body), [
    { shiftID: schichtId, timestampStart: '14.10.26 (08:00)', timestampEnd: '14.10.26 (10:00)' },
  ]);
  assert.equal(posts(requests, '/module/arbeitszeit/api/nachtragen.php').length, 0);
});

test('createZeitbuchung bucht eine Pause in die Schicht', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);
  const { schichtId } = schichtAnlegen(state, neueId);

  const { ref } = await connector.createZeitbuchung({
    art: 'pause',
    mitarbeiterId: 3309,
    start: new Date('2026-10-14T07:00:00Z'),
    ende: new Date('2026-10-14T07:30:00Z'),
  });

  const [[pauseId, pause]] = [...state.pausen.entries()];
  assert.equal(ref, `pause:3309:2026-10-14:${pauseId}`);
  assert.deepEqual(pause, { schichtId, start: '2026-10-14 09:00', ende: '2026-10-14 09:30' });
  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/updatePause.php')[0].body, {
    mitarbeiterId: 3309,
    pause_id: String(pauseId),
    pauseForm: { pause_start: '14.10.26 (09:00)', pause_ende: '14.10.26 (09:30)' },
    neu: 1,
  });
});

test('createZeitbuchung lehnt eine Pause ohne Schicht ab', async t => {
  const { connector, requests } = await startConnector(t);

  await assert.rejects(
    () =>
      connector.createZeitbuchung({
        art: 'pause',
        mitarbeiterId: 3309,
        start: new Date('2026-10-14T07:00:00Z'),
        ende: new Date('2026-10-14T07:30:00Z'),
      }),
    error => error instanceof ZeitbuchungError && /keine Schicht vorhanden/.test(error.message)
  );
  assert.equal(schreibendePosts(requests).length, 0);
});

test('createZeitbuchung meldet den Grund einer 422 und raeumt Platzhalter und Schicht auf', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);
  const { schichtId, verteilungId } = schichtAnlegen(state, neueId);

  await assert.rejects(
    () => connector.createZeitbuchung(block('2026-10-14T07:00:00Z', '2026-10-14T08:00:00Z', { maschinenId: 999 })),
    error =>
      error instanceof ZeitbuchungError &&
      error.status === 422 &&
      error.grund === 'Maschine ungueltig' &&
      /Buchung speichern fehlgeschlagen \(HTTP 422\): Maschine ungueltig/.test(error.message)
  );

  assert.deepEqual([...state.verteilungen.keys()], [verteilungId], 'Platzhalter wurde wieder geloescht');
  assert.equal(posts(requests, '/module/arbeitszeit/api/deleteVerteilung.php').length, 1);
  const schicht = state.schichten.get(schichtId);
  assert.deepEqual([schicht.start, schicht.ende], ['2026-10-14 08:00', '2026-10-14 09:00'], 'Schicht zurueckgesetzt');
});

test('createZeitbuchung ueber Mitternacht korrigiert Verteilung und Schicht nach dem Nachtragen', async t => {
  const { connector, requests, state } = await startConnector(t);

  await connector.createZeitbuchung(
    block('2026-10-14T21:30:00Z', '2026-10-14T22:30:00Z', { datum: '2026-10-14' })
  );

  const params = new URLSearchParams(posts(requests, '/module/arbeitszeit/api/nachtragen.php')[0].body);
  assert.equal(params.get('form[arbeitszeit_start]'), '23:30');
  assert.equal(params.get('form[arbeitszeit_ende]'), '23:59');

  const update = posts(requests, '/module/arbeitszeit/api/updateVerteilung.php')[0].body;
  assert.equal(update.verteilungForm.timestamp_start, '14.10.26 (23:30)');
  assert.equal(update.verteilungForm.timestamp_ende, '15.10.26 (00:30)');
  assert.equal(update.notizForm.notizfeld, '', 'Notiz nicht doppelt anlegen');

  const [schicht] = state.schichten.values();
  assert.deepEqual([schicht.start, schicht.ende], ['2026-10-14 23:30', '2026-10-15 00:30']);
});

// Im echten System gespeichert statt abgelehnt (Echttest 14.10.2026) - der Connector muss pruefen.
test('createZeitbuchung lehnt eine nicht buchbare Taetigkeit ab', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);

  await assert.rejects(
    () => connector.createZeitbuchung(block('2026-10-14T06:00:00Z', '2026-10-14T07:00:00Z', { taetigkeitId: 999 })),
    error => error instanceof ZeitbuchungError && error.grund === 'taetigkeit nicht buchbar'
  );
  assert.equal(posts(requests, '/module/arbeitszeit/api/nachtragen.php').length, 0, 'ohne Schicht nichts nachtragen');

  const { verteilungId } = schichtAnlegen(state, neueId);

  await assert.rejects(
    () => connector.createZeitbuchung(block('2026-10-14T07:00:00Z', '2026-10-14T08:00:00Z', { taetigkeitId: 999 })),
    error => error instanceof ZeitbuchungError && error.grund === 'taetigkeit nicht buchbar'
  );
  assert.equal(posts(requests, '/module/arbeitszeit/api/updateVerteilung.php').length, 0);
  assert.deepEqual([...state.verteilungen.keys()], [verteilungId], 'Platzhalter wurde wieder geloescht');

  await assert.rejects(
    () =>
      connector.updateZeitbuchung(
        `verteilung:3309:2026-10-14:${verteilungId}`,
        block('2026-10-14T06:00:00Z', '2026-10-14T07:00:00Z', { taetigkeitId: 999 })
      ),
    error => error instanceof ZeitbuchungError && error.grund === 'taetigkeit nicht buchbar'
  );
  assert.equal(posts(requests, '/module/arbeitszeit/api/updateVerteilung.php').length, 0);
});

test('updateZeitbuchung aendert die Verteilung und ersetzt die Notiz', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);
  const { verteilungId } = schichtAnlegen(state, neueId);
  const alteNotizId = state.verteilungen.get(verteilungId).notizen[0].id;

  await connector.updateZeitbuchung(
    `verteilung:3309:2026-10-14:${verteilungId}`,
    block('2026-10-14T06:00:00Z', '2026-10-14T06:45:00Z', { taetigkeitId: 869, maschinenId: 5033, notiz: 'Neue Notiz' })
  );

  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/updateVerteilung.php')[0].body, {
    mitarbeiterId: 3309,
    verteilungId: String(verteilungId),
    verteilungForm: {
      timestamp_start: '14.10.26 (08:00)',
      timestamp_ende: '14.10.26 (08:45)',
      alte_taetigkeit_id: '870',
      taetigkeit_id: '869',
      ganzertag: '1',
      maschine_id: '5033',
      projekt_id: '12',
    },
    notizForm: { notizfeld: 'Neue Notiz', verfasser_id: '6' },
  });
  assert.deepEqual(posts(requests, '/module/notiz/api/delete.php').map(r => r.body), [{ noteID: alteNotizId }]);
  assert.deepEqual(state.verteilungen.get(verteilungId).notizen.map(n => n.text), ['Neue Notiz']);
});

test('updateZeitbuchung laesst eine unveraenderte Notiz stehen', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);
  const { verteilungId } = schichtAnlegen(state, neueId);

  await connector.updateZeitbuchung(
    `verteilung:3309:2026-10-14:${verteilungId}`,
    block('2026-10-14T06:00:00Z', '2026-10-14T06:45:00Z', { notiz: 'Alte Notiz' })
  );

  assert.equal(posts(requests, '/module/arbeitszeit/api/updateVerteilung.php')[0].body.notizForm.notizfeld, '');
  assert.equal(posts(requests, '/module/notiz/api/delete.php').length, 0);
});

test('updateZeitbuchung aendert eine Pause', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);
  const { schichtId } = schichtAnlegen(state, neueId);
  const pauseId = neueId();
  state.pausen.set(pauseId, { schichtId, start: '2026-10-14 08:30', ende: '2026-10-14 08:45' });

  await connector.updateZeitbuchung(`pause:3309:2026-10-14:${pauseId}`, {
    art: 'pause',
    mitarbeiterId: 3309,
    start: new Date('2026-10-14T06:35:00Z'),
    ende: new Date('2026-10-14T06:50:00Z'),
  });

  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/updatePause.php')[0].body, {
    mitarbeiterId: 3309,
    pause_id: String(pauseId),
    pauseForm: { pause_start: '14.10.26 (08:35)', pause_ende: '14.10.26 (08:50)' },
    neu: 0,
  });
});

test('updateZeitbuchung lehnt ungueltige Referenzen und Wechsel von Art oder Tag ab', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);
  const { verteilungId } = schichtAnlegen(state, neueId);
  const daten = block('2026-10-14T06:00:00Z', '2026-10-14T06:45:00Z');

  await assert.rejects(() => connector.updateZeitbuchung('1180803', daten), ZeitbuchungError);
  await assert.rejects(
    () => connector.updateZeitbuchung(`pause:3309:2026-10-14:${verteilungId}`, daten),
    /Art der Buchung/
  );
  await assert.rejects(
    () => connector.updateZeitbuchung(`verteilung:3309:2026-10-13:${verteilungId}`, daten),
    /Arbeitstag/
  );
  await assert.rejects(
    () => connector.updateZeitbuchung(`verteilung:3309:2026-10-14:999999`, daten),
    /nicht gefunden/
  );
  assert.equal(schreibendePosts(requests).length, 0);
});

test('deleteZeitbuchung loescht Verteilung und Pause', async t => {
  const { connector, requests, state, neueId } = await startConnector(t);
  const { schichtId, verteilungId } = schichtAnlegen(state, neueId);
  const pauseId = neueId();
  state.pausen.set(pauseId, { schichtId, start: '2026-10-14 08:30', ende: '2026-10-14 08:45' });

  await connector.deleteZeitbuchung(`pause:3309:2026-10-14:${pauseId}`);
  await connector.deleteZeitbuchung(`verteilung:3309:2026-10-14:${verteilungId}`);

  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/deletePause.php')[0].body, {
    pauseID: pauseId,
    employeeID: 3309,
    date: '2026-10-14',
  });
  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/deleteVerteilung.php')[0].body, {
    distributionID: verteilungId,
    employeeID: 3309,
    date: '2026-10-14',
  });
  assert.equal(state.verteilungen.size, 0);
  assert.equal(state.pausen.size, 0);
});

test('createZeitbuchung prueft die Eingaben vor dem ersten Request', async t => {
  const { connector, requests } = await startConnector(t);
  const anzahlVorher = requests.length;

  await assert.rejects(
    () => connector.createZeitbuchung(block('2026-10-14T06:00:00Z', '2026-10-14T06:00:20Z')),
    /mindestens eine Minute/
  );
  await assert.rejects(
    () => connector.createZeitbuchung(block('2026-10-14T06:00:00Z', '2026-10-14T07:00:00Z', { taetigkeitId: 0 })),
    /Taetigkeits-ID/
  );
  assert.equal(requests.length, anzahlVorher);
});

test('createZeitbuchung meldet sich bei abgelaufener Session neu an', async t => {
  const { connector, requests, state, expireSession } = await startConnector(t);
  const logins = () => posts(requests, '/login/api/login.php').length;

  assert.equal(logins(), 1);
  expireSession();

  const { ref } = await connector.createZeitbuchung(block('2026-10-14T06:00:00Z', '2026-10-14T07:00:00Z'));

  assert.equal(logins(), 2, 'genau ein erneuter Login');
  assert.match(ref, /^verteilung:3309:2026-10-14:\d+$/);
  assert.equal(state.verteilungen.size, 1);
});

test('beginneArbeitstag legt eine laufende Schicht an und liefert die vorhandene bei Wiederholung', async t => {
  const { connector, requests, state } = await startConnector(t);

  const { ref } = await connector.beginneArbeitstag(3309, new Date('2026-10-14T04:58:40Z'));

  assert.deepEqual(posts(requests, '/module/auftraege/api/saveSchicht.php').map(r => r.body), [
    { vorgang_id: '-1', mitarbeiter_id: 3309, formdata: { timestamp_start: '14.10.26 (06:59)', timestamp_ende: '' } },
  ]);
  const [[schichtId, schicht]] = [...state.schichten.entries()];
  assert.equal(ref, `schicht:3309:2026-10-14:${schichtId}`);
  assert.equal(schicht.ende, null, 'Schicht laeuft');

  const wiederholt = await connector.beginneArbeitstag(3309, new Date('2026-10-14T04:58:40Z'));

  assert.equal(wiederholt.ref, ref);
  assert.equal(posts(requests, '/module/auftraege/api/saveSchicht.php').length, 1);
});

test('Pause und Taetigkeit in laufender Schicht lassen sie offen', async t => {
  const { connector, requests, state } = await startConnector(t);
  const { ref } = await connector.beginneArbeitstag(3309, new Date('2026-10-14T05:00:00Z'));
  const schichtId = Number(ref.split(':').at(-1));

  const pause = await connector.createZeitbuchung({
    art: 'pause',
    mitarbeiterId: 3309,
    start: new Date('2026-10-14T05:00:00Z'),
    ende: new Date('2026-10-14T05:15:00Z'),
  });
  assert.match(pause.ref, /^pause:3309:2026-10-14:\d+$/, 'Pause als erste Buchung des Tages');

  // Block beginnt vor der Schicht: Start wird vorgezogen, Ende bleibt offen.
  await connector.createZeitbuchung(block('2026-10-14T04:50:00Z', '2026-10-14T05:00:00Z'));

  assert.equal(posts(requests, '/module/arbeitszeit/api/nachtragen.php').length, 0);
  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/updateSchicht.php').map(r => r.body), [
    { shiftID: schichtId, timestampStart: '14.10.26 (06:50)', timestampEnd: '' },
  ]);
  assert.equal(state.schichten.get(schichtId).ende, null);
});

test('beendeArbeitstag, updateArbeitstag und deleteArbeitstag', async t => {
  const { connector, requests, state } = await startConnector(t);
  const { ref } = await connector.beginneArbeitstag(3309, new Date('2026-10-14T05:00:00Z'));
  const schichtId = Number(ref.split(':').at(-1));

  await connector.beendeArbeitstag(ref, new Date('2026-10-14T15:30:00Z'));
  await connector.updateArbeitstag(ref, { start: new Date('2026-10-14T04:45:00Z'), ende: null });

  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/updateSchicht.php').map(r => r.body), [
    { shiftID: schichtId, timestampStart: '14.10.26 (07:00)', timestampEnd: '14.10.26 (17:30)' },
    { shiftID: schichtId, timestampStart: '14.10.26 (06:45)', timestampEnd: '' },
  ]);

  await assert.rejects(
    () => connector.beendeArbeitstag(ref, new Date('2026-10-14T04:00:00Z')),
    error => error instanceof ZeitbuchungError && error.grund === 'dauer'
  );
  await assert.rejects(() => connector.beendeArbeitstag(`verteilung:3309:2026-10-14:${schichtId}`, new Date()), /Arbeitstag-Referenz/);

  await connector.deleteArbeitstag(ref);

  assert.deepEqual(posts(requests, '/module/arbeitszeit/api/deleteSchicht.php')[0].body, {
    shiftID: schichtId,
    employeeID: 3309,
    date: '2026-10-14',
  });
  assert.equal(state.schichten.get(schichtId).deleted, true);
  await assert.rejects(() => connector.beendeArbeitstag(ref, new Date('2026-10-14T15:30:00Z')), /nicht gefunden/);
});