import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
import { BaseService } from 'src/common/base.service';
import { InjectRepository } from '@nestjs/typeorm';
import { DeepPartial, Repository } from 'typeorm';
import { RoleType, Users } from 'src/entities/users.entity';
import { UpdateAssistanteDto } from '../user/dto/update_assistante.dto';
import { AssistanteMaternelle } from 'src/entities/assistantes_maternelles.entity';
import { CreateAssistanteDto } from '../user/dto/create_assistante.dto';

@Injectable()
export class AssistantesMaternellesService extends BaseService<AssistanteMaternelle> {
  constructor(
    @InjectRepository(AssistanteMaternelle)
    private readonly assistantesMaternelleRepository: Repository<AssistanteMaternelle>,
    private readonly usersRepository: Repository<Users>
  ) {
    super(assistantesMaternelleRepository);
  }

  override async create(data: DeepPartial<AssistanteMaternelle>): Promise<AssistanteMaternelle> {
    const dto = data as CreateAssistanteDto;
    const user = await this.usersRepository.findOneBy({ id: dto.user_id });
    if (!user) throw new NotFoundException('Utilisateur introuvable');
    if (user.role !== RoleType.ASSISTANTE_MATERNELLE) throw new BadRequestException('Acces reserve aux assistantes maternelles');
    const exist = await this.assistantesMaternelleRepository.findOneBy({ user_id: dto.user_id });
    if (exist) throw new ConflictException('Assistante maternelle deja existante');

    const entity = this.assistantesMaternelleRepository.create({
      user_id: dto.user_id,
      user: { ...user, role: RoleType.ASSISTANTE_MATERNELLE },
      approval_number: dto.numero_agrement,
      birthdate: new Date(dto.date_naissance),
      birthplace_city: dto.ville_naissance,
      birthplace_country: dto.pays_naissance,
      nir: dto.nir_chiffre,
      max_children: dto.nb_max_enfants,
      biography: dto.biographie,
      available: dto.disponible ?? true,
      city: dto.ville_residence,

    });
    return this.assistantesMaternelleRepository.save(entity);
  }

  override async findAll(): Promise<AssistanteMaternelle[]> {
    return this.assistantesMaternelleRepository.find({
      relations: ['user'],
    });
  }

  override async findOne(user_id: string): Promise<AssistanteMaternelle> {
    const assistante_maternelle = await this.assistantesMaternelleRepository.findOne({
      where: { user_id },
      relations: ['user'],
    });
    if (!assistante_maternelle) throw new NotFoundException('Assistante maternelle introuvable');
    return assistante_maternelle;
  }

  async update(id: string, dto: UpdateAssistanteDto): Promise<AssistanteMaternelle> {
    await this.assistantesMaternelleRepository.update(id, dto);
    return this.findOne(id);
  }

  async remove(id: string): Promise<void> {
    await this.assistantesMaternelleRepository.delete(id);
  }
}