import { describe, expect, it } from "vitest"

import {
  inspektionPrognose,
  kmProTagAusFahrten,
  letzterOelwechsel,
  meldungsPrognose,
  meldungsPrognoseEigenesIntervall,
  naechsterService,
  oelMeldungsPrognose,
  oelwechselPrognose,
} from "./service"
import type { Fahrzeug } from "./profilAdapter"

function fahrzeug(odo: number, modus = "hersteller"): Fahrzeug {
  return {
    fin: "",
    details: "",
    erstzulassung: "",
    hu: "",
    odo,
    odoBekannt: true,
    tankPct: 0,
    reichweite: null,
    batteriespannung: null,
    gesichert: null,
    sicherheitscheck: [],
    zuendung: null,
    standortLat: null,
    standortLon: null,
    standortZeit: null,
    oelwechselFaelligTs: null,
    oelwechselFaelligKm: null,
    inspektionFaelligTs: null,
    inspektionFaelligKm: null,
    smartdeal: { aktiv: false, laeuftAb: null },
    oel: { modus, km: 15000, monate: 12, herstellerKm: 30000, herstellerMonate: 24 },
    versicherung: {},
    steuer: { faellig: "" },
    reifen: { aktiv: "Sommer", anzugsmoment: null, wechsel: {}, sommer: {}, winter: {} },
    service: {},
    technik: {},
    ausstattung: [],
  }
}

const BUCH = [
  { datum: "2026-02-10", km: 40000, art: "Ölwechsel" },
  { datum: "2025-03-05", km: 25000, art: "Inspektion" },
]

describe("letzterOelwechsel", () => {
  it("findet den jüngsten Ölwechsel und ignoriert andere Arten", () => {
    expect(letzterOelwechsel(BUCH)?.datum).toBe("2026-02-10")
  })

  it("erkennt auch die Schreibweise ohne Umlaut", () => {
    expect(letzterOelwechsel([{ datum: "2026-01-01", km: 1, art: "Oelwechsel" }])).not.toBeNull()
  })

  it("liefert null, wenn nie einer eingetragen wurde", () => {
    expect(letzterOelwechsel([{ datum: "2026-01-01", km: 1, art: "Inspektion" }])).toBeNull()
  })
})

describe("oelwechselPrognose", () => {
  const jetzt = new Date("2026-08-11T12:00:00")

  it("rechnet ab dem letzten Ölwechsel, nicht ab dem ersten Buchungseintrag", () => {
    // Seit 10.02. sind 182 Tage vergangen, 6000 km gefahren -> rund 33 km/Tag.
    // Ziel ist 40000 + 30000 = 70000, offen sind also 24000 km.
    const p = oelwechselPrognose(fahrzeug(46000), BUCH, jetzt)
    expect(p).not.toBeNull()
    expect(p!.restKm).toBe(24000)
    expect(p!.kmProTag).toBeGreaterThan(30)
    expect(p!.kmProTag).toBeLessThan(36)
  })

  it("deckelt auf das Zeitlimit, wenn wenig gefahren wurde", () => {
    // Nur 100 km seit dem Wechsel: die Kilometerprognose läge Jahre entfernt,
    // das Zeitlimit von 24 Monaten greift vorher.
    const p = oelwechselPrognose(fahrzeug(40100), BUCH, jetzt)
    expect(p!.durchZeitlimit).toBe(true)
    expect(p!.datum).toBe("2028-02-10")
  })

  it("meldet Fälligkeit sofort, wenn das Intervall überschritten ist", () => {
    const p = oelwechselPrognose(fahrzeug(75000), BUCH, jetzt)
    expect(p!.restKm).toBe(0)
    expect(p!.datum).toBe("2026-08-11")
  })

  it("nutzt bei eigenem Intervall den kleineren der beiden Werte", () => {
    // modus "eigen": min(15000, 30000) = 15000 -> Ziel 55000, offen 9000.
    const p = oelwechselPrognose(fahrzeug(46000, "eigen"), BUCH, jetzt)
    expect(p!.restKm).toBe(9000)
  })

  it("liefert nichts ohne bekannten Kilometerstand", () => {
    const ohne = { ...fahrzeug(0), odoBekannt: false }
    expect(oelwechselPrognose(ohne, BUCH, jetzt)).toBeNull()
  })

  it("liefert nichts, wenn nie ein Ölwechsel eingetragen wurde", () => {
    expect(oelwechselPrognose(fahrzeug(46000), [], jetzt)).toBeNull()
  })
})

describe("inspektionPrognose", () => {
  const jetzt = new Date("2026-08-11T12:00:00")

  it("rechnet mit dem festen Intervall 30.000 km / 24 Monate, nicht dem Ölwechsel-Intervall", () => {
    // Letzte Inspektion 05.03.2025 bei 25000 km -> Ziel 55000. Bei 46000 km
    // sind das 9000 km offen, unabhängig vom oel-Feld des Fahrzeugs (15000/12).
    const p = inspektionPrognose(fahrzeug(46000), BUCH, jetzt)
    expect(p).not.toBeNull()
    expect(p!.restKm).toBe(9000)
  })

  it("ignoriert den Ölwechsel-Eintrag bei der Suche nach der letzten Inspektion", () => {
    expect(inspektionPrognose(fahrzeug(46000), [BUCH[0]!], jetzt)).toBeNull()
  })

  it("liefert nichts, wenn nie eine Inspektion eingetragen wurde", () => {
    expect(inspektionPrognose(fahrzeug(46000), [], jetzt)).toBeNull()
  })
})

describe("naechsterService", () => {
  const jetzt = new Date("2026-08-11T12:00:00")

  it("wählt über Ölwechsel und Inspektion hinweg das zeitlich frühere Datum", () => {
    // Beide unabhängig mit derselben Formel berechnet, statt ein erwartetes
    // Datum von Hand vorzurechnen - so bleibt der Test robust gegen spätere
    // Änderungen an den Intervallen, prüft aber trotzdem die Auswahllogik.
    const oel = oelwechselPrognose(fahrzeug(46000), BUCH, jetzt)
    const insp = inspektionPrognose(fahrzeug(46000), BUCH, jetzt)
    const erwarteteArt = oel!.datum <= insp!.datum ? "Ölwechsel" : "Inspektion"

    const s = naechsterService(fahrzeug(46000), BUCH, [], jetzt)
    expect(s).not.toBeNull()
    expect(s!.art).toBe(erwarteteArt)
    expect(s!.datum).toBe(erwarteteArt === "Ölwechsel" ? oel!.datum : insp!.datum)
  })

  it("nimmt die Hauptuntersuchung auf, obwohl sie keine eigene Prognose hat", () => {
    const f = { ...fahrzeug(46000), hu: "2026-09-01" }
    const s = naechsterService(f, [], [], jetzt)
    expect(s).not.toBeNull()
    expect(s!.art).toBe("Hauptuntersuchung")
    expect(s!.restKm).toBeNull()
    expect(s!.datum).toBe("2026-09-01")
  })

  it("liefert nichts ohne Servicebuch und ohne gepflegte Hauptuntersuchung", () => {
    expect(naechsterService(fahrzeug(46000), [], [], jetzt)).toBeNull()
  })

  it("fällt ohne Servicebucheintrag auf die vom Fahrzeug gemeldete Ölwechsel-Fälligkeit zurück", () => {
    // Ein frisch eingerichtetes Fahrzeug mit zugeordnetem Sensor, aber noch
    // ganz ohne Servicebuch, muss die Meldung trotzdem zeigen - siehe
    // AGENTS.md, Abschnitt H, "no inspektion and ölwechsel shown ...".
    const f = { ...fahrzeug(46000), oelwechselFaelligTs: "2027-03-14T00:00:00+00:00", oelwechselFaelligKm: 11750 }
    const s = naechsterService(f, [], [], jetzt)
    expect(s).not.toBeNull()
    expect(s!.art).toBe("Ölwechsel")
    expect(s!.datum).toBe("2027-03-14")
    expect(s!.restKm).toBe(11750)
  })

  it("fällt ohne Servicebucheintrag auf die vom Fahrzeug gemeldete Inspektions-Fälligkeit zurück", () => {
    const f = { ...fahrzeug(46000), inspektionFaelligTs: "2027-01-01T00:00:00+00:00", inspektionFaelligKm: 5000 }
    const s = naechsterService(f, [], [], jetzt)
    expect(s).not.toBeNull()
    expect(s!.art).toBe("Inspektion")
    expect(s!.datum).toBe("2027-01-01")
    expect(s!.restKm).toBe(5000)
  })

  it("bevorzugt die eigene Prognose gegenüber der Fahrzeugmeldung, wenn beide vorliegen", () => {
    // Servicebucheintrag vorhanden -> oelwechselPrognose() greift; die
    // Meldung (weit in der Zukunft) darf sie nicht verdrängen.
    const f = { ...fahrzeug(46000), oelwechselFaelligTs: "2099-01-01T00:00:00+00:00", oelwechselFaelligKm: 99999 }
    const oel = oelwechselPrognose(f, BUCH, jetzt)
    expect(oel).not.toBeNull()
    const s = naechsterService(f, BUCH, [], jetzt)
    expect(s!.datum).not.toBe("2099-01-01")
  })
})

describe("kmProTagAusFahrten", () => {
  const jetzt = new Date("2026-08-11T12:00:00")

  it("rechnet aus abgeschlossenen Fahrten seit der ältesten die km/Tag-Rate", () => {
    // Exakt 30 Tage vor jetzt (gleiche Uhrzeit), 900 km insgesamt -> 30 km/Tag.
    const fahrten = [
      { ts_start: "2026-07-12T12:00:00", distance_km: 400, status: "abgeschlossen" },
      { ts_start: "2026-08-01T08:00:00", distance_km: 500, status: "abgeschlossen" },
    ]
    expect(kmProTagAusFahrten(fahrten, jetzt)).toBeCloseTo(30, 5)
  })

  it("ignoriert offene Fahrten und Fahrten ohne bekannte Distanz", () => {
    const fahrten = [
      { ts_start: "2026-07-12T08:00:00", distance_km: 400, status: "abgeschlossen" },
      { ts_start: "2026-08-10T08:00:00", distance_km: null, status: "abgeschlossen" },
      { ts_start: "2026-08-11T08:00:00", distance_km: 9999, status: "offen" },
    ]
    // Nur die erste Fahrt zählt -> dieselbe Rate wie ohne die beiden anderen.
    expect(kmProTagAusFahrten(fahrten, jetzt)).toBe(
      kmProTagAusFahrten([fahrten[0]!], jetzt),
    )
  })

  it("liefert nichts ohne Fahrten oder ohne belastbaren Zeitraum", () => {
    expect(kmProTagAusFahrten([], jetzt)).toBeNull()
    expect(kmProTagAusFahrten([{ ts_start: jetzt.toISOString(), distance_km: 5, status: "abgeschlossen" }], jetzt))
      .toBeNull()
  })
})

describe("meldungsPrognose", () => {
  const jetzt = new Date("2026-08-11T12:00:00")
  // 30 km/Tag, siehe kmProTagAusFahrten-Tests oben.
  const fahrten = [
    { ts_start: "2026-07-12T12:00:00", distance_km: 400, status: "abgeschlossen" },
    { ts_start: "2026-08-01T08:00:00", distance_km: 500, status: "abgeschlossen" },
  ]

  it("rechnet die Restkilometer mit der Fahrleistung aus dem Fahrtenlog auf ein Datum hoch", () => {
    // 300 km Rest bei 30 km/Tag -> 10 Tage.
    const p = meldungsPrognose("2099-01-01T00:00:00+00:00", 300, fahrten, jetzt)
    expect(p).not.toBeNull()
    expect(p!.datum).toBe("2026-08-21")
    expect(p!.durchZeitlimit).toBe(false)
  })

  it("deckelt auf die vom Fahrzeug gemeldete Zeitgrenze, wenn zu wenig gefahren wird", () => {
    // 30000 km Rest bei 30 km/Tag läge Jahre in der Zukunft - die gemeldete
    // Zeitgrenze (fünf Tage später) greift zuerst.
    const p = meldungsPrognose("2026-08-16T00:00:00+00:00", 30000, fahrten, jetzt)
    expect(p).not.toBeNull()
    expect(p!.datum).toBe("2026-08-16")
    expect(p!.durchZeitlimit).toBe(true)
  })

  it("fällt ohne Fahrtenlog auf die reine Zeitgrenze der Meldung zurück", () => {
    const p = meldungsPrognose("2027-01-01T00:00:00+00:00", 5000, [], jetzt)
    expect(p).not.toBeNull()
    expect(p!.datum).toBe("2027-01-01")
    expect(p!.durchZeitlimit).toBe(true)
  })

  it("liefert nichts ohne jede brauchbare Angabe", () => {
    expect(meldungsPrognose(null, null, fahrten, jetzt)).toBeNull()
  })

  it("gibt die Restkilometer mit zurück", () => {
    const p = meldungsPrognose("2027-01-01T00:00:00+00:00", 5000, [], jetzt)
    expect(p!.restKm).toBe(5000)
  })
})

describe("meldungsPrognoseEigenesIntervall", () => {
  const jetzt = new Date("2026-08-11T12:00:00")
  // 30 km/Tag, siehe kmProTagAusFahrten-Tests oben.
  const fahrten = [
    { ts_start: "2026-07-12T12:00:00", distance_km: 400, status: "abgeschlossen" },
    { ts_start: "2026-08-01T08:00:00", distance_km: 500, status: "abgeschlossen" },
  ]

  it("rechnet Restkilometer und Zeitgrenze auf das eigene, kürzere Intervall um", () => {
    // Herstellermeldung: 25.000 km / 24 Monate Rest bis zum 2027-08-11 -
    // daraus ergibt sich ein angenommener letzter Service vor 2025-08-11.
    // Eigenes Intervall (15.000 km / 12 Monate) ab demselben Punkt: Zeit-
    // grenze 2026-08-11 (heute), Restkilometer 25000 - 30000 + 15000 = 10000.
    const p = meldungsPrognoseEigenesIntervall(
      "2027-08-11T00:00:00+00:00", 25000, 30000, 24, 15000, 12, fahrten, jetzt,
    )
    expect(p).not.toBeNull()
    expect(p!.restKm).toBe(10000)
    // 10.000 km bei 30 km/Tag läge weit in der Zukunft - die zurückgerechnete
    // eigene Zeitgrenze (heute) greift zuerst.
    expect(p!.durchZeitlimit).toBe(true)
    expect(p!.datum).toBe("2026-08-11")
  })

  it("deckelt die Restkilometer bei null, wenn das eigene Intervall rechnerisch schon überschritten ist", () => {
    // Erst 10.000 von 30.000 km seit der Herstellerfälligkeit gefahren -
    // das kürzere eigene Intervall (15.000 km) ist rechnerisch längst fällig.
    const p = meldungsPrognoseEigenesIntervall(
      "2027-08-11T00:00:00+00:00", 10000, 30000, 24, 15000, 12, fahrten, jetzt,
    )
    expect(p).not.toBeNull()
    expect(p!.restKm).toBe(0)
    expect(p!.durchZeitlimit).toBe(false)
  })

  it("fällt ohne Fahrtenlog auf die zurückgerechnete eigene Zeitgrenze zurück", () => {
    const p = meldungsPrognoseEigenesIntervall(
      "2027-08-11T00:00:00+00:00", 25000, 30000, 24, 15000, 12, [], jetzt,
    )
    expect(p).not.toBeNull()
    expect(p!.datum).toBe("2026-08-11")
    expect(p!.durchZeitlimit).toBe(true)
  })

  it("liefert nichts ohne bekannte Herstellerintervall-Länge", () => {
    expect(
      meldungsPrognoseEigenesIntervall("2027-08-11T00:00:00+00:00", 25000, null, 24, 15000, 12, fahrten, jetzt),
    ).toBeNull()
  })
})

describe("oelMeldungsPrognose", () => {
  const jetzt = new Date("2026-08-11T12:00:00")
  const fahrten = [
    { ts_start: "2026-07-12T12:00:00", distance_km: 400, status: "abgeschlossen" },
    { ts_start: "2026-08-01T08:00:00", distance_km: 500, status: "abgeschlossen" },
  ]

  it("übernimmt bei Herstellervorgabe unverändert die reine Fahrzeugmeldung", () => {
    const f = fahrzeug(10000, "hersteller")
    f.oelwechselFaelligTs = "2027-08-11T00:00:00+00:00"
    f.oelwechselFaelligKm = 25000
    const p = oelMeldungsPrognose(f, fahrten, jetzt)
    expect(p!.restKm).toBe(25000)
    expect(p!.datum).toBe("2027-08-11")
  })

  it("rechnet bei eigenem Intervall auf dessen kürzere Vorgabe um", () => {
    const f = fahrzeug(10000, "eigen")
    f.oelwechselFaelligTs = "2027-08-11T00:00:00+00:00"
    f.oelwechselFaelligKm = 25000
    const p = oelMeldungsPrognose(f, fahrten, jetzt)
    expect(p!.restKm).toBe(10000)
    expect(p!.datum).toBe("2026-08-11")
  })

  it("fällt bei eigenem Intervall ohne Herstellerwerte auf die reine Meldung zurück", () => {
    const f = fahrzeug(10000, "eigen")
    f.oel.herstellerKm = null
    f.oelwechselFaelligTs = "2027-08-11T00:00:00+00:00"
    f.oelwechselFaelligKm = 25000
    const p = oelMeldungsPrognose(f, fahrten, jetzt)
    expect(p!.restKm).toBe(25000)
    expect(p!.datum).toBe("2027-08-11")
  })
})