import { PrismaClient } from "@prisma/client"
import { defaultCategories, type CategoryDefinition } from "../lib/defaults"

const prisma = new PrismaClient()

async function main() {
  console.log("🏷️  Synchronisation des catégories hiérarchiques...")
  console.log(`   ${defaultCategories.length} catégories à synchroniser\n`)

  // ═══════════════════════════════════════════════════════════════════════════
  // PHASE 0: Nettoyage des doublons existants
  // ═══════════════════════════════════════════════════════════════════════════
  console.log("═".repeat(50))
  console.log("PHASE 0: Nettoyage des doublons")
  console.log("═".repeat(50))

  const allExisting = await prisma.category.findMany()
  const byNormalizedName = new Map<string, typeof allExisting>()

  for (const cat of allExisting) {
    const normalized = normalizeName(cat.name)
    if (!byNormalizedName.has(normalized)) {
      byNormalizedName.set(normalized, [])
    }
    byNormalizedName.get(normalized)!.push(cat)
  }

  let merged = 0
  for (const [_normalized, cats] of byNormalizedName) {
    if (cats.length > 1) {
      // Garder celui avec emoji
      let keeper = cats[0]
      for (const cat of cats) {
        if (/[\u{1F300}-\u{1F9FF}]/u.test(cat.name)) {
          keeper = cat
          break
        }
      }
      const toDelete: typeof cats = []
      for (const cat of cats) {
        if (cat.id !== keeper.id) toDelete.push(cat)
      }

      for (const dup of toDelete) {
        // Transférer transactions
        await prisma.transaction.updateMany({
          where: { categoryId: dup.id },
          data: { categoryId: keeper.id },
        })
        // Transférer enfants
        await prisma.category.updateMany({
          where: { parentId: dup.id },
          data: { parentId: keeper.id },
        })
        // Supprimer doublon
        await prisma.category.delete({ where: { id: dup.id } })
        console.log(`🗑️  Fusionné: "${dup.name}" → "${keeper.name}"`)
        merged++
      }
    }
  }
  console.log(merged > 0 ? `   ${merged} doublons fusionnés` : "   Aucun doublon ✓")

  // Séparer parents et enfants
  const parentCategories = defaultCategories.filter((c) => c.parentSlug === null)
  const childCategories = defaultCategories.filter((c) => c.parentSlug !== null)

  console.log(`\n📁 ${parentCategories.length} catégories parentes`)
  console.log(`   └─ ${childCategories.length} sous-catégories\n`)

  // Map slug -> id (pour résoudre les parentId)
  const slugToId = new Map<string, string>()

  let created = 0
  let updated = 0
  let unchanged = 0

  // ═══════════════════════════════════════════════════════════════════════════
  // PHASE 1: Créer/MAJ les catégories parentes
  // ═══════════════════════════════════════════════════════════════════════════
  console.log("═".repeat(50))
  console.log("PHASE 1: Catégories parentes")
  console.log("═".repeat(50))

  for (const category of parentCategories) {
    const result = await upsertCategory(category, null)
    slugToId.set(category.slug, result.id)

    if (result.action === "created") created++
    else if (result.action === "updated") updated++
    else unchanged++
  }

  // ═══════════════════════════════════════════════════════════════════════════
  // PHASE 2: Créer/MAJ les sous-catégories
  // ═══════════════════════════════════════════════════════════════════════════
  console.log("\n" + "═".repeat(50))
  console.log("PHASE 2: Sous-catégories")
  console.log("═".repeat(50))

  for (const category of childCategories) {
    const parentId = slugToId.get(category.parentSlug!)
    if (!parentId) {
      console.log(`⚠️  Parent introuvable pour: ${category.name} (parentSlug: ${category.parentSlug})`)
      continue
    }

    const result = await upsertCategory(category, parentId)
    slugToId.set(category.slug, result.id)

    if (result.action === "created") created++
    else if (result.action === "updated") updated++
    else unchanged++
  }

  // ═══════════════════════════════════════════════════════════════════════════
  // RÉSUMÉ
  // ═══════════════════════════════════════════════════════════════════════════
  console.log("\n" + "═".repeat(50))
  console.log("📊 RÉSUMÉ CATÉGORIES:")
  console.log("═".repeat(50))
  console.log(`   ✅ Créées:       ${created}`)
  console.log(`   ✏️  Mises à jour: ${updated}`)
  console.log(`   ⏭️  Inchangées:   ${unchanged}`)

  // Stats finales
  const totalCategories = await prisma.category.count()
  const parentCount = await prisma.category.count({ where: { parentId: null } })
  const childCount = await prisma.category.count({ where: { NOT: { parentId: null } } })
  const totalKeywords = defaultCategories.reduce((sum, c) => sum + c.keywords.length, 0)

  console.log("\n📈 Base de données:")
  console.log(`   Total catégories: ${totalCategories} (${parentCount} parents, ${childCount} enfants)`)
  console.log(`   Total keywords:   ${totalKeywords}`)
}

// Normaliser un nom (enlever emojis, espaces multiples, lowercase)
function normalizeName(name: string): string {
  return name
    .replace(/[\u{1F300}-\u{1F9FF}]/gu, "") // Remove emojis
    .replace(/[^\w\sÀ-ÿ]/g, "") // Keep only alphanumeric and accents
    .replace(/\s+/g, " ")
    .toLowerCase()
    .trim()
}

async function upsertCategory(
  category: CategoryDefinition,
  parentId: string | null
): Promise<{ id: string; action: "created" | "updated" | "unchanged" }> {
  // Chercher par nom exact d'abord
  let existing = await prisma.category.findFirst({
    where: { name: category.name },
  })

  // Si pas trouvé, chercher par nom normalisé (sans emoji) dans TOUTES les catégories
  if (!existing) {
    const allCategories = await prisma.category.findMany()
    const normalizedTarget = normalizeName(category.name)
    for (const cat of allCategories) {
      if (normalizeName(cat.name) === normalizedTarget) {
        existing = cat
        console.log(`   🔗 Match normalisé: "${cat.name}" → "${category.name}"`)
        break
      }
    }
  }

  if (existing) {
    // Comparer pour voir si mise à jour nécessaire
    const existingKeywords = JSON.parse(existing.keywords) as string[]
    const keywordsChanged =
      JSON.stringify(existingKeywords.sort()) !== JSON.stringify([...category.keywords].sort())
    const nameChanged = existing.name !== category.name
    const colorChanged = existing.color !== category.color
    const iconChanged = existing.icon !== category.icon
    const parentChanged = existing.parentId !== parentId

    if (nameChanged || keywordsChanged || colorChanged || iconChanged || parentChanged) {
      await prisma.category.update({
        where: { id: existing.id },
        data: {
          name: category.name, // Met à jour le nom aussi (ajout emoji)
          color: category.color,
          icon: category.icon,
          keywords: JSON.stringify(category.keywords),
          parentId: parentId,
        },
      })
      console.log(`✏️  MAJ: ${existing.name}${nameChanged ? ` → ${category.name}` : ""}`)
      if (keywordsChanged) {
        console.log(`   └─ Keywords: ${existingKeywords.length} → ${category.keywords.length}`)
      }
      if (parentChanged) {
        console.log(`   └─ Parent modifié`)
      }
      return { id: existing.id, action: "updated" }
    }

    return { id: existing.id, action: "unchanged" }
  }

  // Créer nouvelle catégorie
  const created = await prisma.category.create({
    data: {
      name: category.name,
      color: category.color,
      icon: category.icon,
      keywords: JSON.stringify(category.keywords),
      parentId: parentId,
    },
  })
  console.log(`✅ Créée: ${category.name}${category.keywords.length > 0 ? ` (${category.keywords.length} keywords)` : ""}`)

  return { id: created.id, action: "created" }
}

main()
  .catch((e) => {
    console.error("❌ Erreur:", e)
    process.exit(1)
  })
  .finally(async () => {
    await prisma.$disconnect()
  })