FEDEO/frontend/pages/accounting/liquidity.vue

<script setup>
import dayjs from "dayjs"
import { Line } from "vue-chartjs"

const toast = useToast()
const tempStore = useTempStore()

const forecast = ref(null)
const rawForecast = ref(null)
const loading = ref(false)
const error = ref("")
const cacheLoaded = ref(false)

const CACHE_KEY = "fedeo:liquidityForecast:v1"

const dismissedRecurringKeys = computed(() => {
  return tempStore.settings?.liquidityForecast?.dismissedRecurringKeys || []
})

const storeDismissedRecurringKeys = (keys) => {
  tempStore.modifySettings("liquidityForecast", {
    ...(tempStore.settings?.liquidityForecast || {}),
    dismissedRecurringKeys: [...new Set(keys)].filter(Boolean)
  })
}

const sourceLabels = {
  open_createddocument: "Offene Ausgangsrechnung",
  open_incominginvoice: "Offener Eingangsbeleg",
  recurring_bankstatement: "Regelmäßige Bankbewegung"
}

const intervalLabels = {
  weekly: "wöchentlich",
  monthly: "monatlich",
  quarterly: "quartalsweise",
  yearly: "jährlich"
}

const roundMoney = (value) => Number(Number(value || 0).toFixed(2))

const saveForecastCache = (value) => {
  if (!import.meta.client || !value) return
  localStorage.setItem(CACHE_KEY, JSON.stringify({
    cachedAt: new Date().toISOString(),
    forecast: value
  }))
}

const readForecastCache = () => {
  if (!import.meta.client) return null

  try {
    const raw = localStorage.getItem(CACHE_KEY)
    return raw ? JSON.parse(raw) : null
  } catch (err) {
    return null
  }
}

const applyDismissedRecurring = (value) => {
  if (!value) return null

  const dismissed = new Set(dismissedRecurringKeys.value)
  const events = (value.events || []).filter((event) => {
    return event.source !== "recurring_bankstatement" || !event.recurringKey || !dismissed.has(event.recurringKey)
  })
  const recurring = (value.recurring || []).filter((item) => !item.key || !dismissed.has(item.key))
  const eventsByDate = new Map()

  events.forEach((event) => {
    if (!eventsByDate.has(event.date)) eventsByDate.set(event.date, [])
    eventsByDate.get(event.date).push(event)
  })

  let runningBalance = Number(value.startingBalance || 0)
  const points = (value.points || []).map((point) => {
    const dayEvents = [...(eventsByDate.get(point.date) || [])].sort((a, b) => Math.abs(b.amount) - Math.abs(a.amount))
    const income = roundMoney(dayEvents.filter((event) => event.amount > 0).reduce((sum, event) => sum + Number(event.amount || 0), 0))
    const expense = roundMoney(dayEvents.filter((event) => event.amount < 0).reduce((sum, event) => sum + Number(event.amount || 0), 0))

    runningBalance = roundMoney(runningBalance + income + expense)

    return {
      ...point,
      balance: runningBalance,
      income,
      expense,
      events: dayEvents
    }
  })

  const lowestPoint = points.reduce((lowest, point) => point.balance < lowest.balance ? point : lowest, points[0] || { balance: value.startingBalance, date: value.generatedAt })

  return {
    ...value,
    recurring,
    events,
    points,
    endingBalance: points[points.length - 1]?.balance || value.startingBalance,
    lowestBalance: lowestPoint?.balance || value.startingBalance,
    lowestBalanceDate: lowestPoint?.date || value.generatedAt,
    totalIncome: roundMoney(events.filter((event) => event.amount > 0).reduce((sum, event) => sum + Number(event.amount || 0), 0)),
    totalExpense: roundMoney(events.filter((event) => event.amount < 0).reduce((sum, event) => sum + Number(event.amount || 0), 0))
  }
}

const setRawForecast = (value) => {
  rawForecast.value = value
  forecast.value = applyDismissedRecurring(value)
}

const loadForecastFromCache = () => {
  const cached = readForecastCache()
  if (cached?.forecast) {
    setRawForecast({
      ...cached.forecast,
      cachedAt: cached.cachedAt
    })
  }

  cacheLoaded.value = true
}

const refreshForecast = async () => {
  loading.value = true
  error.value = ""

  try {
    const nextForecast = await useFunctions().useLiquidityForecast()
    saveForecastCache(nextForecast)
    setRawForecast({
      ...nextForecast,
      cachedAt: new Date().toISOString()
    })
    toast.add({
      title: "Prognose aktualisiert",
      description: "Das neue Ergebnis wurde zwischengespeichert.",
      color: "success"
    })
  } catch (err) {
    error.value = "Die Liquiditätsprognose konnte nicht neu erstellt werden."
    toast.add({
      title: "Fehler",
      description: error.value,
      color: "error"
    })
  } finally {
    loading.value = false
  }
}

const formatDate = (value) => dayjs(value).format("DD.MM.YYYY")

const getEventRoute = (event) => {
  if (event.source === "open_createddocument" && event.sourceId) return `/createDocument/show/${event.sourceId}`
  if (event.source === "open_incominginvoice" && event.sourceId) return `/incomingInvoices/show/${event.sourceId}`
  return null
}

const openEvent = (event) => {
  const route = getEventRoute(event)
  if (route) navigateTo(route)
}

const dismissRecurringKey = async (key) => {
  if (!key) return

  storeDismissedRecurringKeys([...dismissedRecurringKeys.value, key])
  forecast.value = applyDismissedRecurring(rawForecast.value)
  toast.add({
    title: "Bankbewegung abgeschlossen",
    description: "Das erkannte Muster wird aus der Liquiditätsprognose entfernt.",
    color: "success"
  })
}

const restoreDismissedRecurring = () => {
  storeDismissedRecurringKeys([])
  forecast.value = applyDismissedRecurring(rawForecast.value)
  toast.add({
    title: "Bankbewegungen wiederhergestellt",
    description: "Ausgeblendete Muster werden wieder in der Prognose berücksichtigt.",
    color: "success"
  })
}

const cachedAtLabel = computed(() => {
  const cachedAt = forecast.value?.cachedAt || forecast.value?.generatedAt
  return cachedAt ? formatDate(cachedAt) + " " + dayjs(cachedAt).format("HH:mm") : null
})

const chartData = computed(() => ({
  labels: (forecast.value?.points || []).map((point) => dayjs(point.date).format("DD.MM.")),
  datasets: [
    {
      label: "Prognostizierter Kontostand",
      borderColor: "#0f766e",
      backgroundColor: "rgba(15, 118, 110, 0.12)",
      pointRadius: 0,
      pointHitRadius: 8,
      tension: 0.28,
      fill: true,
      data: (forecast.value?.points || []).map((point) => point.balance)
    },
    {
      label: "Warnschwelle 0 €",
      borderColor: "#ef4444",
      borderDash: [6, 6],
      pointRadius: 0,
      data: (forecast.value?.points || []).map(() => 0)
    }
  ]
}))

const chartOptions = {
  responsive: true,
  maintainAspectRatio: false,
  interaction: {
    mode: "index",
    intersect: false
  },
  plugins: {
    legend: {
      display: true
    }
  },
  scales: {
    y: {
      ticks: {
        callback: (value) => useCurrency(Number(value))
      }
    }
  }
}

const upcomingEvents = computed(() => {
  return [...(forecast.value?.events || [])]
    .sort((a, b) => a.date.localeCompare(b.date) || Math.abs(b.amount) - Math.abs(a.amount))
    .slice(0, 18)
})

const riskTone = computed(() => {
  if (!forecast.value) return "neutral"
  if (forecast.value.lowestBalance < 0) return "danger"
  if (forecast.value.lowestBalance < forecast.value.startingBalance * 0.15) return "warning"
  return "positive"
})

watch(dismissedRecurringKeys, () => {
  forecast.value = applyDismissedRecurring(rawForecast.value)
})

onMounted(() => {
  loadForecastFromCache()
})
</script>

<template>
  <UDashboardNavbar title="Liquiditätsprognose" />

  <UDashboardToolbar>
    <div class="flex w-full flex-wrap items-center justify-between gap-3">
      <div class="text-sm text-gray-500">
        <span v-if="cachedAtLabel">Zwischengespeichert am {{ cachedAtLabel }}</span>
        <span v-else>Noch keine gespeicherte Prognose vorhanden</span>
      </div>

      <div class="flex flex-wrap items-center gap-2">
        <UButton
          v-if="dismissedRecurringKeys.length"
          icon="i-heroicons-eye"
          variant="ghost"
          @click="restoreDismissedRecurring"
        >
          Ausgeblendete wiederherstellen
        </UButton>

        <UButton
          icon="i-heroicons-arrow-path"
          :loading="loading"
          variant="soft"
          @click="refreshForecast"
        >
          Prognose neu erstellen
        </UButton>
      </div>
    </div>
  </UDashboardToolbar>

  <UDashboardPanelContent class="min-w-0 space-y-6 overflow-x-hidden overflow-y-auto p-4 md:p-6">
    <UAlert
      v-if="error"
      color="error"
      icon="i-heroicons-exclamation-triangle"
      :title="error"
    />

    <div v-if="loading" class="flex min-h-[360px] items-center justify-center text-sm text-gray-500">
      Liquiditätsprognose wird erstellt...
    </div>

    <UCard v-else-if="cacheLoaded && !forecast">
      <div class="flex min-h-[280px] flex-col items-center justify-center gap-4 text-center">
        <UIcon name="i-heroicons-chart-bar-square" class="size-12 text-gray-300" />
        <div>
          <h2 class="text-lg font-semibold">Noch keine Prognose gespeichert</h2>
          <p class="mt-1 max-w-xl text-sm text-gray-500">
            Erstelle die Liquiditätsprognose bewusst über den Refresh-Button. Das Ergebnis bleibt danach zwischengespeichert und wird beim nächsten Öffnen sofort angezeigt.
          </p>
        </div>
        <UButton icon="i-heroicons-arrow-path" :loading="loading" @click="refreshForecast">
          Prognose neu erstellen
        </UButton>
      </div>
    </UCard>

    <template v-else-if="forecast">
      <div class="grid gap-4 md:grid-cols-2 xl:grid-cols-4">
        <UCard>
          <p class="text-sm text-gray-500">Aktuelle Liquidität</p>
          <p class="mt-2 text-2xl font-semibold">{{ useCurrency(forecast.startingBalance) }}</p>
        </UCard>

        <UCard>
          <p class="text-sm text-gray-500">Prognose in {{ forecast.horizonDays }} Tagen</p>
          <p
            class="mt-2 text-2xl font-semibold"
            :class="forecast.endingBalance < 0 ? 'text-rose-600' : 'text-primary-600'"
          >
            {{ useCurrency(forecast.endingBalance) }}
          </p>
        </UCard>

        <UCard>
          <p class="text-sm text-gray-500">Niedrigster Stand</p>
          <p
            class="mt-2 text-2xl font-semibold"
            :class="forecast.lowestBalance < 0 ? 'text-rose-600' : 'text-orange-500'"
          >
            {{ useCurrency(forecast.lowestBalance) }}
          </p>
          <p class="mt-1 text-xs text-gray-500">{{ formatDate(forecast.lowestBalanceDate) }}</p>
        </UCard>

        <UCard>
          <p class="text-sm text-gray-500">KI-Erkennung</p>
          <p class="mt-2 text-2xl font-semibold">{{ forecast.recurring.length }}</p>
          <p class="mt-1 text-xs text-gray-500">
            {{ forecast.ai?.enabled ? `${forecast.ai.candidates} KI-Kandidaten berücksichtigt` : "Fallback ohne KI-Key genutzt" }}
          </p>
        </UCard>
      </div>

      <UAlert
        :color="riskTone === 'danger' ? 'error' : riskTone === 'warning' ? 'warning' : 'success'"
        :icon="riskTone === 'danger' ? 'i-heroicons-exclamation-triangle' : 'i-heroicons-chart-bar-square'"
        :title="riskTone === 'danger' ? 'Liquiditätsengpass möglich' : riskTone === 'warning' ? 'Liquidität wird knapp' : 'Liquidität bleibt positiv'"
        :description="`Die gespeicherte Prognose kombiniert aktuelle Kontostände, offene Belege und erkannte regelmäßige Bankbewegungen bis ${formatDate(dayjs().add(forecast.horizonDays, 'day'))}. Neu berechnet wird sie nur über den Refresh-Button.`"
      />

      <UCard>
        <template #header>
          <div class="flex flex-wrap items-center justify-between gap-2">
            <div>
              <h2 class="font-semibold">Liquiditätsverlauf</h2>
              <p class="text-sm text-gray-500">Täglicher prognostizierter Kontostand</p>
            </div>
            <div class="flex gap-3 text-sm">
              <span class="text-primary-600">+ {{ useCurrency(forecast.totalIncome) }}</span>
              <span class="text-rose-600">{{ useCurrency(forecast.totalExpense) }}</span>
            </div>
          </div>
        </template>

        <div class="h-[360px]">
          <Line :data="chartData" :options="chartOptions" />
        </div>
      </UCard>

      <div class="grid gap-4 xl:grid-cols-[minmax(0,1.2fr)_minmax(320px,0.8fr)]">
        <UCard>
          <template #header>
            <div>
              <h2 class="font-semibold">Nächste Zahlungsereignisse</h2>
              <p class="text-sm text-gray-500">Offene Belege und prognostizierte regelmäßige Bewegungen</p>
            </div>
          </template>

          <div v-if="upcomingEvents.length" class="divide-y divide-gray-200 dark:divide-gray-800">
            <div
              v-for="event in upcomingEvents"
              :key="`${event.source}-${event.sourceId || event.label}-${event.date}-${event.amount}`"
              class="grid gap-3 py-3 sm:grid-cols-[110px_minmax(0,1fr)_auto_auto]"
            >
              <span class="text-sm text-gray-500">{{ formatDate(event.date) }}</span>
              <div class="min-w-0">
                <p class="truncate font-medium">{{ event.label }}</p>
                <p class="text-xs text-gray-500">{{ sourceLabels[event.source] || event.source }}</p>
              </div>
              <span
                class="text-right font-semibold"
                :class="event.amount < 0 ? 'text-rose-600' : 'text-primary-600'"
              >
                {{ useCurrency(event.amount) }}
              </span>
              <div class="flex justify-end gap-1">
                <UButton
                  v-if="getEventRoute(event)"
                  size="xs"
                  variant="ghost"
                  icon="i-heroicons-arrow-top-right-on-square"
                  @click="openEvent(event)"
                >
                  Öffnen
                </UButton>
                <UButton
                  v-if="event.source === 'recurring_bankstatement' && event.recurringKey"
                  size="xs"
                  color="gray"
                  variant="ghost"
                  icon="i-heroicons-check-circle"
                  @click="dismissRecurringKey(event.recurringKey)"
                >
                  Abschließen
                </UButton>
              </div>
            </div>
          </div>

          <p v-else class="py-8 text-center text-sm text-gray-500">Keine Zahlungsereignisse im Prognosezeitraum erkannt.</p>
        </UCard>

        <UCard>
          <template #header>
            <div>
              <h2 class="font-semibold">Regelmäßige Bewegungen</h2>
              <p class="text-sm text-gray-500">Aus Bankumsätzen erkannt, inklusive KI-Analyse</p>
            </div>
          </template>

          <div v-if="forecast.recurring.length" class="space-y-3">
            <div
              v-for="item in forecast.recurring"
              :key="`${item.label}-${item.amount}-${item.nextDate}`"
              class="rounded-lg border border-gray-200 p-3 dark:border-gray-800"
            >
              <div class="flex items-start justify-between gap-3">
                <div class="min-w-0">
                  <p class="truncate font-medium">{{ item.label }}</p>
                  <p class="text-xs text-gray-500">
                    {{ intervalLabels[item.interval] || item.interval }} ab {{ formatDate(item.nextDate) }}
                  </p>
                </div>
                <span
                  class="text-right font-semibold"
                  :class="item.amount < 0 ? 'text-rose-600' : 'text-primary-600'"
                >
                  {{ useCurrency(item.amount) }}
                </span>
              </div>
              <div class="mt-2 flex flex-wrap items-center justify-between gap-2">
                <p class="text-xs text-gray-500">
                  Sicherheit {{ Math.round(item.confidence * 100) }}% · {{ item.evidence }}
                </p>
                <UButton
                  size="xs"
                  color="gray"
                  variant="soft"
                  icon="i-heroicons-check-circle"
                  @click="dismissRecurringKey(item.key)"
                >
                  Als abgeschlossen entfernen
                </UButton>
              </div>
            </div>
          </div>

          <p v-else class="py-8 text-center text-sm text-gray-500">Noch keine regelmäßigen Bewegungen erkannt.</p>
        </UCard>
      </div>
    </template>
  </UDashboardPanelContent>
</template>