FEDEO/composables/useStaffTime.ts

import { defineStore } from 'pinia'
import { useAuthStore } from '~/stores/auth'

export const useStaffTime = () => {
    const { $api, $dayjs } = useNuxtApp()
    const auth = useAuthStore()

    /**
     * Lädt die Zeitspannen (Spans) für die Liste.
     * Nutzt jetzt GET /api/staff/time/spans
     */
    const list = async (filter?: { user_id?: string, from?: string, to?: string }) => {
        // Standard: Aktueller Monat
        const from = filter?.from || $dayjs().startOf('month').format('YYYY-MM-DD')
        const to = filter?.to || $dayjs().endOf('month').format('YYYY-MM-DD')

        // Ziel-User: Entweder aus Filter (Admin-Ansicht) oder eigener User
        const targetUserId = filter?.user_id || auth.user.id

        const params = new URLSearchParams({
            from,
            to,
            // Der Endpoint erwartet targetUserId, wenn man Daten eines anderen Users will
            targetUserId
        })

        try {
            // 💡 UPDATE: Prefix /api hinzugefügt
            const spans = await $api(`/api/staff/time/spans?${params.toString()}`)

            return (spans || []).map((span: any) => {
                const start = $dayjs(span.startedAt)
                // Wenn endedAt null ist, läuft die Zeit noch -> Dauer bis "jetzt" berechnen für Anzeige
                const end = span.endedAt ? $dayjs(span.endedAt) : $dayjs()
                const duration = end.diff(start, 'minute')

                return {
                    // ID: Wir nehmen die erste Event-ID (Start-Event) als Referenz für Aktionen
                    id: span.sourceEventIds && span.sourceEventIds.length > 0 ? span.sourceEventIds[0] : null,

                    // Mapping Backend-Status -> Frontend-State
                    state: span.status,

                    // Zeitstempel
                    started_at: span.startedAt,
                    stopped_at: span.endedAt,

                    duration_minutes: duration,

                    // Da der Endpoint nur die Spans zurückgibt, setzen wir die UserID
                    // auf den User, den wir angefragt haben.
                    user_id: targetUserId,

                    type: span.type,

                    // Payload/Description falls vorhanden
                    description: span.payload?.description || ''
                }
            }).sort((a: any, b: any) => $dayjs(b.started_at).valueOf() - $dayjs(a.started_at).valueOf()) // Sortierung: Neueste oben

        } catch (error) {
            console.error("Fehler beim Laden der Zeiten:", error)
            return []
        }
    }

    /**
     * Startet einen neuen Zeiteintrag.
     * POST /api/staff/time/event
     */
    const start = async (description = "Arbeitszeit") => {
        try {
            // 💡 UPDATE: Prefix /api hinzugefügt
            await $api('/api/staff/time/event', {
                method: 'POST',
                body: {
                    eventtype: 'work_start',
                    eventtime: new Date().toISOString(),
                    payload: { description }
                }
            })
        } catch (error) {
            console.error("Fehler beim Starten:", error)
            throw error
        }
    }

    /**
     * Stoppt die aktuelle Zeit.
     * POST /api/staff/time/event
     */
    const stop = async (entryId?: string) => {
        try {
            // 💡 UPDATE: Prefix /api hinzugefügt
            await $api('/api/staff/time/event', {
                method: 'POST',
                body: {
                    eventtype: 'work_end',
                    eventtime: new Date().toISOString()
                }
            })
        } catch (error) {
            console.error("Fehler beim Stoppen:", error)
            throw error
        }
    }

    /**
     * Reicht einen Eintrag ein.
     * POST /api/staff/time/submit
     */
    const submit = async (entryId: string) => {
        if (!entryId) return
        try {
            // 💡 UPDATE: Prefix /api hinzugefügt
            await $api('/api/staff/time/submit', {
                method: 'POST',
                body: {
                    eventIds: [entryId]
                }
            })
        } catch (error) {
            console.error("Fehler beim Einreichen:", error)
            throw error
        }
    }

    /**
     * Genehmigt einen Eintrag.
     * POST /api/staff/time/approve
     */
    const approve = async (entry: any) => {
        if (!entry || !entry.id || !entry.user_id) {
            console.error("Ungültiger Eintrag für Genehmigung (ID oder UserID fehlt)", entry)
            return
        }

        try {
            // 💡 UPDATE: Prefix /api hinzugefügt
            await $api('/api/staff/time/approve', {
                method: 'POST',
                body: {
                    eventIds: [entry.id],
                    employeeUserId: entry.user_id
                }
            })
        } catch (error) {
            console.error("Fehler beim Genehmigen:", error)
            throw error
        }
    }

    return {
        list,
        start,
        stop,
        submit,
        approve
    }
}