/**
 * Bad-debt VAT reclaims routes — bad-debt-writeoff (wave-12).
 * Mounted at /api/bad-debt-reclaims in the main route index.
 *
 * GET  /api/bad-debt-reclaims?status=...&year=...  → paginated list with invoice + customer context
 * PATCH /api/bad-debt-reclaims/:id                 → update reclaim status / dates
 */
import { Hono } from 'hono'
import type { AppEnv } from '../types'
import { authMiddleware } from '../middleware/auth'
import { requirePermission } from '../middleware/guards'
import {
  createDb,
  listReclaims,
  patchReclaim,
  reclaimPatchInputSchema,
  WriteOffNotFoundError,
} from '@zync/db/queries'

export const badDebtReclaimsRoute = new Hono<AppEnv>()

badDebtReclaimsRoute.use('*', authMiddleware)

// GET /api/bad-debt-reclaims
badDebtReclaimsRoute.get(
  '/',
  requirePermission('invoices:read'),
  async (c) => {
    const session = c.get('session')
    if (!session || session.type !== 'user' || !session.tid) {
      return c.json({ error: 'Unauthorized' }, 401)
    }

    const query = c.req.query()
    const statusParam = query.status
    const statuses = statusParam
      ? statusParam.split(',').map((s) => s.trim()).filter(Boolean)
      : undefined
    const year = query.year ? parseInt(query.year, 10) : undefined
    const limit = Math.min(parseInt(query.limit ?? '20', 10), 100)
    const offset = parseInt(query.offset ?? '0', 10)

    const db = createDb(c.env)
    const result = await listReclaims(db, session.tid, { statuses, year, limit, offset })

    return c.json({
      items: result.items,
      total: result.total,
      limit,
      offset,
    }, 200)
  },
)

// PATCH /api/bad-debt-reclaims/:id
badDebtReclaimsRoute.patch(
  '/:id',
  requirePermission('invoices:write'),
  async (c) => {
    const session = c.get('session')
    if (!session || session.type !== 'user' || !session.tid) {
      return c.json({ error: 'Unauthorized' }, 401)
    }

    const reclaimId = c.req.param('id')
    const body = await c.req.json().catch(() => null)
    const parsed = reclaimPatchInputSchema.safeParse(body)
    if (!parsed.success) {
      return c.json({ error: 'Validation failed', issues: parsed.error.issues }, 400)
    }

    const db = createDb(c.env)

    try {
      const reclaim = await patchReclaim(db, session.tid, reclaimId, session.sub, parsed.data)
      return c.json(reclaim, 200)
    } catch (err) {
      if (err instanceof WriteOffNotFoundError) {
        return c.json({ error: 'Reclaim not found' }, 404)
      }
      throw err
    }
  },
)