/** HQ web ↔ hq-server client; token survives reloads via localStorage['hq.token']. */

const TOKEN_KEY = 'hq.token'
const NAME_KEY = 'hq.name'
const ROLE_KEY = 'hq.role'
const ID_KEY = 'hq.id'

export function hasSession(): boolean {
  return (localStorage.getItem(TOKEN_KEY) ?? '') !== ''
}

export function displayName(): string {
  return localStorage.getItem(NAME_KEY) ?? ''
}

/** The signed-in employee's id ('' for sessions minted before it was stored). */
export function staffId(): string {
  return localStorage.getItem(ID_KEY) ?? ''
}

/** 'owner' | 'manager' | 'staff' — pages gate write actions on this. */
export function role(): string {
  return localStorage.getItem(ROLE_KEY) ?? 'staff'
}

/** True for the managerial roles (owner|manager); mirrors the server-side gate. */
export function isManagerial(): boolean {
  const r = role()
  return r === 'owner' || r === 'manager'
}

export function clearSession(): void {
  localStorage.removeItem(TOKEN_KEY)
  localStorage.removeItem(NAME_KEY)
  localStorage.removeItem(ROLE_KEY)
  localStorage.removeItem(ID_KEY)
}

/**
 * Fetch `/api${path}` with the session bearer token. On 401 (outside the login
 * call itself) the session is cleared and the app redirects to /login.
 */
export async function apiFetch<T>(path: string, opts?: RequestInit): Promise<T> {
  const token = localStorage.getItem(TOKEN_KEY) ?? ''
  const res = await fetch(`/api${path}`, {
    ...opts,
    headers: {
      'content-type': 'application/json',
      ...(token !== '' ? { authorization: `Bearer ${token}` } : {}),
      ...(opts?.headers ?? {}),
    },
  }).catch(() => undefined)
  if (res === undefined) throw new Error('HQ server unreachable — is it running on port 5182?')
  if (res.status === 401 && !path.startsWith('/auth/')) {
    clearSession()
    window.location.hash = '#/login'
    throw new Error('Not signed in')
  }
  const body = (await res.json().catch(() => ({}))) as T & { error?: string }
  if (!res.ok) throw new Error(body.error ?? `Server error HTTP ${res.status}`)
  return body
}

export async function login(email: string, password: string): Promise<{ displayName: string; role: string }> {
  const out = await apiFetch<{ token: string; staff: { id: string; displayName: string; role: string } }>(
    '/auth/login',
    { method: 'POST', body: JSON.stringify({ email, password }) },
  )
  localStorage.setItem(TOKEN_KEY, out.token)
  localStorage.setItem(NAME_KEY, out.staff.displayName)
  localStorage.setItem(ROLE_KEY, out.staff.role)
  localStorage.setItem(ID_KEY, out.staff.id)
  return { displayName: out.staff.displayName, role: out.staff.role }
}

export interface EmailStatus { connected: boolean; address?: string; dead: boolean }
export const getEmailStatus = (): Promise<EmailStatus> => apiFetch<EmailStatus>('/email/status')

// ---------- shared server shapes (mirror apps/hq repos — camelCase JSON) ----------

export interface ClientContact { name: string; phone?: string; email?: string; role?: string }

export type ClientStatus = 'lead' | 'active' | 'dormant' | 'lost'
export const CLIENT_STATUSES: ClientStatus[] = ['lead', 'active', 'dormant', 'lost']

export interface Client {
  id: string; code: string; name: string; gstin?: string; stateCode: string
  address: string; contacts: ClientContact[]; status: ClientStatus; notes: string
  /** Account/enquiry owner (→ employee id); absent = unassigned. */
  ownerId?: string
}

export type Kind = 'one_time' | 'monthly' | 'yearly' | 'usage'
export const KIND_LABEL: Record<Kind, string> = {
  one_time: 'One-time', monthly: 'Monthly', yearly: 'Yearly', usage: 'Usage',
}

export interface Module {
  id: string; code: string; name: string; sac: string
  allowedKinds: Kind[]; multiSubscription: boolean; active: boolean
  quoteContent: string[]
}

export interface ModulePrice {
  id: string; moduleId: string; edition: string; kind: Kind
  pricePaise: number; effectiveFrom: string
}

export type ClientModuleStatus =
  | 'quoted' | 'ordered' | 'installing' | 'installed'
  | 'trained' | 'live' | 'expired' | 'cancelled'
export const CLIENT_MODULE_STATUSES: ClientModuleStatus[] = [
  'quoted', 'ordered', 'installing', 'installed', 'trained', 'live', 'expired', 'cancelled',
]

export interface ClientModule {
  id: string; clientId: string; moduleId: string; status: ClientModuleStatus
  kind: Kind; edition: string
  installedOn: string | null; completedOn: string | null; trainedOn: string | null
  nextRenewal: string | null; active: boolean
}

export type DocType = 'QUOTATION' | 'PROFORMA' | 'INVOICE' | 'RECEIPT' | 'CREDIT_NOTE'
export type DocStatus =
  | 'draft' | 'sent' | 'accepted' | 'invoiced' | 'part_paid' | 'paid' | 'lost' | 'cancelled'
export const DOC_STATUSES: DocStatus[] = [
  'draft', 'sent', 'accepted', 'invoiced', 'part_paid', 'paid', 'lost', 'cancelled',
]

export interface DocLine {
  itemId: string; name: string; hsn: string; qty: number; unitCode: string
  unitPricePaise: number; taxablePaise: number; lineTotalPaise: number
}

export interface Doc {
  id: string; docType: DocType; docNo: string | null; fy: string; clientId: string
  docDate: string; status: DocStatus; refDocId: string | null
  taxablePaise: number; cgstPaise: number; sgstPaise: number; igstPaise: number
  roundOffPaise: number; payablePaise: number
  payload: { lines: DocLine[]; terms?: string; lineContents?: string[][] }
  source: string; createdBy: string; createdAt: string
}

export interface DocumentEvent {
  id: string; documentId: string; atWall: string; kind: string; meta: Record<string, unknown>
}

/** A public share link for one document (mirrors apps/hq repos-shares — camelCase JSON). */
export interface Share {
  id: string; documentId: string; token: string; createdBy: string
  createdAt: string; expiresAt: string | null; revoked: boolean
}

/** email_log rows come straight off the table (snake_case). */
export interface EmailLogRow {
  id: string; document_id: string | null; to_addr: string; subject: string
  status: 'sent' | 'failed'; gmail_message_id: string | null; error: string | null; at_wall: string
}

export type PaymentMode = 'bank' | 'upi' | 'cheque' | 'cash' | 'other'
export const PAYMENT_MODES: PaymentMode[] = ['bank', 'upi', 'cheque', 'cash', 'other']

export interface Payment {
  id: string; clientId: string; receivedOn: string; mode: PaymentMode
  reference: string; amountPaise: number; tdsPaise: number
  createdBy: string; createdAt: string
}

export interface Ledger {
  documents: Doc[]; payments: Payment[]; advancePaise: number
  modulePaid: { moduleId: string; billedPaise: number; settledPaise: number }[]
}

// ---------- typed calls ----------

export const getClients = (q?: string): Promise<Client[]> =>
  apiFetch<{ clients: Client[] }>(`/clients${q !== undefined && q !== '' ? `?q=${encodeURIComponent(q)}` : ''}`)
    .then((r) => r.clients)
export const getClient = (id: string): Promise<Client> =>
  apiFetch<{ client: Client }>(`/clients/${id}`).then((r) => r.client)
export const createClient = (body: Record<string, unknown>): Promise<Client> =>
  apiFetch<{ client: Client }>('/clients', { method: 'POST', body: JSON.stringify(body) }).then((r) => r.client)
export const patchClient = (id: string, body: Record<string, unknown>): Promise<Client> =>
  apiFetch<{ client: Client }>(`/clients/${id}`, { method: 'PATCH', body: JSON.stringify(body) }).then((r) => r.client)
/** Assign/clear the account owner — owner/manager only; audited server-side. `null` clears. */
export const setClientOwner = (id: string, ownerId: string | null): Promise<Client> =>
  apiFetch<{ client: Client }>(`/clients/${id}/owner`, { method: 'PATCH', body: JSON.stringify({ ownerId }) }).then((r) => r.client)

export const getModules = (): Promise<Module[]> =>
  apiFetch<{ modules: Module[] }>('/modules').then((r) => r.modules)
export const createModule = (body: Record<string, unknown>): Promise<Module> =>
  apiFetch<{ module: Module }>('/modules', { method: 'POST', body: JSON.stringify(body) }).then((r) => r.module)
export const patchModule = (id: string, body: Record<string, unknown>): Promise<Module> =>
  apiFetch<{ module: Module }>(`/modules/${id}`, { method: 'PATCH', body: JSON.stringify(body) }).then((r) => r.module)
export const getPrices = (moduleId: string): Promise<ModulePrice[]> =>
  apiFetch<{ prices: ModulePrice[] }>(`/modules/${moduleId}/prices`).then((r) => r.prices)
export const addPrice = (moduleId: string, body: Record<string, unknown>): Promise<ModulePrice[]> =>
  apiFetch<{ prices: ModulePrice[] }>(`/modules/${moduleId}/prices`, { method: 'POST', body: JSON.stringify(body) })
    .then((r) => r.prices)

export const getClientModules = (clientId: string): Promise<ClientModule[]> =>
  apiFetch<{ clientModules: ClientModule[] }>(`/clients/${clientId}/modules`).then((r) => r.clientModules)
export const assignClientModule = (clientId: string, body: Record<string, unknown>): Promise<ClientModule> =>
  apiFetch<{ clientModule: ClientModule }>(`/clients/${clientId}/modules`, { method: 'POST', body: JSON.stringify(body) })
    .then((r) => r.clientModule)
export const patchClientModule = (id: string, body: Record<string, unknown>): Promise<ClientModule> =>
  apiFetch<{ clientModule: ClientModule }>(`/client-modules/${id}`, { method: 'PATCH', body: JSON.stringify(body) })
    .then((r) => r.clientModule)

export const getBillingSettings = (): Promise<{ paymentTermsDays: number }> =>
  apiFetch<{ paymentTermsDays: number }>('/settings/billing')

/** One Documents-list row: the document plus the server-joined client name (no N+1). */
export type DocListRow = Doc & { clientName: string }
export interface DocumentsPage { documents: DocListRow[]; total: number; page: number; pageSize: number }
/** Server-paginated document list with an honest total (rule 8); filters compose. */
export const getDocuments = (
  opts: { type?: DocType; status?: DocStatus; clientId?: string; page?: number; pageSize?: number } = {},
): Promise<DocumentsPage> => {
  const p = new URLSearchParams()
  if (opts.type !== undefined) p.set('type', opts.type)
  if (opts.status !== undefined) p.set('status', opts.status)
  if (opts.clientId !== undefined && opts.clientId !== '') p.set('clientId', opts.clientId)
  if (opts.page !== undefined) p.set('page', String(opts.page))
  if (opts.pageSize !== undefined) p.set('pageSize', String(opts.pageSize))
  const q = p.toString()
  return apiFetch<DocumentsPage>(`/documents${q === '' ? '' : `?${q}`}`)
}
export const createDocument = (body: Record<string, unknown>): Promise<Doc> =>
  apiFetch<{ document: Doc }>('/documents', { method: 'POST', body: JSON.stringify(body) }).then((r) => r.document)
export const getDocumentFull = (id: string): Promise<{ document: Doc; events: DocumentEvent[]; emails: EmailLogRow[]; shares: Share[] }> =>
  apiFetch(`/documents/${id}`)
/** issue / status / convert / cancel / credit-note / send — all POST → { document }. */
export const documentAction = (id: string, action: string, body?: Record<string, unknown>): Promise<Doc> =>
  apiFetch<{ document: Doc }>(`/documents/${id}/${action}`, {
    method: 'POST', body: JSON.stringify(body ?? {}),
  }).then((r) => r.document)

/** Mint a public share link for a document. `expiresDays: null` = never expires; omit for the +30d default. */
export const createShare = (id: string, expiresDays?: number | null): Promise<{ share: Share; shares: Share[] }> =>
  apiFetch<{ share: Share; shares: Share[] }>(`/documents/${id}/share`, {
    method: 'POST', body: JSON.stringify(expiresDays !== undefined ? { expiresDays } : {}),
  })
/** Revoke a share (owner-gated, audited); returns the refreshed share list. */
export const revokeShare = (id: string, shareId: string): Promise<{ share: Share; shares: Share[] }> =>
  apiFetch<{ share: Share; shares: Share[] }>(`/documents/${id}/share/${shareId}/revoke`, {
    method: 'POST', body: '{}',
  })

export const recordPayment = (body: Record<string, unknown>): Promise<Payment> =>
  apiFetch<{ payment: Payment }>('/payments', { method: 'POST', body: JSON.stringify(body) }).then((r) => r.payment)
export const getLedger = (clientId: string): Promise<Ledger> =>
  apiFetch<Ledger>(`/clients/${clientId}/ledger`)

// ---------- employees (staff_user; D16) ----------

export type EmployeeRole = 'owner' | 'manager' | 'staff'
export const EMPLOYEE_ROLES: EmployeeRole[] = ['owner', 'manager', 'staff']

export interface Employee {
  id: string; email: string; displayName: string; role: EmployeeRole; active: boolean
  phone: string | null; title: string | null
}

/** Full list + server-echoed total (bounded set, no truncation) — any signed-in user. */
export const getEmployees = (): Promise<{ employees: Employee[]; total: number }> =>
  apiFetch<{ employees: Employee[]; total: number }>('/employees')
export const createEmployee = (
  body: { email: string; displayName: string; role: EmployeeRole; password: string },
): Promise<Employee> =>
  apiFetch<{ employee: Employee }>('/employees', { method: 'POST', body: JSON.stringify(body) }).then((r) => r.employee)
/** Email is the login id — immutable; name, role, phone and title may change. */
export const patchEmployee = (
  id: string, body: { displayName?: string; role?: EmployeeRole; phone?: string; title?: string },
): Promise<Employee> =>
  apiFetch<{ employee: Employee }>(`/employees/${id}`, { method: 'PATCH', body: JSON.stringify(body) }).then((r) => r.employee)

// ---------- self-service profile (D18 WS-E) ----------
export const getMe = (): Promise<Employee> =>
  apiFetch<{ employee: Employee }>('/me').then((r) => r.employee)
/** Self-scoped: only name + phone; role/email untouchable server-side. */
export const patchMe = (body: { displayName?: string; phone?: string }): Promise<Employee> =>
  apiFetch<{ employee: Employee }>('/me', { method: 'PATCH', body: JSON.stringify(body) })
    .then((r) => { if (r.employee.displayName !== '') localStorage.setItem(NAME_KEY, r.employee.displayName); return r.employee })
export const changeMyPassword = (currentPassword: string, newPassword: string): Promise<void> =>
  apiFetch<{ ok: boolean }>('/me/password', {
    method: 'POST', body: JSON.stringify({ currentPassword, newPassword }),
  }).then(() => undefined)
export const deactivateEmployee = (id: string): Promise<Employee> =>
  apiFetch<{ employee: Employee }>(`/employees/${id}/deactivate`, { method: 'POST', body: '{}' }).then((r) => r.employee)
export const reactivateEmployee = (id: string): Promise<Employee> =>
  apiFetch<{ employee: Employee }>(`/employees/${id}/reactivate`, { method: 'POST', body: '{}' }).then((r) => r.employee)
export const resetEmployeePassword = (id: string, password: string): Promise<Employee> =>
  apiFetch<{ employee: Employee }>(`/employees/${id}/password`, {
    method: 'POST', body: JSON.stringify({ password }),
  }).then((r) => r.employee)

// ---------- pipeline chase-list (D-PIPE; spec §6b/§9) ----------

export type PipelineStage = 'enquiry' | 'new_project' | 'quoted_waiting' | 'won' | 'lost'
export type PipelineBand = 'green' | 'amber' | 'red'
export type PipelineNextAction =
  | 'send_quote' | 'waiting' | 'chase' | 'nudge' | 'final_nudge' | 'convert_invoice' | 'none'
export type PipelineFilter = 'all' | 'mine' | 'overdue' | 'lost'

export interface PipelineRow {
  clientId: string; clientCode: string; clientName: string
  docId: string | null; docNo: string | null; docStatus: string | null
  amountPaise: number | null
  ownerId: string | null; ownerName: string | null
  stage: PipelineStage; ageDays: number | null
  nextAction: PipelineNextAction; band: PipelineBand | null
}

export interface PipelinePage {
  rows: PipelineRow[]; total: number; page: number; pageSize: number; dayOffsets: number[]
}

/** Server-paginated, role-gated (staff forced to own rows server-side). */
export const getPipeline = (
  opts: { filter?: PipelineFilter; owner?: string; page?: number; pageSize?: number } = {},
): Promise<PipelinePage> => {
  const p = new URLSearchParams()
  if (opts.filter !== undefined) p.set('filter', opts.filter)
  if (opts.owner !== undefined && opts.owner !== '') p.set('owner', opts.owner)
  if (opts.page !== undefined) p.set('page', String(opts.page))
  if (opts.pageSize !== undefined) p.set('pageSize', String(opts.pageSize))
  const q = p.toString()
  return apiFetch<PipelinePage>(`/pipeline${q === '' ? '' : `?${q}`}`)
}

// ---------- HQ-2 shapes ----------

export type Cadence = 'monthly' | 'yearly'
export interface RecurringPlan {
  id: string; clientId: string; clientModuleId: string | null; cadence: Cadence
  amountPaise: number | null; nextRun: string; policy: 'auto' | 'manual'; active: boolean
}

export type AmcPaidStatus = 'paid' | 'unpaid' | 'unbilled'
export interface AmcContract {
  id: string; clientId: string; coverage: string; periodFrom: string; periodTo: string
  amountPaise: number; renewalReminderDays: number; legacyPaid: boolean | null
  invoiceDocId: string | null; active: boolean; paidStatus: AmcPaidStatus
}

export interface InteractionType { code: string; label: string }
export type Outcome = 'positive' | 'neutral' | 'negative'
export interface Interaction {
  id: string; clientId: string; typeCode: string; onDate: string; staffId: string
  notes: string; outcome: Outcome | null; followUpOn: string | null; createdAt: string
}

export type ReminderRuleKind =
  | 'invoice_overdue' | 'renewal_due' | 'amc_expiring' | 'follow_up' | 'recurring_generated'
  | 'email_bounced' | 'quote_followup'
export type ReminderStatus = 'queued' | 'sent' | 'failed' | 'dismissed'
export interface Reminder {
  id: string; ruleKind: ReminderRuleKind; subjectId: string; duePeriod: string; clientId: string
  docId: string | null; status: ReminderStatus; policyApplied: 'auto' | 'manual'
  error: string | null; createdAt: string; sentAt: string | null
}

/** One queue row: the reminder + server-derived display fields (client name, doc no, owner, label). */
export type QueueItem = Reminder & {
  clientName: string; docNo: string | null; ownerId: string | null; label: string
}

export interface DashboardView {
  today: string
  overdue: { docId: string; docNo: string | null; clientId: string; clientName: string; outstandingPaise: number; daysOverdue: number }[]
  dueThisWeek: { planId: string; clientId: string; clientName: string; nextRun: string; amountPaise: number | null }[]
  renewalsThisMonth: { clientModuleId: string; clientId: string; clientName: string; nextRenewal: string }[]
  followUpsToday: { id: string; clientId: string; clientName: string; onDate: string; followUpOn: string; notes: string }[]
  recentPayments: { id: string; clientId: string; clientName: string; receivedOn: string; amountPaise: number; mode: string }[]
  queue: QueueItem[]
  /** Honest queue size — `queue` is the first page only. */
  queueTotal: number
  totals: { overduePaise: number; queued: number; failed: number }
}

// ---------- HQ-2 calls ----------

export const getDashboard = (): Promise<DashboardView> =>
  apiFetch<{ view: DashboardView }>('/dashboard').then((r) => r.view)
export interface RemindersPage { reminders: QueueItem[]; total: number; page: number; pageSize: number }
/**
 * Viewer-scoped, paginated queue slice + honest total (staff are server-forced to their
 * own rows). No `status` = the working set (queued|failed); `owner` narrows — managerial only.
 */
export const getReminders = (
  opts: { status?: ReminderStatus; owner?: string; page?: number; pageSize?: number } = {},
): Promise<RemindersPage> => {
  const p = new URLSearchParams()
  if (opts.status !== undefined) p.set('status', opts.status)
  if (opts.owner !== undefined && opts.owner !== '') p.set('owner', opts.owner)
  if (opts.page !== undefined) p.set('page', String(opts.page))
  if (opts.pageSize !== undefined) p.set('pageSize', String(opts.pageSize))
  const q = p.toString()
  return apiFetch<RemindersPage>(`/reminders${q === '' ? '' : `?${q}`}`)
}
export const sendReminder = (id: string): Promise<Reminder> =>
  apiFetch<{ reminder: Reminder }>(`/reminders/${id}/send`, { method: 'POST', body: '{}' }).then((r) => r.reminder)
export const dismissReminder = (id: string): Promise<Reminder> =>
  apiFetch<{ reminder: Reminder }>(`/reminders/${id}/dismiss`, { method: 'POST', body: '{}' }).then((r) => r.reminder)

export const getRecurringPlans = (clientId: string): Promise<RecurringPlan[]> =>
  apiFetch<{ plans: RecurringPlan[] }>(`/recurring?clientId=${clientId}`).then((r) => r.plans)
export const createRecurringPlan = (clientId: string, body: Record<string, unknown>): Promise<RecurringPlan> =>
  apiFetch<{ plan: RecurringPlan }>(`/clients/${clientId}/recurring`, { method: 'POST', body: JSON.stringify(body) }).then((r) => r.plan)
export const updateRecurringPlan = (id: string, body: Record<string, unknown>): Promise<RecurringPlan> =>
  apiFetch<{ plan: RecurringPlan }>(`/recurring/${id}`, { method: 'PATCH', body: JSON.stringify(body) }).then((r) => r.plan)
export const deactivateRecurringPlan = (id: string): Promise<RecurringPlan> =>
  apiFetch<{ plan: RecurringPlan }>(`/recurring/${id}/deactivate`, { method: 'POST', body: '{}' }).then((r) => r.plan)

export const getAmc = (clientId: string): Promise<AmcContract[]> =>
  apiFetch<{ contracts: AmcContract[] }>(`/clients/${clientId}/amc`).then((r) => r.contracts)
export const createAmc = (clientId: string, body: Record<string, unknown>): Promise<AmcContract> =>
  apiFetch<{ contract: AmcContract }>(`/clients/${clientId}/amc`, { method: 'POST', body: JSON.stringify(body) }).then((r) => r.contract)
export const updateAmc = (id: string, body: Record<string, unknown>): Promise<AmcContract> =>
  apiFetch<{ contract: AmcContract }>(`/amc/${id}`, { method: 'PATCH', body: JSON.stringify(body) }).then((r) => r.contract)
export const deactivateAmc = (id: string): Promise<AmcContract> =>
  apiFetch<{ contract: AmcContract }>(`/amc/${id}/deactivate`, { method: 'POST', body: '{}' }).then((r) => r.contract)
export const generateAmcRenewalInvoice = (id: string): Promise<Doc> =>
  apiFetch<{ document: Doc }>(`/amc/${id}/renewal-invoice`, { method: 'POST', body: '{}' }).then((r) => r.document)

export const getInteractionTypes = (): Promise<InteractionType[]> =>
  apiFetch<{ types: InteractionType[] }>('/interaction-types').then((r) => r.types)
export const getInteractions = (clientId: string): Promise<Interaction[]> =>
  apiFetch<{ interactions: Interaction[] }>(`/clients/${clientId}/interactions`).then((r) => r.interactions)
export const createInteraction = (clientId: string, body: Record<string, unknown>): Promise<Interaction> =>
  apiFetch<{ interaction: Interaction }>(`/clients/${clientId}/interactions`, { method: 'POST', body: JSON.stringify(body) }).then((r) => r.interaction)
export const updateInteraction = (id: string, body: Record<string, unknown>): Promise<Interaction> =>
  apiFetch<{ interaction: Interaction }>(`/interactions/${id}`, { method: 'PATCH', body: JSON.stringify(body) }).then((r) => r.interaction)

// ---------- HQ-3a shapes ----------

export interface DuesAgingRow {
  clientId: string; clientName: string
  b0_30: number; b31_60: number; b61_90: number; b90p: number; totalPaise: number
}
export interface ModuleRevenueRow {
  moduleId: string; moduleCode: string; moduleName: string; billedPaise: number; settledPaise: number
}
export interface ProfitabilityRow {
  clientId: string; clientName: string
  billedPaise: number; settledPaise: number; awsCostPaise: number; marginPaise: number
}
export interface CostRankRow { clientId: string; clientName: string; costPaise: number; sharePctBp: number }
export interface AwsUsageRow {
  id: string; clientId: string; month: string
  storageGb: number; transferGb: number; costPaise: number; source: 'auto' | 'manual'; updatedAt: string
}

// ---------- HQ-3a calls ----------

const rangeQs = (from?: string, to?: string): string => {
  const p = new URLSearchParams()
  if (from !== undefined && from !== '') p.set('from', from)
  if (to !== undefined && to !== '') p.set('to', to)
  const q = p.toString()
  return q === '' ? '' : `?${q}`
}

export const getDuesAging = (): Promise<DuesAgingRow[]> =>
  apiFetch<{ rows: DuesAgingRow[] }>('/reports/dues-aging').then((r) => r.rows)
export const getModuleRevenue = (from?: string, to?: string): Promise<ModuleRevenueRow[]> =>
  apiFetch<{ rows: ModuleRevenueRow[] }>(`/reports/module-revenue${rangeQs(from, to)}`).then((r) => r.rows)
export const getProfitability = (from?: string, to?: string): Promise<ProfitabilityRow[]> =>
  apiFetch<{ rows: ProfitabilityRow[] }>(`/reports/profitability${rangeQs(from, to)}`).then((r) => r.rows)
export const getAwsRanking = (month?: string): Promise<{ month: string; total: number; rows: CostRankRow[] }> =>
  apiFetch<{ month: string; total: number; rows: CostRankRow[] }>(`/aws/ranking${month !== undefined && month !== '' ? `?month=${month}` : ''}`)
export const getClientAwsUsage = (clientId: string): Promise<AwsUsageRow[]> =>
  apiFetch<{ usage: AwsUsageRow[] }>(`/clients/${clientId}/aws-usage`).then((r) => r.usage)
export const upsertAwsUsage = (body: Record<string, unknown>): Promise<AwsUsageRow> =>
  apiFetch<{ usage: AwsUsageRow }>('/aws/usage', { method: 'POST', body: JSON.stringify(body) }).then((r) => r.usage)
export const pullAwsCosts = (month?: string): Promise<{ upserted: number; totalPaise: number; unknownTags: { tag: string; costPaise: number }[] }> =>
  apiFetch('/aws/pull', { method: 'POST', body: JSON.stringify(month !== undefined ? { month } : {}) })

export const getCompanyProfile = (): Promise<Record<string, string>> =>
  apiFetch<{ company: Record<string, string> }>('/settings/company').then((r) => r.company)
export const putCompanyProfile = (body: Record<string, string>): Promise<Record<string, string>> =>
  apiFetch<{ company: Record<string, string> }>('/settings/company', { method: 'PUT', body: JSON.stringify(body) }).then((r) => r.company)

export const getTemplateSettings = (): Promise<Record<string, string>> =>
  apiFetch<{ settings: Record<string, string> }>('/settings/template').then((r) => r.settings)
export const putTemplateSettings = (
  body: { company?: Record<string, string>; template?: Record<string, string>; titles?: Record<string, string> },
): Promise<Record<string, string>> =>
  apiFetch<{ settings: Record<string, string> }>('/settings/template', { method: 'PUT', body: JSON.stringify(body) }).then((r) => r.settings)
export const uploadTemplateLogo = (dataUri: string): Promise<string> =>
  apiFetch<{ logo: string }>('/settings/template/logo', { method: 'POST', body: JSON.stringify({ dataUri }) }).then((r) => r.logo)

// ---------- module → client roster (spec §10) ----------

export interface ModuleClientRow {
  clientId: string; clientName: string; clientCode: string
  status: string; kind: Kind; edition: string
  nextRenewal: string | null; pricePaise: number | null
}
export interface ModuleClientsPage {
  clients: ModuleClientRow[]; total: number; page: number; pageSize: number; totalPricePaise: number
}
export const getModuleClients = (moduleId: string, page = 1): Promise<ModuleClientsPage> =>
  apiFetch<ModuleClientsPage & { ok: boolean }>(`/modules/${moduleId}/clients?page=${page}`)
export const notifyModuleClients = (
  moduleId: string, body: { subject: string; body: string },
): Promise<{ sent: number; total: number; failed: { client: string; error: string }[] }> =>
  apiFetch(`/modules/${moduleId}/notify`, { method: 'POST', body: JSON.stringify(body) })
/** CSV export needs the bearer header an <a href> can't carry — blob + transient anchor. */
export async function downloadModuleClientsCsv(moduleId: string, moduleCode: string): Promise<void> {
  const token = localStorage.getItem(TOKEN_KEY) ?? ''
  const res = await fetch(`/api/modules/${moduleId}/clients.csv`, {
    headers: token !== '' ? { authorization: `Bearer ${token}` } : {},
  })
  if (!res.ok) {
    const body = (await res.json().catch(() => ({}))) as { error?: string }
    throw new Error(body.error ?? `CSV failed: HTTP ${res.status}`)
  }
  const blob = await res.blob()
  const url = URL.createObjectURL(blob)
  const a = document.createElement('a')
  a.href = url
  a.download = `module-${moduleCode}-clients.csv`
  document.body.appendChild(a)
  a.click()
  a.remove()
  URL.revokeObjectURL(url)
}

/** The PDF route needs the bearer header, which an <iframe src> can't carry — fetch a blob instead. */
export async function fetchPdfBlob(documentId: string): Promise<Blob> {
  const token = localStorage.getItem(TOKEN_KEY) ?? ''
  const res = await fetch(`/api/documents/${documentId}/pdf`, {
    headers: token !== '' ? { authorization: `Bearer ${token}` } : {},
  })
  if (!res.ok) {
    const body = (await res.json().catch(() => ({}))) as { error?: string }
    throw new Error(body.error ?? `PDF failed: HTTP ${res.status}`)
  }
  return res.blob()
}

/**
 * Download the document PDF as a file. Hits `?download=1` (attachment disposition) but,
 * because the route needs the bearer header an <a href> can't carry, fetches a blob and
 * saves it via a transient object-URL anchor named after the doc-no (slugged, `/` → `-`).
 */
export async function downloadDocumentPdf(documentId: string, docNo: string | null): Promise<void> {
  const token = localStorage.getItem(TOKEN_KEY) ?? ''
  const res = await fetch(`/api/documents/${documentId}/pdf?download=1`, {
    headers: token !== '' ? { authorization: `Bearer ${token}` } : {},
  })
  if (!res.ok) {
    const body = (await res.json().catch(() => ({}))) as { error?: string }
    throw new Error(body.error ?? `PDF failed: HTTP ${res.status}`)
  }
  const blob = await res.blob()
  const url = URL.createObjectURL(blob)
  const a = document.createElement('a')
  a.href = url
  a.download = `${(docNo ?? 'draft').replaceAll('/', '-')}.pdf`
  document.body.appendChild(a)
  a.click()
  a.remove()
  URL.revokeObjectURL(url)
}

export interface DocTotals {
  taxablePaise: number; cgstPaise: number; sgstPaise: number
  igstPaise: number; roundOffPaise: number; payablePaise: number
}
export interface DocPreview { html: string; totals: DocTotals; warnings: string[] }

/**
 * Dedicated preview POST (mirrors fetchPdfBlob): carries the bearer token and the
 * AbortSignal, and — unlike apiFetch — lets an aborted fetch reject as AbortError
 * so LivePreview can silently drop superseded requests instead of surfacing a
 * spurious "server unreachable".
 */
async function postPreview<T>(path: string, body: unknown, signal?: AbortSignal): Promise<T> {
  const token = localStorage.getItem(TOKEN_KEY) ?? ''
  const res = await fetch(`/api${path}`, {
    method: 'POST', signal,
    headers: { 'content-type': 'application/json', ...(token !== '' ? { authorization: `Bearer ${token}` } : {}) },
    body: JSON.stringify(body),
  })
  const json = (await res.json().catch(() => ({}))) as T & { error?: string }
  if (!res.ok) throw new Error((json as { error?: string }).error ?? `Preview failed: HTTP ${res.status}`)
  return json
}

export const previewDocument = (body: unknown, signal?: AbortSignal): Promise<DocPreview> =>
  postPreview<DocPreview>('/documents/preview', body, signal)
export const previewSample = (body: unknown, signal?: AbortSignal): Promise<{ html: string }> =>
  postPreview<{ html: string }>('/previews/sample', body, signal)
export const getReminderPreview = (id: string): Promise<{ subject: string; body: string }> =>
  apiFetch<{ subject: string; body: string }>(`/reminders/${id}/preview`)