import {
  ConflictException,
  Injectable,
  NotFoundException,
} from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Not, Repository } from 'typeorm';
import { InstitucionPrograma } from './entity/institucion-programa.entity';
import { Operador } from '../operador/entity/operador.entity';
import { Programa } from './entity/programa.entity';
import { InstitucionService } from '../institucion/institucion.service';

@Injectable()
export class InstitucionProgramaService {
  constructor(
    @InjectRepository(InstitucionPrograma)
    private institucionProgramaRepository: Repository<InstitucionPrograma>,
    @InjectRepository(Programa)
    private programaRepository: Repository<Programa>,
    private institucionService: InstitucionService,
  ) {}

  create(programa: string) {
    return this.programaRepository
      .findOne({ programa })
      .then((existePrograma) => {
        if (existePrograma)
          throw new ConflictException('Ya existe este programa.');
        return this.programaRepository.save(
          this.programaRepository.create({ programa }),
        );
      })
      .then(async (programa) => {
        const instituciones = await this.institucionService.findAll();

        for (let i = 0; i < instituciones.length; i++)
          await this.institucionProgramaRepository.save(
            this.institucionProgramaRepository.create({
              institucion: instituciones[i],
              programa,
            }),
          );
        return { message: 'Se creó correctamente un nuevo programa.' };
      });
  }

  async findAllByIdInstitucion(id_institucion: number, mostrar = false) {
    const institucion = await this.institucionService.findById(id_institucion);
    const query = this.institucionProgramaRepository
      .createQueryBuilder('ip')
      .innerJoinAndSelect('ip.programa', 'p', 'p.id_programa != 1')
      .innerJoinAndSelect(
        'ip.institucion',
        'i',
        'i.id_institucion = :id_institucion',
        { id_institucion: institucion.id_institucion },
      )
      .orderBy('p.programa');

    if (mostrar) query.andWhere('ip.mostrar = 1');
    return query.getMany();
  }

  findAllProgramas() {
    return this.programaRepository.find({
      where: { id_programa: Not(1) },
      order: { programa: 'ASC' },
    });
  }

  findById(id_institucion_programa: number) {
    return this.institucionProgramaRepository
      .findOne({
        join: {
          alias: 'ip',
          innerJoinAndSelect: { i: 'ip.institucion', p: 'ip.programa' },
        },
        where: { id_institucion_programa },
      })
      .then((institucionPrograma) => {
        if (!institucionPrograma)
          throw new NotFoundException('No existe esta institucion programa.');
        return institucionPrograma;
      });
  }

  findProgramaById(id_programa: number) {
    return this.programaRepository.findOne({ id_programa }).then((programa) => {
      if (!programa) throw new NotFoundException('No existe este programa.');
      return programa;
    });
  }

  findProgramaByPrograma(programa: string, validarNoExiste = true) {
    return this.programaRepository.findOne({ programa }).then((programa) => {
      if (validarNoExiste && !programa)
        throw new NotFoundException('No existe este programa.');
      return programa;
    });
  }

  update(admin: Operador, attrs: Partial<InstitucionPrograma>) {
    return this.findById(attrs.id_institucion_programa)
      .then((institucionPrograma) => {
        if (
          admin.institucion.id_institucion !=
          institucionPrograma.institucion.id_institucion
        )
          throw new ConflictException(
            'No puedes actualizar la información de este software porque no le pertenece a tu institución.',
          );
        Object.assign(institucionPrograma, attrs);
        return this.institucionProgramaRepository.save(institucionPrograma);
      })
      .then((_) => ({
        message: 'Se guardaron los cambios correctamente.',
      }));
  }
}