import { HttpException, Injectable } from '@nestjs/common';
import { Profesor } from './entities/profesor.entity';
import { DatosAcademicosService } from '../datos_academicos/datos_academicos.service';
import { LineasInvestigacionService } from '../lineas_investigacion/lineas_investigacion.service';
import { ProyectosAcademicosService } from '../proyectos_academicos/proyectos_academicos.service';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { profesorDto } from './dto/profesorDto.dto';
import { ProyectosAcademicos } from '../proyectos_academicos/entities/proyectos_academicos.entity';
import { DatosAcademicos } from '../datos_academicos/entities/datos_academicos.entity'
import { LineasInvestigacion } from '../lineas_investigacion/entities/lineas_investigacion.entity'

@Injectable()
export class ProfesorService {
  constructor(
    @InjectRepository(Profesor) private profesorRepository: Repository<Profesor>,
    private datosAcademicosService: DatosAcademicosService,
    private lineasInvestigacionService: LineasInvestigacionService,
    private proyectosAcademicosService: ProyectosAcademicosService,
    @InjectRepository(ProyectosAcademicos)
    private readonly proyectosAcademicosRepository: Repository<ProyectosAcademicos>,
    @InjectRepository(DatosAcademicos)
    private readonly datosAcademicosRepository: Repository<DatosAcademicos>,
    @InjectRepository(LineasInvestigacion)
    private readonly lineasInvestigacionRepository: Repository<LineasInvestigacion>,
  ) {}

  //register teacher
  async register(data: profesorDto) {
    const {num_trabajador,rfc,proyectosAcademicos, datosAcademicos, lineasInvestigacion } = data;

    const existrfc = await this.profesorRepository.findOne({where:{rfc}});
    if(existrfc){
      throw new HttpException('rfc already exist', 403);
    }

    const existnumber = await this.profesorRepository.findOne({where:{num_trabajador}});
    if(existnumber){
      throw new HttpException('number of worker already exist', 403);
    }

    const newProfesor = this.profesorRepository.create(data);
    const savedProfesor = await this.profesorRepository.save(newProfesor);

    if (proyectosAcademicos && proyectosAcademicos.length > 0) {
      const proyectos = proyectosAcademicos.map(proyecto => {
        const newProyecto = this.proyectosAcademicosRepository.create({
          ...proyecto,
          profesor: savedProfesor,
          id_profesor: savedProfesor.id_profesor,
        });
        return newProyecto;
      });
      await this.proyectosAcademicosRepository.save(proyectos);
    }

    if (datosAcademicos && datosAcademicos.length > 0) {
      const datos = datosAcademicos.map(dato => {
        const newDato = this.datosAcademicosRepository.create({
          ...dato,
          profesor: savedProfesor,
          id_profesor: savedProfesor.id_profesor,
        });
        return newDato;
      });
      await this.datosAcademicosRepository.save(datos);
    }

    if (lineasInvestigacion && lineasInvestigacion.length > 0) {
      const lineas = lineasInvestigacion.map(linea => {
        const newLinea = this.lineasInvestigacionRepository.create({
          ...linea,
          profesor: savedProfesor,
          id_profesor: savedProfesor.id_profesor,
        });
        return newLinea;
      });
      await this.lineasInvestigacionRepository.save(lineas);
    }

    return savedProfesor;
  }

  //brings all teachers
  async findAll(): Promise<Profesor[]> {
    return this.profesorRepository.find({
      order: {
        nombre: 'ASC',
      },
    });
  }

  //modify teacher
  async modify(id_profesor: number, data: profesorDto) {
    const profesor = await this.profesorRepository.findOne({ where: { id_profesor } });
    if (!profesor) {
      throw new HttpException('Profesor not found', 404);
    }

    const { proyectosAcademicos, datosAcademicos, lineasInvestigacion, ...profesorData } = data;
    Object.assign(profesor, profesorData);
    const savedProfesor = await this.profesorRepository.save(profesor);

    if (proyectosAcademicos) {
      await this.proyectosAcademicosRepository.delete({ profesor: { id_profesor } });
      const proyectos = proyectosAcademicos.map(proyecto => {
        const newProyecto = this.proyectosAcademicosRepository.create({
          ...proyecto,
          profesor: savedProfesor,
          id_profesor: savedProfesor.id_profesor,
        });
        return newProyecto;
      });
      await this.proyectosAcademicosRepository.save(proyectos);
    }

    if (datosAcademicos) {
      await this.datosAcademicosRepository.delete({ profesor: { id_profesor } });
      const datos = datosAcademicos.map(dato => {
        const newDato = this.datosAcademicosRepository.create({
          ...dato,
          profesor: savedProfesor,
          id_profesor: savedProfesor.id_profesor,
        });
        return newDato;
      });
      await this.datosAcademicosRepository.save(datos);
    }

    if (lineasInvestigacion) {
      await this.lineasInvestigacionRepository.delete({ profesor: { id_profesor } });
      const lineas = lineasInvestigacion.map(linea => {
        const newLinea = this.lineasInvestigacionRepository.create({
          ...linea,
          profesor: savedProfesor,
          id_profesor: savedProfesor.id_profesor,
        });
        return newLinea;
      });
      await this.lineasInvestigacionRepository.save(lineas);
    }

    return savedProfesor;
  }

  //remove teacher
  async remove(id_profesor: number) {
    const profesor = await this.profesorRepository.findOne({ where: { id_profesor }, relations: ['datosAcademicos'] });
    if (!profesor) {
      throw new HttpException('Profesor not found', 404);
    }

    // Delete related records in datos_academicos
    await this.datosAcademicosService.removeByProfesorId(id_profesor);
    await this.lineasInvestigacionService.removeByProfesorId(id_profesor);
    await this.proyectosAcademicosService.removeByProfesorId(id_profesor);

    await this.profesorRepository.remove(profesor);
    return { message: 'Profesor removed successfully' };
  }

  //brings teachers by id
  async profile(id_profesor: number) {
    const profesor = await this.profesorRepository.findOne({
      where: { id_profesor },
      relations: ['proyectosAcademicos', 'datosAcademicos', 'lineasInvestigacion'],
    });
    
    if (!profesor) {
      throw new HttpException('Profesor not found', 404);
    }

    return profesor;
  }

  //brings teachers by filter
  async filter(filterDto: profesorDto): Promise<Profesor[]> {
    const query = this.profesorRepository.createQueryBuilder('profesor');

    if (filterDto.nombre) {
      query.andWhere('profesor.nombre like :nombre', { nombre: `%${filterDto.nombre}%` });
    }

    if (filterDto.id_categoria !== undefined) {
      query.andWhere('profesor.id_categoria = :id_categoria', { id_categoria: filterDto.id_categoria });
    }

    if (filterDto.extension) {
      query.andWhere('profesor.extension like :extension', { extension: `%${filterDto.extension}%` });
    }

    if (filterDto.id_adscripcion !== undefined) {
      query.andWhere('profesor.id_adscripcion = :id_adscripcion', { id_adscripcion: filterDto.id_adscripcion });
    }

    if (filterDto.id_edificio !== undefined) {
      query.andWhere('profesor.id_edificio = :id_edificio', { id_edificio: filterDto.id_edificio });
    }

    if (filterDto.activo !== undefined) {
      query.andWhere('profesor.activo = :activo', { activo: filterDto.activo });
    }

    return query.getMany();
  }

  async findAllPaginated(
    page: number,
    limit: number,
    filters: any
  ): Promise<{ profesores: Profesor[], total: number, totalPages: number }> {
    const query = this.profesorRepository.createQueryBuilder('profesor')

    if (filters.nombre) {
      query.andWhere('profesor.nombre LIKE :nombre', { nombre: `%${filters.nombre}%` });
    }

    if (filters.adscripcion) {
      query.andWhere('profesor.adscripcion = :adscripcion', { adscripcion: filters.adscripcion });
    }

    if (filters.categoria) {
      query.andWhere('profesor.categoria = :categoria', { categoria: filters.categoria });
    }

    if (filters.edificio) {
      query.andWhere('profesor.edificio = :edificio', { edificio: filters.edificio });
    }

    const [profesores, total] = await query
      .skip((page - 1) * limit)
      .take(limit)
      .orderBy('profesor.nombre', 'ASC')
      .getManyAndCount();

    const totalPages = Math.ceil(total / limit);

    return { profesores, total, totalPages };
  }
  
}