sf-sim/packages/sim-consumidor-objenious/aplication/Sim.usecases.ts

import { ActionData, ActivationData } from "#domain/DTOs/objeniousapi.js"
import { HttpClient } from "#shared/infrastructure/HTTPClient.js"
import { AxiosError } from "axios"
import { Result } from "#shared/domain/Result"

// TODO: 
// - Pasar a un archivo de DTOs
// - Mucha repeticion por funcion, deberia hacer una plantilla


export class SimUseCases {
  private httpClient: HttpClient

  constructor(args: {

    httpClient: HttpClient
  }) {
    this.httpClient = args.httpClient
  }



  public activate(activationData: ActivationData): () => Promise<Result<string, boolean>> {
    const OPERATION_URL = "/actions/activateLine"
    return async () => {
      // TODO: validacion de campos

      const req = this.httpClient.client.post(OPERATION_URL, {
        ...activationData
      })


      try {
        const response = await req
        console.log("[!] El status de la respuesta es", response.status)

        if (response.status == 200) {
          console.log("Activacion con exito", response.data.response)
          return <Result<string, boolean>>{
            error: undefined,
            data: true
          }
        } else {
          return {
            error: String(response.status),
            data: undefined
          }
        }
      } catch (error) {
        console.error("[Sim.usecase] Error activando ", (error as AxiosError).response?.status)
        return {
          error: "Error general de la peticion",
          data: undefined
        }
      }
    }
  }

  public preActivate(pauseData: ActionData): () => Promise<Result<string, boolean>> {
    const OPERATION_URL = "/actions/preactivateLine"
    return async () => {
      const req = this.httpClient.client.post(OPERATION_URL, {
        ...pauseData
      })

      try {
        const e = await req
        console.log("Sim preactivada con exito", e.data)
        return <Result<string, boolean>>{
          error: undefined,
          data: true
        }
      } catch (error) {
        console.error("Error preactivacion", pauseData)
        return <Result<string, boolean>>{
          error: "Error preactivando la sim" + pauseData.identifier,
          data: true
        }
      }
    }
  }

  public reActivate(pauseData: ActionData): () => Promise<Result<string, boolean>> {
    const OPERATION_URL = "/actions/reactivateLine"
    return async () => {
      const req = this.httpClient.client.post(OPERATION_URL, {
        ...pauseData
      })

      try {
        const e = await req
        console.log("Sim reactivada con exito", e.data)
        return <Result<string, boolean>>{
          error: undefined,
          data: true
        }
      } catch (error) {
        console.error("Error reactivacion", error)
        return <Result<string, boolean>>{
          error: "Error reactivando la sim" + pauseData.identifier,
          data: true
        }
      }
    }
  }

  public suspend(suspendData: ActionData): () => Promise<Result<string, boolean>> {
    const OPERATION_URL = "/actions/suspendLine"
    return async () => {
      const req = this.httpClient.client.post(OPERATION_URL, {
        ...suspendData
      })

      try {
        const e = await req
        console.log("Sim pausada/suspendida con exito", e.data)
        return <Result<string, boolean>>{
          error: undefined,
          data: true
        }
      } catch (error) {
        console.error("[Pausa Use case] Error pausa")
        return {
          error: "Error general pausando/suspendiendo la sim" + suspendData.identifier,
          data: undefined
        }
      }
    }
  }

  public terminate(terminationData: ActionData): () => Promise<Result<string, boolean>> {
    const OPERATION_URL = "/actions/terminateLine"
    return async () => {
      const req = this.httpClient.client.post(OPERATION_URL, {
        ...terminationData
      })

      // TODO: para cuando estemos listos.
      throw new Error("Peticion no reversible desactivada de momento")

      try {
        const e = await req
        console.log("Sim cancelada con exito", e.data)
        return <Result<string, boolean>>{
          error: undefined,
          data: true
        }
      } catch (error) {
        console.error("Error pausa", error)
        return <Result<string, boolean>>{
          error: "Error cancelando/terminate la sim" + terminationData.identifier,
          data: undefined
        }
      }
    }
  }


}