Keep/keep-notes/app/api/fix-labels/route.ts

import { NextResponse } from 'next/server'
import prisma from '@/lib/prisma'
import { revalidatePath } from 'next/cache'

function getHashColor(name: string): string {
  const colors = ['red', 'blue', 'green', 'yellow', 'purple', 'pink', 'orange', 'gray']
  let hash = 0
  for (let i = 0; i < name.length; i++) {
    hash = name.charCodeAt(i) + ((hash << 5) - hash)
  }
  return colors[Math.abs(hash) % colors.length]
}

export async function POST() {
  try {
    const result = { created: 0, deleted: 0, missing: [] as string[] }

    // Get ALL users
    const users = await prisma.user.findMany({
      select: { id: true, email: true }
    })

    console.log(`[FIX] Processing ${users.length} users`)

    for (const user of users) {
      const userId = user.id

      // 1. Get all labels from notes
      const allNotes = await prisma.note.findMany({
        where: { userId },
        select: { labels: true }
      })

      const labelsInNotes = new Set<string>()
      allNotes.forEach(note => {
        if (note.labels) {
          try {
            const parsed: string[] = JSON.parse(note.labels)
            if (Array.isArray(parsed)) {
              parsed.forEach(l => {
                if (l && l.trim()) labelsInNotes.add(l.trim())
              })
            }
          } catch (e) {}
        }
      })

      console.log(`[FIX] User ${user.email}: ${labelsInNotes.size} labels in notes`, Array.from(labelsInNotes))

      // 2. Get existing Label records
      const existingLabels = await prisma.label.findMany({
        where: { userId },
        select: { id: true, name: true }
      })

      console.log(`[FIX] User ${user.email}: ${existingLabels.length} existing labels`, existingLabels.map(l => l.name))

      const existingLabelMap = new Map<string, any>()
      existingLabels.forEach(label => {
        existingLabelMap.set(label.name.toLowerCase(), label)
      })

      // 3. Create missing Label records
      for (const labelName of labelsInNotes) {
        if (!existingLabelMap.has(labelName.toLowerCase())) {
          console.log(`[FIX] Creating missing label: "${labelName}" for ${user.email}`)
          try {
            await prisma.label.create({
              data: {
                userId,
                name: labelName,
                color: getHashColor(labelName)
              }
            })
            result.created++
            console.log(`[FIX] ✓ Created: "${labelName}"`)
          } catch (e: any) {
            console.error(`[FIX] ✗ Failed to create "${labelName}":`, e.message, e.code)
            result.missing.push(labelName)
          }
        }
      }

      // 4. Delete orphan Label records
      const usedLabelsSet = new Set<string>()
      allNotes.forEach(note => {
        if (note.labels) {
          try {
            const parsed: string[] = JSON.parse(note.labels)
            if (Array.isArray(parsed)) {
              parsed.forEach(l => usedLabelsSet.add(l.toLowerCase()))
            }
          } catch (e) {}
        }
      })

      for (const label of existingLabels) {
        if (!usedLabelsSet.has(label.name.toLowerCase())) {
          try {
            await prisma.label.delete({
              where: { id: label.id }
            })
            result.deleted++
            console.log(`[FIX] Deleted orphan: "${label.name}"`)
          } catch (e) {}
        }
      }
    }

    revalidatePath('/')

    return NextResponse.json({
      success: true,
      ...result,
      message: `Created ${result.created} labels, deleted ${result.deleted} orphans`
    })
  } catch (error) {
    console.error('[FIX] Error:', error)
    return NextResponse.json(
      { success: false, error: String(error) },
      { status: 500 }
    )
  }
}