import { FastifyInstance } from "fastify"
import {
    stafftimeentries,
    stafftimenetryconnects
} from "../../../db/schema"
import {
    eq,
    and,
    gte,
    lte,
    desc
} from "drizzle-orm"

export default async function staffTimeRoutes(server: FastifyInstance) {

    // -------------------------------------------------------------
    // ▶ Neue Zeit starten
    // -------------------------------------------------------------
    server.post("/staff/time", async (req, reply) => {
        try {
            const { user_id, ...rest } = req.body as any
            const userId = req.user.user_id
            const tenantId = req.user.tenant_id

            const newEntry = {
                tenant_id: tenantId,
                user_id: user_id || userId,
                ...rest
            }

            const [created] = await server.db
                .insert(stafftimeentries)
                .values(newEntry)
                .returning()

            return created
        } catch (err: any) {
            console.error(err)
            return reply.code(400).send({ error: err.message })
        }
    })

    // -------------------------------------------------------------
    // ▶ Zeit stoppen
    // -------------------------------------------------------------
    server.put("/staff/time/:id/stop", async (req, reply) => {
        try {
            const { id } = req.params as any
            const { stopped_at } = req.body as any

            const [updated] = await server.db
                .update(stafftimeentries)
                .set({
                    stopped_at,
                    updated_at: new Date()
                })
                .where(eq(stafftimeentries.id, id))
                .returning()

            return updated
        } catch (err) {
            return reply.code(400).send({ error: (err as Error).message })
        }
    })

    // -------------------------------------------------------------
    // ▶ Liste aller Zeiten
    // -------------------------------------------------------------
    server.get("/staff/time", async (req, reply) => {
        try {
            const { from, to, type, user_id } = req.query as any
            const { tenant_id, user_id: currentUserId } = req.user

            let where = and(eq(stafftimeentries.tenant_id, tenant_id))

            // Zugriffsbeschränkung
            if (!req.hasPermission("staff.time.read_all")) {
                where = and(where, eq(stafftimeentries.user_id, currentUserId))
            } else if (user_id) {
                where = and(where, eq(stafftimeentries.user_id, user_id))
            }

            if (from) where = and(where, gte(stafftimeentries.started_at, from))
            if (to) where = and(where, lte(stafftimeentries.started_at, to))
            if (type) where = and(where, eq(stafftimeentries.type, type))

            const rows = await server.db
                .select()
                .from(stafftimeentries)
                .where(where)
                .orderBy(desc(stafftimeentries.started_at))

            return rows
        } catch (err) {
            console.error(err)
            return reply.code(400).send({ error: (err as Error).message })
        }
    })

    // -------------------------------------------------------------
    // ▶ Einzelne Zeit (inkl. Connects)
    // -------------------------------------------------------------
    server.get("/staff/time/:id", async (req, reply) => {
        try {
            const { id } = req.params as any

            const rows = await server.db
                .select()
                .from(stafftimeentries)
                .where(eq(stafftimeentries.id, id))
                .limit(1)

            if (!rows.length) return reply.code(404).send({ error: "Not found" })

            const entry = rows[0]

            const connects = await server.db
                .select()
                .from(stafftimenetryconnects)
                .where(eq(stafftimenetryconnects.stafftimeentry, id))

            return {
                ...entry,
                staff_time_entry_connects: connects
            }
        } catch (err) {
            return reply.code(400).send({ error: (err as Error).message })
        }
    })

    // -------------------------------------------------------------
    // ▶ Zeit bearbeiten
    // -------------------------------------------------------------
    server.put("/staff/time/:id", async (req, reply) => {
        try {
            const { id } = req.params as any


            const updateData = {
                // @ts-ignore
                ...req.body,
                updated_at: new Date()
            }

            const [updated] = await server.db
                .update(stafftimeentries)
                .set(updateData)
                .where(eq(stafftimeentries.id, id))
                .returning()

            return updated
        } catch (err) {
            return reply.code(400).send({ error: (err as Error).message })
        }
    })

    // -------------------------------------------------------------
    // ▶ Zeit löschen
    // -------------------------------------------------------------
    server.delete("/staff/time/:id", async (req, reply) => {
        try {
            const { id } = req.params as any

            await server.db
                .delete(stafftimeentries)
                .where(eq(stafftimeentries.id, id))

            return { success: true }
        } catch (err) {
            return reply.code(400).send({ error: (err as Error).message })
        }
    })
}