import { ConflictException, ForbiddenException, Injectable, NotFoundException } from '@nestjs/common';
import { BaseService } from 'src/common/base.service';
import { Repository } from 'typeorm';
import { RoleType, Users } from 'src/entities/users.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { UpdateGestionnaireDto } from '../user/dto/update_gestionnaire.dto';
import { CreateGestionnaireDto } from '../user/dto/create_gestionnaire.dto';

@Injectable()
export class GestionnairesService extends BaseService<Users> {
  constructor(
    @InjectRepository(Users)
    private readonly gestionnaireRepository: Repository<Users>,
  ) {
    super(gestionnaireRepository);
  }
  override async create(dto: CreateGestionnaireDto): Promise<Users> {

    const exist = await this.gestionnaireRepository.findOneBy({ email: dto.email });
    if (exist) throw new ConflictException('Email déjà utilise');

    const entity = this.gestionnaireRepository.create({
      ...dto,
      role: RoleType.GESTIONNAIRE,
    });
    return this.gestionnaireRepository.save(entity);
  }

  override async findAll(): Promise<Users[]> {
    // Retourner seulement les utilisateurs avec le rôle de gestionnaire
    const all_gestionnaires = await this.gestionnaireRepository.find({ where: { role: RoleType.GESTIONNAIRE } });
    return all_gestionnaires;
  }

  override async findOne(id: string): Promise<Users> {
    const gestionnaire = await this.gestionnaireRepository.findOne({ where: { id, role: RoleType.GESTIONNAIRE } });
    if (!gestionnaire) throw new NotFoundException('Gestionnaire introuvable');
    return gestionnaire;
  }

  async update(id: string, dto: UpdateGestionnaireDto): Promise<Users> {
    await this.gestionnaireRepository.update(id, dto);
    return this.findOne(id);
  }

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