import { IOperationsRepository, ObjeniousOperation, ObjeniousOperationChange } from "sim-shared/domain/operationsRepository.port.js";
import { Result } from "sim-shared/domain/Result.js";
import { PgClient } from "sim-shared/infrastructure/PgClient.js";

export class OperationsRepository implements IOperationsRepository {

  constructor(
    private readonly pgClient: PgClient
  ) {
  }

  async createOperation(data: ObjeniousOperation): Promise<Result<string, ObjeniousOperation>> {
    const query = `
      INSERT INTO objenious_operation (operation, iccids, status, max_retry, request_id)
      VALUES ($1, $2, $3, $4, $5)
      RETURNING *`;
    const iccids = JSON.stringify(data.iccids)
    const values = [data.operation, iccids, data.status, data.max_retry, data.request_id];
    const { rows } = await this.pgClient.query(query, values);
    return <Result<string, ObjeniousOperation>>{
      data: rows[0]
    }
  }

  async updateOperation(data: ObjeniousOperationChange): Promise<Result<string, ObjeniousOperation>> {
    const client = await this.pgClient.connect();
    const {
      new_status,
      previous_status,
      error,
      new_request_id,
      new_mass_action_id,
      operation_id,
      new_objenious_status,
      previous_objenious_status
    } = data

    try {
      await client.query('BEGIN');
      // 1. Actualizar objenious_operation (la operacion base)
      const updateParams = [operation_id, new_status, error, new_request_id, new_mass_action_id, new_objenious_status]
      const updateOpQuery = `
        UPDATE objenious_operation 
        SET 
          status = $2::status_enum,
          error = COALESCE($3,error),
          request_id = COALESCE($4, request_id),
          mass_action_id = COALESCE($5, mass_action_id),
          last_change_date = now(),
          end_date = CASE WHEN $2 IN ('finished') THEN now() ELSE end_date END,
          objenious_status = $6 
        WHERE id = $1`;

      const operation = await client.query<ObjeniousOperation>(
        updateOpQuery, updateParams)

      // 2. Nuevo registro en objenious_operation_change (indica un cambio de estado)
      const insertChangeQuery = `
        INSERT INTO objenious_operation_change (operation_id, new_status, previous_status, error, new_request_id, new_mass_action_id, new_objenious_status, previous_objenious_status)
        VALUES                                 ($1,           $2,         $3,              $4,    $5,             $6,                 $7,                   $8)`;
      await client.query(insertChangeQuery, [operation_id, new_status, previous_status, error, new_request_id, new_mass_action_id, new_objenious_status, previous_objenious_status]);
      await client.query('COMMIT');

      return <Result<string, ObjeniousOperation>>{
        data: operation.rows[0]
      }
    } catch (e) {
      console.error("Error añadiendo actualizacion de la operation", e)
      console.error("datos errorneos", data)
      await client.query('ROLLBACK');
      return <Result<string, ObjeniousOperation>>{
        data: undefined,
        error: e
      }
    } finally {
      client.release();
    }
  }

  async getPendingOperations(): Promise<Result<string, ObjeniousOperation[]>> {
    // Aprovecha el índice 'pending_operations' 
    const query = `SELECT * FROM objenious_operation WHERE end_date IS NULL ORDER BY start_date ASC`;
    try {
      const { rows } = await this.pgClient.query<ObjeniousOperation>(query);
      return {
        error: undefined,
        data: rows
      };
    } catch (e) {
      return {
        error: String(e),
        data: undefined
      }
    }
  }
}