import { pgPool } from "./config/postgreConfig.js"
import { PgClient } from "sim-shared/infrastructure/PgClient.js"
import { httpInstance } from "./config/httpClient.config.js"
import { CheckObjeniousRequests } from "./tasks/check_objenious_request.js"
import { ObjeniousOperationsRepository } from "sim-shared/infrastructure/ObjeniousOperationRepository.js"
import { OrderRepository } from "sim-shared/infrastructure/OrderRepository.js"
import { TaskVolcadoLineas } from "./tasks/volcado_lineas.js"
import { ObjeniousLinesRepository } from "./infranstructure/ObjeniousLinesRepository.js"
import { postgresClientIntranet } from "./config/intranetPostgresConfig.js"
import { PauseCancelTaskRepository } from "sim-consumidor-objenious/infrastructure/PauseCancelTaskRepository.js"
import { PauseTerminateTask } from "./tasks/check_pause_terminate.js"
import { SimUseCases } from "sim-consumidor-objenious/aplication/Sim.usecases.js"

async function startCron() {
  const commonSettings = {
    maxRandomDelay: 1000,
    noOverlap: true
  }

  const httpClient = httpInstance
  const pgClient = new PgClient({ pool: pgPool })

  console.log("[i] Comprobando conexion con la BDD ")
  await pgClient.checkDatabaseConnection()

  const operationRepository = new ObjeniousOperationsRepository(
    httpClient,
    pgClient,
  )
  const orderRepository = new OrderRepository(pgClient)
  const objeniousLineRepository = new ObjeniousLinesRepository(postgresClientIntranet)

  const objTask = new CheckObjeniousRequests(
    operationRepository,
    orderRepository,
    httpClient,
  )

  const objeniosRepo = new ObjeniousOperationsRepository(
    httpClient,
    pgClient
  )

  const volcadoLineasTask = new TaskVolcadoLineas(
    objeniousLineRepository,
    objeniosRepo
  )

  const pauseRepo = new PauseCancelTaskRepository(pgClient)
  const simUsecases = new SimUseCases({
    httpClient: httpClient,
    operationRepository: operationRepository,
    orderRepository: orderRepository,
    pauseRepository: pauseRepo
  })

  const pauseTask = new PauseTerminateTask(
    objeniosRepo,
    pauseRepo,
    simUsecases,
    orderRepository
  )

  //await objTask.getPendingOperations()
  const PERIODO_PETICIONES = 10 * 60 * 1000
  const interval = setInterval(async () => {
    try {
      await objTask.getPendingOperations()
    } catch (e) {
      console.error("[x] Error de actualizacion de las lineas ")
    }
  }, PERIODO_PETICIONES)

  const PERIODO_VOLCADO = 60 * 60 * 1000
  const volcadoInterval = setInterval(async () => {
    try {
      await volcadoLineasTask.loadLines()
    } catch (e) {
      console.error("[x] Volcado de lineas de Objenious Fallido", e)
    }
  }, PERIODO_VOLCADO)

  await pauseTask.run()
  const PERIODO_CANCELACIONES = 60 * 60 * 1000;
  const clacelacionesInterval = setInterval(async () => {
    await pauseTask.run()
  }, PERIODO_CANCELACIONES)


}

startCron().then(e => console.log).catch(e => console.error)