import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { DossiersService } from './dossiers.service';
import { Parents } from 'src/entities/parents.entity';
import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
import { ParentsService } from '../parents/parents.service';
import { SuppressionService } from '../suppressions/suppression.service';
import { StatutUtilisateurType } from 'src/entities/users.entity';

describe('DossiersService.listDossiers', () => {
  let service: DossiersService;
  const parentsQb = {
    innerJoinAndSelect: jest.fn().mockReturnThis(),
    leftJoinAndSelect: jest.fn().mockReturnThis(),
    where: jest.fn().mockReturnThis(),
    andWhere: jest.fn().mockReturnThis(),
    getMany: jest.fn(),
  };
  const amQb = {
    innerJoinAndSelect: jest.fn().mockReturnThis(),
    where: jest.fn().mockReturnThis(),
    andWhere: jest.fn().mockReturnThis(),
    getMany: jest.fn(),
  };
  const parentsRepo = {
    createQueryBuilder: jest.fn(() => parentsQb),
    findOne: jest.fn(),
  };
  const amRepo = {
    createQueryBuilder: jest.fn(() => amQb),
    findOne: jest.fn(),
  };
  const parentsService = {
    getDossierFamilleByNumero: jest.fn(),
  };
  const suppressionService = {
    countEnfantsForNumero: jest.fn().mockResolvedValue(1),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        DossiersService,
        { provide: getRepositoryToken(Parents), useValue: parentsRepo },
        { provide: getRepositoryToken(AssistanteMaternelle), useValue: amRepo },
        { provide: ParentsService, useValue: parentsService },
        { provide: SuppressionService, useValue: suppressionService },
      ],
    }).compile();

    service = module.get(DossiersService);
    jest.clearAllMocks();
    parentsRepo.createQueryBuilder.mockReturnValue(parentsQb);
    amRepo.createQueryBuilder.mockReturnValue(amQb);
    suppressionService.countEnfantsForNumero.mockResolvedValue(1);
  });

  it('aggregates famille (pivot+co-parent) and AM, sorts a_valider first', async () => {
    parentsQb.getMany.mockResolvedValue([
      {
        user_id: 'p1',
        numero_dossier: '2026-000010',
        user: {
          id: 'p1',
          email: 'claire@test.fr',
          prenom: 'Claire',
          nom: 'Martin',
          statut: StatutUtilisateurType.ACTIF,
          cree_le: new Date('2026-01-01'),
        },
        co_parent: {
          id: 'p2',
          email: 'thomas@test.fr',
          prenom: 'Thomas',
          nom: 'Martin',
          statut: StatutUtilisateurType.ACTIF,
          cree_le: new Date('2026-01-02'),
        },
      },
      {
        user_id: 'p3',
        numero_dossier: '2026-000020',
        user: {
          id: 'p3',
          email: 'pending@test.fr',
          prenom: 'Paul',
          nom: 'Pending',
          statut: StatutUtilisateurType.EN_ATTENTE,
          cree_le: new Date('2026-02-01'),
        },
        co_parent: undefined,
      },
    ]);
    amQb.getMany.mockResolvedValue([
      {
        user_id: 'am1',
        numero_dossier: '2026-000015',
        user: {
          id: 'am1',
          email: 'am@test.fr',
          prenom: 'Marie',
          nom: 'Dupont',
          statut: StatutUtilisateurType.ACTIF,
          cree_le: new Date('2026-01-15'),
        },
      },
    ]);

    const list = await service.listDossiers();
    expect(list).toHaveLength(3);
    expect(list[0].a_valider).toBe(true);
    expect(list[0].type).toBe('famille');
    expect(list[0].numero_dossier).toBe('2026-000020');

    const famille = list.find((i) => i.numero_dossier === '2026-000010')!;
    expect(famille.type).toBe('famille');
    expect(famille.user_ids).toEqual(expect.arrayContaining(['p1', 'p2']));
    expect(famille.emails).toHaveLength(2);
    expect(famille.libelle).toContain('MARTIN');

    const am = list.find((i) => i.type === 'assistante_maternelle')!;
    expect(am.numero_dossier).toBe('2026-000015');
    expect(am.libelle).toContain('Marie');
  });

  it('filters with q', async () => {
    parentsQb.getMany.mockResolvedValue([]);
    amQb.getMany.mockResolvedValue([
      {
        user_id: 'am1',
        numero_dossier: '2026-000015',
        user: {
          id: 'am1',
          email: 'am@test.fr',
          prenom: 'Marie',
          nom: 'Dupont',
          statut: StatutUtilisateurType.ACTIF,
          cree_le: new Date('2026-01-15'),
        },
      },
    ]);

    const hit = await service.listDossiers('dupont');
    expect(hit).toHaveLength(1);
    const miss = await service.listDossiers('zzz');
    expect(miss).toHaveLength(0);
  });
});