import { PrismaClient, Roles } from '@prisma/client';

const prisma = new PrismaClient();

// base sans underscore, en string
const BASE_PHONE = '1100000000';

function emailFor(i: number) {
  return `user${i + 1}@example.test`;
}

async function main() {
  type UserSeed = {
    first_name: string;
    last_name: string;
    email: string;
    phone_number: string;
    residence?: string | null;
    role: Roles;
  };

  const usersData: UserSeed[] = [];

  const firstNames = ['Alex', 'Sam', 'Chris', 'Jordan', 'Taylor', 'Morgan', 'Jamie', 'Robin', 'Avery', 'Casey'];
  const lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Miller', 'Davis', 'Wilson', 'Taylor', 'Clark'];

  const pick = <T,>(arr: T[]) => arr[Math.floor(Math.random() * arr.length)];

  /**
   * Objectif total: 50 users
   * - 39 employés génériques (dont ADMIN=1, SUPERVISOR=3, HR=1, ACCOUNTING=1, EMPLOYEE=33)
   * - +1 superviseur spécial "User Test" (=> 40 employés)
   * - 10 customers
   */
  const rolesForEmployees39: Roles[] = [
    Roles.ADMIN,                         // 1
    ...Array(3).fill(Roles.SUPERVISOR),  // 3 supervisors (le 4e sera "User Test")
    Roles.HR,                            // 1
    Roles.ACCOUNTING,                    // 1
    ...Array(33).fill(Roles.EMPLOYEE),   // 33
    // total = 39
  ];

  // --- 39 employés génériques: user1..user39@example.test
  for (let i = 0; i < 39; i++) {
    const fn = pick(firstNames);
    const ln = pick(lastNames);
    usersData.push({
      first_name: fn,
      last_name: ln,
      email: emailFor(i),
      phone_number: BASE_PHONE + i.toString(),
      residence: Math.random() < 0.5 ? 'QC' : 'ON',
      role: rolesForEmployees39[i],
    });
  }

  // --- 10 customers: user40..user49@example.test
  for (let i = 39; i < 49; i++) {
    const fn = pick(firstNames);
    const ln = pick(lastNames);
    usersData.push({
      first_name: fn,
      last_name: ln,
      email: emailFor(i),
      phone_number: BASE_PHONE + i.toString(),
      residence: Math.random() < 0.5 ? 'QC' : 'ON',
      role: Roles.CUSTOMER,
    });
  }

  // 1) Insert des 49 génériques (skipDuplicates pour rejouer le seed sans erreurs)
  await prisma.users.createMany({ data: usersData, skipDuplicates: true });

  // 2) Upsert du superviseur spécial "User Test"
  const specialEmail = 'user@targointernet.com';
  const specialUser = await prisma.users.upsert({
    where: { email: specialEmail },
    update: {
      first_name: 'User',
      last_name: 'Test',
      role: Roles.SUPERVISOR,
      residence: 'QC',
      phone_number: BASE_PHONE + '999',
    },
    create: {
      first_name: 'User',
      last_name: 'Test',
      email: specialEmail,
      role: Roles.SUPERVISOR,
      residence: 'QC',
      phone_number: BASE_PHONE + '999',
    },
  });

  // 3) Créer/mettre à jour les entrées Employees pour tous les rôles employés
  const employeeUsers = await prisma.users.findMany({
    where: { role: { in: [Roles.ADMIN, Roles.SUPERVISOR, Roles.HR, Roles.ACCOUNTING, Roles.EMPLOYEE] } },
    orderBy: { email: 'asc' },
  });

  const firstWorkDay = new Date('2025-01-06'); // à adapter à ton contexte

  for (let i = 0; i < employeeUsers.length; i++) {
    const u = employeeUsers[i];
    await prisma.employees.upsert({
      where: { user_id: u.id },
      update: {
        is_supervisor: u.role === Roles.SUPERVISOR,
        job_title: u.role,
      },
      create: {
        user_id: u.id,
        is_supervisor: u.role === Roles.SUPERVISOR,
        external_payroll_id: 1000 + i, // à adapter
        company_code: 1,               // à adapter
        first_work_day: firstWorkDay,
        job_title: u.role,
      },
    });
  }

  // 4) Répartition des 33 EMPLOYEE sur 4 superviseurs: 8/8/8/9 (9 pour User Test)
  const supervisors = await prisma.employees.findMany({
    where: { is_supervisor: true, user: { role: Roles.SUPERVISOR } },
    include: { user: true },
    orderBy: { id: 'asc' },
  });

  const userTestSupervisor = supervisors.find((s) => s.user.email === specialEmail);
  if (!userTestSupervisor) {
    throw new Error('Employee(User Test) introuvable — vérifie le upsert Users/Employees.');
  }

  const plainEmployees = await prisma.employees.findMany({
    where: { is_supervisor: false, user: { role: Roles.EMPLOYEE } },
    orderBy: { id: 'asc' },
  });

  // Si la configuration est bien 4 superviseurs + 33 employés, on force 8/8/8/9 avec 9 pour User Test.
  if (supervisors.length === 4 && plainEmployees.length === 33) {
    const others = supervisors.filter((s) => s.id !== userTestSupervisor.id);
    // ordre: autres (3) puis User Test en dernier (reçoit 9)
    const ordered = [...others, userTestSupervisor];

    const chunks = [
      plainEmployees.slice(0, 8),   // -> sup 0
      plainEmployees.slice(8, 16),  // -> sup 1
      plainEmployees.slice(16, 24), // -> sup 2
      plainEmployees.slice(24, 33), // -> sup 3 (User Test) = 9
    ];

    for (let b = 0; b < chunks.length; b++) {
      const sup = ordered[b];
      for (const emp of chunks[b]) {
        await prisma.employees.update({
          where: { id: emp.id },
          data: { supervisor_id: sup.id },
        });
      }
    }
  } else {
    // fallback: distribution round-robin si la config diffère
    console.warn(
      `Répartition fallback (round-robin). Supervisors=${supervisors.length}, Employees=${plainEmployees.length}`
    );
    const others = supervisors.filter((s) => s.id !== userTestSupervisor.id);
    const ordered = [...others, userTestSupervisor];
    for (let i = 0; i < plainEmployees.length; i++) {
      const sup = ordered[i % ordered.length];
      await prisma.employees.update({
        where: { id: plainEmployees[i].id },
        data: { supervisor_id: sup.id },
      });
    }
  }

  // 5) Sanity checks
  const totalUsers = await prisma.users.count();
  const supCount = await prisma.users.count({ where: { role: Roles.SUPERVISOR } });
  const empCount = await prisma.users.count({ where: { role: Roles.EMPLOYEE } });

  const countForUserTest = await prisma.employees.count({
    where: { supervisor_id: userTestSupervisor.id, is_supervisor: false },
  });

  console.log(`✓ Users total: ${totalUsers} (attendu 50)`);
  console.log(`✓ Supervisors: ${supCount} (attendu 4)`);
  console.log(`✓ Employees  : ${empCount} (attendu 33)`);
  console.log(`✓ Employés sous User Test: ${countForUserTest} (attendu 9)`);
}

main()
  .catch((e) => {
    console.error(e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });