Scrum4Me/actions/sprints.ts

'use server'

import { revalidatePath } from 'next/cache'
import { cookies } from 'next/headers'
import { getIronSession } from 'iron-session'
import { z } from 'zod'
import { prisma } from '@/lib/prisma'
import { SessionData, sessionOptions } from '@/lib/session'
import { getAccessibleProduct, productAccessFilter } from '@/lib/product-access'

async function getSession() {
  return getIronSession<SessionData>(await cookies(), sessionOptions)
}

function hasDuplicateIds(ids: string[]) {
  return new Set(ids).size !== ids.length
}

const dateField = z.string().optional().nullable().transform(v => (v && v.trim() !== '' ? new Date(v) : null))

function validateDateOrder(data: { start_date: Date | null; end_date: Date | null }, ctx: z.RefinementCtx) {
  if (data.start_date && data.end_date && data.end_date < data.start_date) {
    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['end_date'], message: 'Einddatum moet na startdatum liggen' })
  }
}

export async function createSprintAction(_prevState: unknown, formData: FormData) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const parsed = z.object({
    productId: z.string(),
    sprint_goal: z.string().min(1, 'Sprint Goal is verplicht').max(500),
    start_date: dateField,
    end_date: dateField,
  }).superRefine(validateDateOrder).safeParse({
    productId: formData.get('productId'),
    sprint_goal: formData.get('sprint_goal'),
    start_date: formData.get('start_date'),
    end_date: formData.get('end_date'),
  })
  if (!parsed.success) return { error: parsed.error.flatten().fieldErrors }

  const product = await getAccessibleProduct(parsed.data.productId, session.userId)
  if (!product) return { error: 'Product niet gevonden' }

  const existing = await prisma.sprint.findFirst({
    where: { product_id: parsed.data.productId, status: 'ACTIVE' },
  })
  if (existing) return { error: 'Er is al een actieve Sprint voor dit product', sprintId: existing.id }

  const sprint = await prisma.sprint.create({
    data: {
      product_id: parsed.data.productId,
      sprint_goal: parsed.data.sprint_goal,
      status: 'ACTIVE',
      start_date: parsed.data.start_date,
      end_date: parsed.data.end_date,
    },
  })

  revalidatePath(`/products/${parsed.data.productId}`)
  return { success: true, sprintId: sprint.id }
}

export async function updateSprintDatesAction(_prevState: unknown, formData: FormData) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const parsed = z.object({
    id: z.string(),
    start_date: dateField,
    end_date: dateField,
  }).superRefine(validateDateOrder).safeParse({
    id: formData.get('id'),
    start_date: formData.get('start_date'),
    end_date: formData.get('end_date'),
  })
  if (!parsed.success) return { error: parsed.error.flatten().fieldErrors }

  const sprint = await prisma.sprint.findFirst({
    where: { id: parsed.data.id, product: productAccessFilter(session.userId) },
  })
  if (!sprint) return { error: 'Sprint niet gevonden' }

  await prisma.sprint.update({
    where: { id: parsed.data.id },
    data: { start_date: parsed.data.start_date, end_date: parsed.data.end_date },
  })
  revalidatePath(`/products/${sprint.product_id}/sprint`)
  return { success: true }
}

export async function updateSprintGoalAction(_prevState: unknown, formData: FormData) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const id = formData.get('id') as string
  const sprint_goal = formData.get('sprint_goal') as string
  if (!sprint_goal?.trim()) return { error: 'Sprint Goal is verplicht' }

  const sprint = await prisma.sprint.findFirst({
    where: { id, product: productAccessFilter(session.userId) },
  })
  if (!sprint) return { error: 'Sprint niet gevonden' }

  await prisma.sprint.update({ where: { id }, data: { sprint_goal } })
  revalidatePath(`/products/${sprint.product_id}/sprint`)
  return { success: true }
}

export async function addStoryToSprintAction(sprintId: string, storyId: string) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const sprint = await prisma.sprint.findFirst({
    where: { id: sprintId, product: productAccessFilter(session.userId) },
  })
  if (!sprint) return { error: 'Sprint niet gevonden' }

  const story = await prisma.story.findFirst({
    where: { id: storyId, product: productAccessFilter(session.userId) },
  })
  if (!story) return { error: 'Story niet gevonden' }
  if (story.product_id !== sprint.product_id) return { error: 'Story hoort niet bij deze Sprint' }

  const last = await prisma.story.findFirst({
    where: { sprint_id: sprintId },
    orderBy: { sort_order: 'desc' },
  })

  await prisma.story.update({
    where: { id: storyId },
    data: { sprint_id: sprintId, status: 'IN_SPRINT', sort_order: (last?.sort_order ?? 0) + 1.0 },
  })

  revalidatePath(`/products/${sprint.product_id}/sprint`)
  revalidatePath(`/products/${sprint.product_id}`)
  return { success: true }
}

export async function removeStoryFromSprintAction(storyId: string) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const story = await prisma.story.findFirst({
    where: { id: storyId, product: productAccessFilter(session.userId) },
    include: { sprint: true },
  })
  if (!story) return { error: 'Story niet gevonden' }

  await prisma.story.update({
    where: { id: storyId },
    data: { sprint_id: null, status: 'OPEN' },
  })

  revalidatePath(`/products/${story.product_id}/sprint`)
  revalidatePath(`/products/${story.product_id}`)
  return { success: true }
}

export async function reorderSprintStoriesAction(sprintId: string, orderedIds: string[]) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }
  if (hasDuplicateIds(orderedIds)) return { error: 'Ongeldige Sprint Backlog-volgorde' }

  const sprint = await prisma.sprint.findFirst({
    where: { id: sprintId, product: productAccessFilter(session.userId) },
  })
  if (!sprint) return { error: 'Sprint niet gevonden' }

  const stories = await prisma.story.findMany({
    where: { id: { in: orderedIds }, sprint_id: sprintId, product_id: sprint.product_id },
    select: { id: true },
  })
  if (stories.length !== orderedIds.length) return { error: 'Ongeldige Sprint Backlog-volgorde' }

  await prisma.$transaction(
    orderedIds.map((id, i) =>
      prisma.story.update({ where: { id }, data: { sort_order: i + 1.0 } })
    )
  )

  revalidatePath(`/products/${sprint.product_id}/sprint`)
  return { success: true }
}

export async function completeSprintAction(
  sprintId: string,
  decisions: Record<string, 'DONE' | 'OPEN'>
) {
  const session = await getSession()
  if (!session.userId) return { error: 'Niet ingelogd' }
  if (session.isDemo) return { error: 'Niet beschikbaar in demo-modus' }

  const sprint = await prisma.sprint.findFirst({
    where: { id: sprintId, product: productAccessFilter(session.userId) },
  })
  if (!sprint) return { error: 'Sprint niet gevonden' }

  const entries = Object.entries(decisions)
  if (entries.some(([, status]) => status !== 'DONE' && status !== 'OPEN')) {
    return { error: 'Ongeldige Sprint-afronding' }
  }

  const storyIds = entries.map(([storyId]) => storyId)
  if (hasDuplicateIds(storyIds)) return { error: 'Ongeldige Sprint-afronding' }

  const stories = await prisma.story.findMany({
    where: { id: { in: storyIds }, sprint_id: sprintId, product_id: sprint.product_id },
    select: { id: true, pbi_id: true },
  })
  if (stories.length !== storyIds.length) return { error: 'Ongeldige Sprint-afronding' }

  const affectedPbiIds = [...new Set(stories.map((s) => s.pbi_id))]
  const candidatePbis = await prisma.pbi.findMany({
    where: { id: { in: affectedPbiIds }, status: { not: 'DONE' } },
    select: { id: true, stories: { select: { id: true, status: true } } },
  })

  const decisionByStoryId = new Map(entries)
  const pbiIdsToMarkDone = candidatePbis
    .filter(
      (pbi) =>
        pbi.stories.length > 0 &&
        pbi.stories.every((s) => {
          const next = decisionByStoryId.get(s.id) ?? s.status
          return next === 'DONE'
        })
    )
    .map((p) => p.id)

  await prisma.$transaction([
    ...entries.map(([storyId, status]) =>
      prisma.story.update({
        where: { id: storyId },
        data: {
          status,
          sprint_id: status === 'OPEN' ? null : undefined,
        },
      })
    ),
    ...pbiIdsToMarkDone.map((id) =>
      prisma.pbi.update({ where: { id }, data: { status: 'DONE' } })
    ),
    prisma.sprint.update({
      where: { id: sprintId },
      data: { status: 'COMPLETED', completed_at: new Date() },
    }),
  ])

  revalidatePath(`/products/${sprint.product_id}`)
  revalidatePath(`/products/${sprint.product_id}/sprint`)
  return { success: true }
}