import * as moment from 'moment';
import { ConflictException, Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { FindOptionsWhere, Like, Repository } from 'typeorm';
import { Multa } from './entity/multa.entity';
import { FullInformacionMultaView } from './entity/views/full-informacion-multa.view';
import { InformacionMultaView } from './entity/views/informacion-multa.view';
import { Operador } from '../operador/entity/operador.entity';
import { Prestamo } from '../prestamo/entity/prestamo.entity';
import { EquipoService } from '../equipo/equipo.service';
import { InstitucionService } from '../institucion/institucion.service';
import { InstitucionInfraccionService } from '../institucion-infraccion/institucion-infraccion.service';
import { InstitucionUsuarioService } from '../institucion-usuario/institucion-usuario.service';
import { OperadorService } from '../operador/operador.service';
import { PrestamoService } from '../prestamo/prestamo.service';
import { UsuarioService } from '../usuario/usuario.service';

@Injectable()
export class MultaService {
  constructor(
    @InjectRepository(Multa) private repository: Repository<Multa>,
    @InjectRepository(FullInformacionMultaView)
    private fullInformacionMultaView: Repository<FullInformacionMultaView>,
    @InjectRepository(InformacionMultaView)
    private informacionMultaView: Repository<InformacionMultaView>,
    private equipoService: EquipoService,
    private institucionService: InstitucionService,
    private institucionInfraccionService: InstitucionInfraccionService,
    private institucionUsuarioService: InstitucionUsuarioService,
    private operadorService: OperadorService,
    private prestamoService: PrestamoService,
    private usuarioService: UsuarioService,
  ) {}

  async create(
    id_prestamo: number | Prestamo,
    id_operador: number | Operador,
    descripcion: string,
    retraso?: number,
    id_institucion_infraccion?: number,
  ) {
    console.log('hola1');
    const ahora = moment();
    const prestamo =
      typeof id_prestamo === 'number'
        ? await this.prestamoService.findById(id_prestamo)
        : id_prestamo;
    const operador =
      typeof id_operador === 'number'
        ? await this.operadorService.findById(id_operador)
        : id_operador;
    // Creo registro de multa
    const nuevaMulta = this.repository.create({
      descripcion,
      fecha_inicio: ahora.toDate(),
      operadorMulta: operador,
      prestamo,
    });
    let institucionInfraccion = id_institucion_infraccion
      ? await this.institucionInfraccionService.findById(
          id_institucion_infraccion,
        )
      : null;

    // Valido que este prestamo no haya sido cancelado poer el usuario u operador
    if (prestamo.cancelado_operador || prestamo.cancelado_usuario)
      throw new ConflictException(
        'No se puede multar a un usuario con un préstamo que fue cancelado.',
      );
    // Si no se mando un id_institucion_infraccion
    if (!institucionInfraccion) {
      // Si tampoco se mando retraso saco error
      if (!retraso)
        throw new ConflictException(
          'No se mandó ningún motivo para multar a este alumno.',
        );
      // Asigno institucionInfraccion "Sin multa" por default
      institucionInfraccion =
        await this.institucionInfraccionService.findSinInfraccion(
          operador.institucion,
        );
    }
    // Busco una multa con este préstamo
    return this.repository
      .findOne({ where: { prestamo } })
      .then((existeMulta) => {
        // Si existe saco error
        if (existeMulta)
          throw new ConflictException(
            'Ya existe una multa asignada a este préstamo.',
          );
        // Si hay retraso lo agrego a la multa
        if (retraso) {
          nuevaMulta.retraso = true;
          ahora.add(retraso * operador.institucion.dias_multa_retraso, 'd');
        }
        nuevaMulta.institucionInfraccion = institucionInfraccion;
        ahora.add(institucionInfraccion.dias_multa, 'd');
        nuevaMulta.fecha_fin = ahora.toDate();
        // Guardo la información
        return this.repository.save(nuevaMulta);
      })
      .then((_) =>
        // Actualizo multas del usuario
        this.institucionUsuarioService.updateMulta(
          operador.institucion.id_institucion,
          prestamo.usuario.id_usuario,
          true,
        ),
      );
  }

  desactivarMultas() {
    const ahora = moment();

    return this.repository
      .find({ where: { activo: true } })
      .then(async (multas) => {
        for (let i = 0; i < multas.length; i++)
          if (ahora.diff(moment(multas[i].fecha_fin)) > 0) {
            const instituciones = multas[i].prestamo.usuario.instituciones;

            multas[i].activo = false;
            await this.repository.save(multas[i]);
            for (let j = 0; j < instituciones.length; j++) {
              const institucionUsuario = instituciones[j];

              if (
                institucionUsuario.institucionCarrera.institucion
                  .id_institucion ===
                multas[i].operadorMulta.institucion.id_institucion
              ) {
                institucionUsuario.multa = false;
                await this.institucionUsuarioService.save(institucionUsuario);
              }
            }
          }
      });
  }

  async findFullInfoMultaAll(filtros: {
    pagina: string;
    id_institucion?: string;
    usuario?: string;
  }) {
    const institucion = filtros.id_institucion
      ? await this.institucionService.findById(parseInt(filtros.id_institucion))
      : null;
    const busqueda: FindOptionsWhere<FullInformacionMultaView> = {};

    if (filtros.usuario) busqueda.usuario = Like(`%${filtros.usuario}%`);
    if (institucion) busqueda.id_institucion = institucion.id_institucion;
    return this.fullInformacionMultaView
      .findAndCount({
        where: busqueda,
        order: {
          institucion: 'ASC',
          activo: 'DESC',
          id_multa: 'DESC',
          id_usuario: 'ASC',
        },
        skip: (parseInt(filtros.pagina) - 1) * 25,
        take: 25,
      })
      .then((infoMultas) => {
        const multas: Multa[] = [];

        for (let i = 0; i < infoMultas[0].length; i++)
          multas.push(
            this.repository.create(this.fullViewToMulta(infoMultas[0][i])),
          );
        return [multas, infoMultas[1]];
      });
  }

  findAllByIdEquipo(id_equipo: number, pagina: number) {
    return this.equipoService.findById(id_equipo).then((equipo) =>
      this.fullInformacionMultaView
        .findAndCount({
          where: { id_equipo: equipo.id_equipo },
          skip: (pagina - 1) * 25,
          take: 25,
        })
        .then((infoMultas) => {
          const multas: Multa[] = [];

          for (let i = 0; i < infoMultas[0].length; i++)
            multas.push(
              this.repository.create(this.fullViewToMulta(infoMultas[0][i])),
            );
          return [multas, infoMultas[1]];
        }),
    );
  }

  findAllByIdUsuario(id_usuario: number, pagina: number) {
    return this.usuarioService.findById(id_usuario).then((usuario) =>
      this.fullInformacionMultaView
        .findAndCount({
          where: { id_usuario: usuario.id_usuario },
          skip: (pagina - 1) * 25,
          take: 25,
        })
        .then((infoMultas) => {
          const multas: Multa[] = [];

          for (let i = 0; i < infoMultas[0].length; i++)
            multas.push(
              this.repository.create(this.fullViewToMulta(infoMultas[0][i])),
            );
          return [multas, infoMultas[1]];
        }),
    );
  }

  findMultasActivas(id_usuario: number) {
    return this.usuarioService.findById(id_usuario).then((usuario) =>
      this.repository
        .createQueryBuilder('mu')
        .innerJoin('mu.prestamo', 'p')
        .innerJoin('p.usuario', 'u', 'u.id_usuario = :id_usuario', {
          id_usuario: usuario.id_usuario,
        })
        .innerJoinAndSelect('mu.institucionInfraccion', 'ii')
        .innerJoinAndSelect('ii.institucion', 'i')
        .andWhere('mu.activo = 1')
        .getMany(),
    );
  }

  private fullViewToMulta(infoMulta: FullInformacionMultaView) {
    return this.repository.create({
      id_multa: infoMulta.id_multa,
      activo: infoMulta.activo === 1,
      descripcion: infoMulta.descripcion,
      fecha_fin: infoMulta.fecha_fin,
      fecha_inicio: infoMulta.fecha_inicio,
      retraso: infoMulta.retraso === 1,
      institucionInfraccion: {
        id_institucion_infraccion: infoMulta.id_institucion_infraccion,
        infraccion: {
          id_infraccion: infoMulta.id_infraccion,
          infraccion: infoMulta.infraccion,
        },
      },
      operadorMulta: {
        id_operador: infoMulta.id_operador,
        operador: infoMulta.operador,
        institucion: {
          id_institucion: infoMulta.id_institucion,
          institucion: infoMulta.institucion,
        },
      },
      prestamo: {
        id_prestamo: infoMulta.id_prestamo,
        usuario: {
          id_usuario: infoMulta.id_usuario,
          usuario: infoMulta.usuario,
          nombre: infoMulta.nombre,
        },
      },
    });
  }

  async quitarMulta(id_institucion_usuario: number) {
    const institucionUsuario = await this.institucionUsuarioService.findById(
      id_institucion_usuario,
    );

    return this.repository
      .createQueryBuilder('mu')
      .innerJoin('mu.prestamo', 'p')
      .innerJoin('p.usuario', 'u')
      .innerJoin(
        'u.instituciones',
        'is',
        'is.id_institucion_usuario = :id_institucion_usuario',
        { id_institucion_usuario: institucionUsuario.id_institucion_usuario },
      )
      .where('mu.activo = 1')
      .getOne()
      .then((multa) => {
        if (!multa)
          throw new ConflictException(
            'Este usuario no tiene una multa activa en esta institución.',
          );
        multa.activo = false;
        institucionUsuario.multa = false;
        return this.repository.save(multa);
      })
      .then((_) => this.institucionUsuarioService.save(institucionUsuario))
      .then((_) => ({ message: 'Se guardaron los cambios correctamente.' }));
  }
}