import { ObjeniousLine } from "sim-shared/domain/objeniousLine.js";
import { PauseCancelTaskRepository } from "sim-consumidor-objenious/infrastructure/PauseCancelTaskRepository.js";
import { ObjeniousOperationsRepository } from "sim-shared/infrastructure/ObjeniousOperationRepository.js";
import { SimUseCases } from "sim-consumidor-objenious/aplication/Sim.usecases.js";
import { OrderRepository } from "sim-shared/infrastructure/OrderRepository.js";

const logger =
{
  log: (...data: any[]) => console.log("[i] [TaskPauseTerminate]", ...data),
  error: (...data: any[]) => console.error("[x] [TaskPauseTerminate] ", ...data),
}


export class PauseTerminateTask {
  constructor(
    private readonly objeniousRepo: ObjeniousOperationsRepository,
    private readonly pauseRepo: PauseCancelTaskRepository,
    private readonly simUsecases: SimUseCases,
    private readonly orderRepo: OrderRepository
  ) {
  }

  public async run() {
    const finError = (err: any) => {
      logger.error("Finalizado con errores proceso de comprobacion de lineas en pausa o canceladas")
      logger.error(err)
    }

    const finExito = () => {
      logger.log("Finalizado con exito proceso de comprobacion de lineas en pausa o canceladas")
    }
    try {
      logger.log("Iniciando proceso de comprobacion de lineas en pausa o canceladas")

      // 1. Se comprueba cuantas peticiones hay qye revisar
      const peticionesRevisar = await this.pauseRepo.getPending()

      if (peticionesRevisar.error != undefined) {
        finError(peticionesRevisar.error)
        return 1;
      }

      logger.log(`Se van a revisar ${peticionesRevisar.data?.length} peticiones`)
      if (peticionesRevisar.data == undefined || peticionesRevisar.data.length == 0) {
        finExito()
        return 0;
      }


      // 2. Se comprueba que alguna de las lineas haya dejado de estar en estado de test
      const iccids = peticionesRevisar.data.map(e => e.iccid)
      const lineasActualizadas: ObjeniousLine[] = []

      const lineGenerator = this.objeniousRepo.getLinesByStatusAPI({
        iccids: iccids
      })

      let lines = await lineGenerator.next()

      if (lines.value.error != undefined || lines.value.data == undefined) {
        logger.error("Error cargando las lineas", lines.value.error)
        finError(lines.value.error)
        return 1;
      } else {
        lineasActualizadas.push(...lines.value.data)
      }

      while (!lines.done) {
        lines = await lineGenerator.next()
        if (lines.value.error != undefined || lines.value.data == undefined) {
          logger.error("Error cargando las lineas", lines.value.error)
          finError(lines.value.error)
          return 1;
        } else {
          lineasActualizadas.push(...lines.value.data)
        }

      }

      console.log("Cargado: ", lineasActualizadas)

      // 3. Se separan las lineas que se tienen que actualizar al no ser test
      // y las que se tienen que reencolar al ser test
      const lineasNoTest = lineasActualizadas.filter(e => e.status.billingStatus != "TEST")
      const lineasTest = lineasActualizadas.filter(e => e.status.billingStatus == "TEST")

      // 4. Las lineas de test se reencolan
      // El proximo reintento es en 1 dia
      const proximoReintento = new Date()
      proximoReintento.setDate(new Date().getDate() + 1)

      // 5. Reintentos en 1 dia
      for (const linea of lineasTest) {
        const lineaId = peticionesRevisar.data
          .find(e => e.iccid == linea.identifier.iccid)?.id

        if (lineaId == undefined) continue; // Esto puede ser un problema si se generaliza

        this.pauseRepo.updateTask({
          id: lineaId,
          next_check: proximoReintento
        })
      }

      // 6. Operaciones de pausa/cancelacion definitiva
      for (const linea of lineasNoTest) {
        const operacion = peticionesRevisar.data
          .find(e => e.iccid == linea.identifier.iccid)

        if (operacion == undefined) continue;
        const dueDate = new Date()
        dueDate.setMinutes(new Date().getMinutes() + 15)

        const operacionTipo = operacion.operation_type
        const actionData = operacion.action_data
        const correlation_id = operacion.action_data.correlation_id
        actionData.dueDate = dueDate.toISOString()

        switch (linea.status.billingStatus) {
          case "ACTIVATED":
            let result = null;

            // Se termina el proceso aqui pero pasa a ser una operación de
            // objenious por lo que puede fallar y quedaria registrado en 
            // la tabla objenious_operation
            switch (operacionTipo) {
              case "suspend":
                result = await this.simUsecases.suspend(actionData)()
                console.log("SUSPENDED", result)
                break;
              case "terminate":
                result = await this.simUsecases.terminate(actionData)()
                break;
              default:
                break;
            }

            if (result == undefined) {
              logger.error("Operacion desconocida", operacion)
            } else if (result?.error != undefined) {
              // error usecase
              logger.error(result.error)
              await this.pauseRepo.finishTask({
                id: operacion.id,
                error: result.error
              })
              if (correlation_id != undefined)
                await this.orderRepo.errorOrder({
                  correlation_id: correlation_id,
                  status: "dlx",
                  reason: result.error
                })
            } else {
              // ok
              await this.pauseRepo.finishTask({ id: operacion.id })
              if (correlation_id != undefined)
                await this.orderRepo.finishOrder({ correlation_id })
            }

            break;
          case "CANCELED":
            await this.pauseRepo.finishTask({
              id: operacion.id,
              error: "billingStatus is CANCELED"
            })
            if (correlation_id != undefined)
              await this.orderRepo.finishOrder({ correlation_id })
            break;
          case "SUSPENDED":
            await this.pauseRepo.finishTask({
              id: operacion.id,
              error: "billingStatus is SUSPENDED"
            })
            if (correlation_id != undefined)
              await this.orderRepo.finishOrder({ correlation_id })
            break;
          case "TEST":
          // No puede ser
          default:
            logger.error("billingStatus desconocido", linea.status.billingStatus)

        }
      }

      finExito()
    } catch (e) {
      finError(e)
    }

    return 0
  }
}