import {
  BadRequestException,
  Injectable,
  InternalServerErrorException,
} from '@nestjs/common';
import { AlumnoService } from 'src/alumno/student.service';
import { DetalleServicioService } from 'src/detalle_servicio/detalle_servicio.service';
import { DataSource } from 'typeorm';
import { chargePrintDto } from './dto/operations.dto';
import { UserService } from 'src/user/user.service';
import { ReciboService } from 'src/recibo/recibo.service';
import { AlumnoInscritoService } from 'src/alumno_inscrito/alumno_inscrito.service';
import { PeriodoService } from 'src/periodo/periodo.service';

@Injectable()
export class OperationsService {
  constructor(
    private readonly dataSource: DataSource,
    private readonly alumnoService: AlumnoService,
    private readonly alumnoInscritoService: AlumnoInscritoService,
    private readonly detalleServicioService: DetalleServicioService,
    private readonly userService: UserService,
    private readonly reciboService: ReciboService,
    private readonly periodoService: PeriodoService,
  ) {}

  async chargePrint(data: chargePrintDto, id_usuario: number) {
    const { monto, id_cuenta, id_servicio, numero_hojas } = data;

    const queryRunner = this.dataSource.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction();

    try {
      const credit = await this.alumnoService.GetCredit(id_cuenta);

      if (credit < monto) {
        throw new BadRequestException('Crédito insuficiente');
      }

      const user = await this.userService.findOne(id_usuario);
      const alum = await this.alumnoService.findOne(id_cuenta);

      const detalleData = {
        servicio: id_servicio,
        user,
        alum,
        monto,
        fecha_operacion: new Date(),
        numero_hojas,
      };

      await this.detalleServicioService.Create(
        detalleData,
        queryRunner.manager,
      );

      await this.alumnoService.collectCredit(
        id_cuenta,
        monto,
        queryRunner.manager,
      );

      await queryRunner.commitTransaction();
      return { message: 'correct' };
    } catch (error) {
      await queryRunner.rollbackTransaction();
      throw new InternalServerErrorException(error.message);
    } finally {
      await queryRunner.release();
    }
  }

  async addCredit(data, id_usuario: number) {
    const { id_cuenta, monto, fecha_recibo, folio_recibo } = data;

    const ticket = await this.reciboService.findOne(folio_recibo);

    if (ticket) {
      throw new BadRequestException('Ticket ya existente');
    }

    const queryRunner = this.dataSource.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction();

    const user = await this.userService.findOne(id_usuario);
    const alum = await this.alumnoService.findOne(id_cuenta);

    try {
      const detalleData = {
        folio_recibo,
        user,
        alum,
        fecha_recibo,
        monto,
      };

      await this.reciboService.create(detalleData, queryRunner.manager);

      await this.alumnoService.addCredit(id_cuenta, monto, queryRunner.manager);

      await queryRunner.commitTransaction();
      return { message: 'correct' };
    } catch (error) {
      await queryRunner.rollbackTransaction();
      throw new InternalServerErrorException(error.message);
    } finally {
      await queryRunner.release();
    }
  }

  async addTime(data, id_usuario: number) {
    const { monto, id_cuenta, idPlataforma, folio_recibo, fecha_recibo } = data;

    const studentRegister = await this.alumnoInscritoService.findRegister(
      id_cuenta,
      idPlataforma,
    );

    const queryRunner = this.dataSource.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction();

    const user = await this.userService.findOne(id_usuario);
    const alum = await this.alumnoService.findOne(id_cuenta);

    try {
      const detalleRecibo = {
        folio_recibo,
        user,
        alum,
        fecha_recibo,
        monto,
      };

      await this.reciboService.create(detalleRecibo, queryRunner.manager);

      const detalleData = {
        servicio: 5,
        user,
        alum,
        monto,
        fecha_operacion: new Date(),
      };

      await this.detalleServicioService.Create(
        detalleData,
        queryRunner.manager,
      );

      studentRegister.tiempo_disponible += 3600;

      await this.alumnoInscritoService.save(
        studentRegister,
        queryRunner.manager,
      );

      await queryRunner.commitTransaction();
      return { studentRegister };
    } catch (error) {
      await queryRunner.rollbackTransaction();
      throw new InternalServerErrorException(error.message);
    } finally {
      await queryRunner.release();
    }
  }

  async addReceiptInscription(data, id_usuario: number) {
    const {
      monto,
      id_cuenta,
      id_plataforma,
      folio_recibo,
      fecha_recibo,
      realizo_pago,
    } = data;

    await this.alumnoInscritoService.findNotRegister(id_cuenta, id_plataforma);

    const queryRunner = this.dataSource.createQueryRunner();
    await queryRunner.connect();
    await queryRunner.startTransaction();

    const user = await this.userService.findOne(id_usuario);
    const alum = await this.alumnoService.findOne(id_cuenta);

    try {
      const detalleRecibo = {
        folio_recibo,
        user,
        alum,
        fecha_recibo,
        monto,
      };

      await this.reciboService.create(detalleRecibo, queryRunner.manager);

      const detalleData = {
        servicio: 4,
        user,
        alum,
        monto,
        fecha_operacion: new Date(),
      };

      await this.detalleServicioService.Create(
        detalleData,
        queryRunner.manager,
      );

      const periodo = await this.periodoService.getPeriodoActivo();
      const plataforma =
        await this.alumnoInscritoService.findPlataformaById(id_plataforma);

      await this.alumnoInscritoService.create(
        { realizo_pago, alumno: alum, plataforma, periodo },
        queryRunner.manager,
      );

      await queryRunner.commitTransaction();
    } catch (error) {
      await queryRunner.rollbackTransaction();
      throw new InternalServerErrorException(error.message);
    } finally {
      await queryRunner.release();
    }
  }
}