/**
 * Migration Script: ApplicationMessage → Conversation + Message
 * 
 * Migrates existing application-scoped messages into the new Conversation/Message system.
 * Run with: npx tsx scripts/migrate-messages.ts
 */

import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

async function migrateMessages() {
    console.log("🔄 Starting message migration...");

    // 1. Find all applications that have messages
    const applicationsWithMessages = await prisma.applicationMessage.findMany({
        select: {
            application_id: true,
        },
        distinct: ["application_id"],
    });

    const applicationIds = applicationsWithMessages.map((m) => m.application_id);
    console.log(`📋 Found ${applicationIds.length} applications with messages to migrate.`);

    let conversationsCreated = 0;
    let messagesMigrated = 0;
    let skipped = 0;

    for (const applicationId of applicationIds) {
        // Check if a conversation already exists for this application
        const existingConversation = await prisma.conversation.findUnique({
            where: { application_id: applicationId },
        });

        if (existingConversation) {
            skipped++;
            continue;
        }

        // Get the application with its candidate and job employer
        const application = await prisma.application.findUnique({
            where: { id: applicationId },
            include: {
                job: { select: { employer_id: true } },
                candidate: { select: { id: true } },
            },
        });

        if (!application) {
            console.warn(`⚠️  Application ${applicationId} not found, skipping.`);
            skipped++;
            continue;
        }

        // Get all messages for this application, ordered by creation
        const appMessages = await prisma.applicationMessage.findMany({
            where: { application_id: applicationId },
            orderBy: { created_at: "asc" },
        });

        if (appMessages.length === 0) continue;

        const lastMsg = appMessages[appMessages.length - 1];

        // Create the conversation
        const conversation = await prisma.conversation.create({
            data: {
                type: "application",
                application_id: applicationId,
                created_by: application.job.employer_id,
                last_message_at: lastMsg.created_at,
                last_message_preview: lastMsg.message.substring(0, 200),
                status: "active",
                participants: {
                    create: [
                        {
                            user_id: application.job.employer_id,
                            role: "creator",
                            unread_count: 0,
                        },
                        {
                            user_id: application.candidate_id,
                            role: "member",
                            unread_count: 0,
                        },
                    ],
                },
                messages: {
                    create: appMessages.map((msg) => ({
                        sender_id: msg.sender_id,
                        content: msg.message,
                        message_type: msg.message_type || "text",
                        is_deleted: false,
                        is_edited: false,
                        metadata: msg.attachment_url
                            ? { legacy_attachment_url: msg.attachment_url }
                            : undefined,
                        created_at: msg.created_at,
                    })),
                },
            },
        });

        conversationsCreated++;
        messagesMigrated += appMessages.length;

        if (conversationsCreated % 50 === 0) {
            console.log(`   ✅ Migrated ${conversationsCreated} conversations (${messagesMigrated} messages)...`);
        }
    }

    console.log("\n📊 Migration Summary:");
    console.log(`   Conversations created: ${conversationsCreated}`);
    console.log(`   Messages migrated:     ${messagesMigrated}`);
    console.log(`   Skipped (already exist): ${skipped}`);
    console.log("✅ Migration complete!");
}

migrateMessages()
    .catch((e) => {
        console.error("❌ Migration failed:", e);
        process.exit(1);
    })
    .finally(() => prisma.$disconnect());
