import type { Prisma, SprintStatus } from '@prisma/client'
import { prisma } from '@/lib/prisma'
import {
  mergeSettings,
  parseUserSettings,
  type UserSettings,
} from '@/lib/user-settings'

export type ActiveSprint = {
  id: string
  code: string
  status: SprintStatus
}

async function readSettings(userId: string): Promise<UserSettings> {
  const user = await prisma.user.findUnique({
    where: { id: userId },
    select: { settings: true },
  })
  return parseUserSettings(user?.settings)
}

async function writeSettings(userId: string, next: UserSettings): Promise<void> {
  await prisma.user.update({
    where: { id: userId },
    data: { settings: next as unknown as Prisma.InputJsonValue },
  })
}

async function notifyUserSettings(
  userId: string,
  patch: Partial<UserSettings>,
): Promise<void> {
  await prisma.$executeRaw`
    SELECT pg_notify('scrum4me_changes', ${JSON.stringify({
      kind: 'user_settings',
      userId,
      patch,
    })}::text)
  `
}

export async function getActiveSprintIdFromSettings(
  userId: string,
  productId: string,
): Promise<string | null> {
  const settings = await readSettings(userId)
  return settings.layout?.activeSprints?.[productId] ?? null
}

export async function setActiveSprintInSettings(
  userId: string,
  productId: string,
  sprintId: string,
): Promise<void> {
  const current = await readSettings(userId)
  const patch: Partial<UserSettings> = {
    layout: {
      activeSprints: {
        ...(current.layout?.activeSprints ?? {}),
        [productId]: sprintId,
      },
    },
  }
  await writeSettings(userId, mergeSettings(current, patch))
  await notifyUserSettings(userId, patch)
}

export async function clearActiveSprintInSettings(
  userId: string,
  productId: string,
): Promise<void> {
  const current = await readSettings(userId)
  const existing = current.layout?.activeSprints
  if (!existing || !(productId in existing)) return
  const nextActiveSprints = { ...existing }
  delete nextActiveSprints[productId]
  const next: UserSettings = {
    ...current,
    layout: { ...current.layout, activeSprints: nextActiveSprints },
  }
  await writeSettings(userId, next)
  await notifyUserSettings(userId, {
    layout: { activeSprints: nextActiveSprints },
  })
}

export async function resolveActiveSprint(
  productId: string,
  userId: string,
): Promise<ActiveSprint | null> {
  const stored = await getActiveSprintIdFromSettings(userId, productId)
  if (stored) {
    const sprint = await prisma.sprint.findFirst({
      where: { id: stored, product_id: productId },
      select: { id: true, code: true, status: true },
    })
    if (sprint) return sprint
  }

  const open = await prisma.sprint.findFirst({
    where: { product_id: productId, status: 'OPEN' },
    orderBy: { created_at: 'desc' },
    select: { id: true, code: true, status: true },
  })
  if (open) return open

  const closed = await prisma.sprint.findFirst({
    where: { product_id: productId, status: 'CLOSED' },
    orderBy: { created_at: 'desc' },
    select: { id: true, code: true, status: true },
  })
  return closed ?? null
}