import 'server-only'

import { createAdminClient } from '@/lib/supabase/admin'
import {
  canEdit, canMove, changedFields, devTaskUpdateSchema, groupByStatus, parseTaskRef, positionForPlacement, positionForUrgency,
  sortColumn, statusTimestamps, type BoardRole, type DevTask, type DevTaskActorKind, type DevTaskCreateInput, type DevTaskEvent,
  type DevTaskStatus, type DevTaskUpdateInput,
} from '@/lib/domain/dev-tasks'

/**
 * Developer task board I/O (migration 0061). Every write also appends a
 * dev_task_events row, so the board keeps the full history: who created,
 * edited, moved, reordered, removed or commented, and when.
 */
export interface BoardActor {
  kind: DevTaskActorKind
  label: string
  role: BoardRole
}

export type BoardResult<T> = { ok: true; value: T } | { ok: false; status: number; error: string }

const fail = (status: number, error: string): { ok: false; status: number; error: string } => ({ ok: false, status, error })

/** True when migration 0061 has not been applied yet. */
export function isBoardMissing(error: { code?: string; message?: string } | null | undefined): boolean {
  return !!error && (error.code === '42P01' || error.code === 'PGRST205' || /dev_tasks|schema cache|does not exist/i.test(error.message ?? ''))
}

function normalize(row: Record<string, unknown>): DevTask {
  return { ...(row as unknown as DevTask), steps: Array.isArray(row.steps) ? (row.steps as unknown[]).map(String) : [] }
}

async function logEvent(event: Omit<DevTaskEvent, 'id' | 'created_at' | 'detail'> & { detail?: Record<string, unknown> }) {
  const { error } = await createAdminClient().from('dev_task_events').insert({ ...event, detail: event.detail ?? {} })
  if (error) console.error('dev_task_events insert failed:', error.message)
}

export async function findTask(ref: string): Promise<BoardResult<DevTask>> {
  const parsed = parseTaskRef(ref)
  if (!parsed) return fail(400, 'Unknown task reference. Use the task number (T-12) or its id.')
  const query = createAdminClient().from('dev_tasks').select('*')
  const { data, error } = await ('id' in parsed ? query.eq('id', parsed.id) : query.eq('task_number', parsed.number)).maybeSingle()
  if (error) return fail(isBoardMissing(error) ? 503 : 500, isBoardMissing(error) ? 'The task board is not set up yet (migration 0061).' : 'Task lookup failed.')
  if (!data) return fail(404, 'Task not found.')
  return { ok: true, value: normalize(data) }
}

async function column(status: DevTaskStatus, excludeId?: string): Promise<DevTask[]> {
  let query = createAdminClient().from('dev_tasks').select('*').eq('status', status).is('archived_at', null)
  if (excludeId) query = query.neq('id', excludeId)
  const { data } = await query.order('position', { ascending: true })
  return sortColumn((data ?? []).map(normalize))
}

export interface BoardQuery {
  status?: DevTaskStatus
  project?: string
  /** Only tasks changed at or after this time. */
  since?: string
  includeArchived?: boolean
}

export async function listTasks(q: BoardQuery = {}): Promise<BoardResult<DevTask[]>> {
  let query = createAdminClient().from('dev_tasks').select('*')
  if (q.status) query = query.eq('status', q.status)
  if (q.project) query = query.eq('project', q.project)
  if (q.since) query = query.gte('updated_at', q.since)
  if (!q.includeArchived) query = query.is('archived_at', null)
  const { data, error } = await query.order('position', { ascending: true }).limit(500)
  if (error) return fail(isBoardMissing(error) ? 503 : 500, isBoardMissing(error) ? 'The task board is not set up yet (migration 0061).' : 'Task list failed.')
  return { ok: true, value: (data ?? []).map(normalize) }
}

export async function loadBoard(): Promise<BoardResult<{ columns: ReturnType<typeof groupByStatus<DevTask>>; commentCounts: Record<string, number> }>> {
  const tasks = await listTasks()
  if (!tasks.ok) return tasks
  const ids = tasks.value.map((t) => t.id)
  const counts: Record<string, number> = {}
  if (ids.length) {
    const { data } = await createAdminClient().from('dev_task_events').select('task_id').eq('action', 'comment').in('task_id', ids)
    for (const row of data ?? []) counts[row.task_id as string] = (counts[row.task_id as string] ?? 0) + 1
  }
  return { ok: true, value: { columns: groupByStatus(tasks.value), commentCounts: counts } }
}

export async function taskEvents(taskId: string): Promise<DevTaskEvent[]> {
  const { data } = await createAdminClient().from('dev_task_events').select('*').eq('task_id', taskId).order('created_at', { ascending: true }).limit(500)
  return (data ?? []) as DevTaskEvent[]
}

/** Recent history across the board (completions, comments, moves) for the CTO to catch up on. */
export async function boardActivity(since: string | undefined, limit = 200): Promise<BoardResult<(DevTaskEvent & { task_number: number | null; title: string | null })[]>> {
  let query = createAdminClient().from('dev_task_events').select('*, dev_tasks(task_number, title)')
  if (since) query = query.gte('created_at', since)
  const { data, error } = await query.order('created_at', { ascending: false }).limit(Math.min(Math.max(limit, 1), 500))
  if (error) return fail(isBoardMissing(error) ? 503 : 500, 'Activity lookup failed.')
  return {
    ok: true,
    value: (data ?? []).map((row) => {
      const { dev_tasks: task, ...event } = row as DevTaskEvent & { dev_tasks: { task_number: number; title: string } | null }
      return { ...event, task_number: task?.task_number ?? null, title: task?.title ?? null }
    }),
  }
}

export async function createTask(input: DevTaskCreateInput, actor: BoardActor): Promise<BoardResult<DevTask>> {
  if (!canEdit(actor.role)) return fail(403, 'Only the manager adds tasks.')
  const pending = await column('pending')
  const { data, error } = await createAdminClient().from('dev_tasks').insert({
    ...input,
    source: input.source ?? actor.label,
    created_by: input.created_by ?? actor.label,
    status: 'pending',
    position: positionForUrgency(pending, input.urgency),
  }).select('*').single()
  if (error || !data) return fail(isBoardMissing(error) ? 503 : 500, isBoardMissing(error) ? 'The task board is not set up yet (migration 0061).' : 'Task could not be saved.')
  const task = normalize(data)
  await logEvent({ task_id: task.id, action: 'created', from_status: null, to_status: 'pending', actor_kind: actor.kind, actor_label: actor.label, detail: { urgency: task.urgency, project: task.project } })
  return { ok: true, value: task }
}

/**
 * One update entry point for the API and the board. The developer may only
 * move a task (and leave a completion note); the manager may also edit the
 * brief, reorder, remove and restore.
 */
export async function updateTask(ref: string, rawPatch: DevTaskUpdateInput, actor: BoardActor): Promise<BoardResult<DevTask>> {
  const parsedPatch = devTaskUpdateSchema.safeParse(rawPatch)
  if (!parsedPatch.success) return fail(400, 'Invalid task update.')
  const patch = parsedPatch.data
  const found = await findTask(ref)
  if (!found.ok) return found
  const task = found.value
  const { status, archived, completion_note, ...fields } = patch
  // "Place it before T-3": the neighbour may be named by number or id.
  let place = patch.place
  if (place && !('edge' in place)) {
    const neighbour = await findTask('before' in place ? place.before : place.after)
    if (!neighbour.ok) return fail(400, 'The task to place it next to was not found.')
    place = 'before' in place ? { before: neighbour.value.id } : { after: neighbour.value.id }
  }
  delete (fields as { place?: unknown }).place
  const fieldKeys = Object.keys(fields).filter((k) => (fields as Record<string, unknown>)[k] !== undefined)
  if (!canEdit(actor.role) && (fieldKeys.length || place || archived !== undefined)) return fail(403, 'Only the manager edits, reorders or removes tasks.')
  if (task.archived_at && archived !== false) return fail(409, 'This task was removed. Restore it first.')

  const now = new Date().toISOString()
  const update: Record<string, unknown> = {}
  const events: Parameters<typeof logEvent>[0][] = []

  if (archived !== undefined && archived !== !!task.archived_at) {
    update.archived_at = archived ? now : null
    events.push({ task_id: task.id, action: archived ? 'archived' : 'restored', from_status: task.status, to_status: task.status, actor_kind: actor.kind, actor_label: actor.label })
  }

  const edits = Object.fromEntries(fieldKeys.map((k) => [k, (fields as Record<string, unknown>)[k]]))
  const changed = changedFields(task, edits as Partial<DevTask>)
  for (const k of changed) update[k] = edits[k]
  if (changed.length) events.push({ task_id: task.id, action: 'updated', from_status: task.status, to_status: task.status, actor_kind: actor.kind, actor_label: actor.label, detail: { fields: changed } })

  const target = status ?? task.status
  if (status && status !== task.status) {
    if (!canMove(actor.role, task.status, status)) return fail(403, `A task can't move from ${task.status} to ${status} from here.`)
    Object.assign(update, statusTimestamps(task, status, now), { status })
    if (status !== 'completed') update.completion_note = null
    const destination = await column(status, task.id)
    update.position = place ? positionForPlacement(destination, place) ?? positionForUrgency(destination, (edits.urgency as DevTask['urgency']) ?? task.urgency)
      : status === 'pending' ? positionForUrgency(destination, (edits.urgency as DevTask['urgency']) ?? task.urgency)
        : destination.length ? destination[destination.length - 1].position + 1024 : 1024
    events.push({ task_id: task.id, action: 'moved', from_status: task.status, to_status: status, actor_kind: actor.kind, actor_label: actor.label, detail: completion_note ? { note: completion_note } : {} })
  } else if (place) {
    const position = positionForPlacement(await column(task.status, task.id), place)
    if (position === null) return fail(400, 'The task to place it next to is not in the same column.')
    update.position = position
    events.push({ task_id: task.id, action: 'reordered', from_status: task.status, to_status: task.status, actor_kind: actor.kind, actor_label: actor.label })
  }

  if (completion_note !== undefined) {
    if (target !== 'completed') return fail(400, 'A completion note goes with a completed task.')
    if (completion_note !== task.completion_note) update.completion_note = completion_note
  }

  if (!Object.keys(update).length) return { ok: true, value: task }
  update.updated_at = now
  const { data, error } = await createAdminClient().from('dev_tasks').update(update).eq('id', task.id).select('*').single()
  if (error || !data) return fail(500, 'Task could not be updated.')
  for (const e of events) await logEvent(e)
  return { ok: true, value: normalize(data) }
}

export async function addComment(ref: string, text: string, actor: BoardActor): Promise<BoardResult<DevTaskEvent>> {
  const found = await findTask(ref)
  if (!found.ok) return found
  const { data, error } = await createAdminClient().from('dev_task_events').insert({
    task_id: found.value.id, action: 'comment', from_status: found.value.status, to_status: found.value.status,
    actor_kind: actor.kind, actor_label: actor.label, detail: { text },
  }).select('*').single()
  if (error || !data) return fail(500, 'Comment could not be saved.')
  await createAdminClient().from('dev_tasks').update({ updated_at: new Date().toISOString() }).eq('id', found.value.id)
  return { ok: true, value: data as DevTaskEvent }
}
