import * as moment from 'moment';
import { ConflictException, Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { FindOperator, Like, Repository } from 'typeorm';
import { Institucion } from '../institucion/entity/institucion.entity';
import { InstitucionInfraccion } from '../institucion-infraccion/entity/institucion-infraccion.entity';
import { Multa } from './entity/multa.entity';
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 { 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>,
    private equipoService: EquipoService,
    private institucionService: InstitucionService,
    private institucionInfraccionService: InstitucionInfraccionService,
    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,
  ) {
    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;
    const data: {
      descripcion: string;
      fecha_inicio: Date;
      opeardorMulta: Operador;
      prestamo: Prestamo;
      fecha_fin?: Date;
      institucionInfraccion?: InstitucionInfraccion;
      retraso?: boolean;
    } = {
      descripcion,
      fecha_inicio: ahora.toDate(),
      opeardorMulta: operador,
      prestamo,
    };
    const institucionInfraccion = id_institucion_infraccion
      ? await this.institucionInfraccionService.findById(
          id_institucion_infraccion,
        )
      : null;

    if (!retraso && !institucionInfraccion)
      throw new ConflictException(
        'No se mandó ningún motivo para multar a este alumno.',
      );
    return this.repository
      .findOne({ prestamo })
      .then((existeMulta) => {
        if (existeMulta)
          throw new ConflictException(
            'Ya existe una multa asignada a este prestamo.',
          );
        if (retraso) {
          data.retraso = true;
          ahora.add(retraso * operador.institucion.dias_multa_retraso, 'd');
        }
        if (institucionInfraccion) {
          data.institucionInfraccion = institucionInfraccion;
          ahora.add(institucionInfraccion.dias_multa, 'd');
        }
        data.fecha_fin = ahora.toDate();
        return this.repository.save(this.repository.create(data));
      })
      .then((_) => {
        prestamo.usuario.multa = true;
        return this.usuarioService.update(prestamo.usuario);
      });
  }

  async findAll(filtros: {
    pagina: string;
    id_institucion?: string;
    usuario?: string;
  }) {
    const busqueda: {
      prestamo: {
        equipo: { carrito: { modulo: { institucion?: Institucion } } };
        usuario: { usuario?: FindOperator<string> };
      };
    } = {
      prestamo: { equipo: { carrito: { modulo: {} } }, usuario: {} },
    };
    const institucion = filtros.id_institucion
      ? await this.institucionService.findById(parseInt(filtros.id_institucion))
      : null;

    if (filtros.usuario)
      busqueda.prestamo.usuario.usuario = Like(filtros.usuario);
    if (institucion)
      busqueda.prestamo.equipo.carrito.modulo.institucion = institucion;
    return this.repository.findAndCount({
      join: {
        alias: 'mu',
        innerJoinAndSelect: {
          p: 'mu.prestamo',
          e: 'p.equipo',
          c: 'e.carrito',
          m: 'c.modulo',
          i: 'm.institucion',
          u: 'p.usuario',
          ci: 'u.institucionCarrera',
          ca: 'ci.carrera',
          n: 'ca.nivel',
        },
      },
      where: busqueda,
      skip: (parseInt(filtros.pagina) - 1) * 25,
      take: 25,
    });
  }

  findAllByIdEquipo(id_equipo: number, pagina: number) {
    return this.equipoService.findById(id_equipo).then((equipo) =>
      this.repository.findAndCount({
        join: {
          alias: 'mu',
          innerJoinAndSelect: {
            p: 'mu.prestamo',
            e: 'p.equipo',
            u: 'p.usuario',
            ci: 'u.institucionCarrera',
            ca: 'ci.carrera',
            n: 'ca.nivel',
          },
        },
        where: { prestamo: { equipo } },
        skip: (pagina - 1) * 25,
        take: 25,
      }),
    );
  }

  findAllByIdUsuario(id_usuario: number, pagina: number) {
    return this.usuarioService.findById(id_usuario).then((usuario) =>
      this.repository.findAndCount({
        join: {
          alias: 'mu',
          innerJoinAndSelect: {
            p: 'mu.prestamo',
            e: 'p.equipo',
            c: 'e.carrito',
            m: 'c.modulo',
            i: 'm.institucion',
          },
        },
        where: { prestamo: { usuario } },
        skip: (pagina - 1) * 25,
        take: 25,
      }),
    );
  }

  desactivarMultas() {
    const ahora = moment();

    return this.repository.find({ activo: true }).then(async (multas) => {
      for (let i = 0; i < multas.length; i++)
        if (ahora.diff(moment(multas[i].fecha_fin)) > 0) {
          multas[i].activo = false;
          multas[i].prestamo.usuario.multa = false;
          await this.usuarioService
            .update(multas[i].prestamo.usuario)
            .then((_) => this.repository.save(multas[i]));
        }
    });
  }
}