pispas_modules/

cash_guard.rs

use crate::service::{Service, WebSocketWrite};
use async_trait::async_trait;
use futures_util::SinkExt;
use serde_json::{json, Value};
use std::sync::Arc;
use tokio::sync::Mutex;
use tokio::time::{sleep, Duration};
use tokio_tungstenite::tungstenite::protocol::Message;
use easy_trace::prelude::{error, info};

pub const CASH_GUARD_VERSION: &str = "1.0.0";

/// CashGuardService handles communication with the CashGuard system.
pub struct CashGuardService {
    base_url: String,
    processing_ids: Arc<Mutex<Vec<String>>>, // Tracks currently processing transactions
    auth: (String, String), // Tuple to hold username and password
}

impl Clone for CashGuardService {
    fn clone(&self) -> Self {
        Self {
            base_url: self.base_url.clone(),
            processing_ids: Arc::clone(&self.processing_ids),
            auth: self.auth.clone(),
        }
    }
}

impl CashGuardService {
    /// Creates a new instance of CashGuardService.
    ///
    /// # Arguments
    ///
    /// * `host` - The hostname or IP address of the CashGuard system.
    /// * `port` - The port number for connecting to the CashGuard system.
    /// * `username` - The username for authentication.
    /// * `password` - The password for authentication.
    pub fn new(host: &str, port: u16, username: &str, password: &str) -> Self {
        let base_url = format!("http://{}:{}/cashguard/posApi/4.0", host, port);
        Self {
            base_url,
            processing_ids: Arc::new(Mutex::new(Vec::new())),
            auth: (username.to_string(), password.to_string()),
        }
    }

    /// Sends a structured response through WebSocket.
    ///
    /// # Arguments
    ///
    /// * `write` - A reference to the WebSocket writer.
    /// * `uuid` - The unique identifier for the message.
    /// * `message` - The JSON payload to be sent.
    async fn _send_response(&self, write: &WebSocketWrite, uuid: &str, message: Value) {
        let full_message = json!({
        "SERVICE_NAME": "CASHGUARD",
        "SERVICE_VERS": CASH_GUARD_VERSION,
        "MESSAGE_TYPE": "RESPONSE",
        "MESSAGE_EXEC": "SUCCESS",
        "MESSAGE_UUID": uuid,
        "MESSAGE_DATA": message,
    });

        self.send_message(write, full_message).await;
    }

    /// Sends an HTTP request to the CashGuard system.
    ///
    /// # Arguments
    ///
    /// * `method` - The HTTP method (GET, POST, PUT, DELETE).
    /// * `endpoint` - The API endpoint.
    /// * `params` - Optional JSON parameters for the request.
    ///
    /// # Returns
    ///
    /// A `Result` with a JSON response or an error message.
    async fn send_request(
        &self,
        method: &str,
        endpoint: &str,
        params: Option<Value>,
    ) -> Result<Value, String> {
        let url = format!("{}/{}", self.base_url, endpoint);
        let client = reqwest::Client::new();
        let (username, password) = &self.auth;
        info!("Sending request to: {} with params: {:?}", url, params);

        let query_params: Vec<(String, String)> = match params.as_ref().and_then(|value| value.as_object()) {
            Some(map) => map.iter()
                .map(|(k, v)| {
                    let value_as_string = if v.is_number() {
                        if let Some(num) = v.as_f64() {
                            format!("{}", num as i64) // Fuerza a entero
                        } else if let Some(num) = v.as_i64() {
                            format!("{}", num)
                        } else {
                            v.to_string()
                        }
                    } else {
                        v.to_string()
                    };
                    (k.clone(), value_as_string)
                })
                .collect(),
            None => Vec::new(),
        };

        let response = match method.to_uppercase().as_str() {
            "GET" => {
                client
                    .get(&url)
                    .basic_auth(username, Some(password))
                    .header("accept", "*/*")
                    .query(&query_params) // Usar query parameters
                    .send()
                    .await
            }
            "POST" => {
                client
                    .post(&url)
                    .basic_auth(username, Some(password))
                    .header("accept", "*/*")
                    .json(&params.unwrap_or_else(|| json!({}))) // POST usa cuerpo JSON
                    .send()
                    .await
            }
            "PUT" => {
                client
                    .put(&url)
                    .basic_auth(username, Some(password))
                    .header("accept", "*/*")
                    .query(&query_params)
                    .send()
                    .await
            }
            "DELETE" => {
                client
                    .delete(&url)
                    .basic_auth(username, Some(password))
                    .header("accept", "*/*")
                    .query(&query_params)
                    .send()
                    .await
            }
            _ => {
                return Err(format!("Unsupported HTTP method: {}", method));
            }
        };


        match response {
            Ok(res) if res.status().is_success() => {
                let body = res.text().await.unwrap_or_else(|_| "{}".to_string());
                Ok(serde_json::from_str(&body).unwrap_or(json!({})))
            }
            Ok(res) => Err(format!(
                "HTTP Error: {} - {}",
                res.status(),
                res.text().await.unwrap_or_default()
            )),
            Err(err) => Err(format!("Request failed: {}", err)),
        }
    }


    /// Retrieves the status of the CashGuard system.
    ///
    /// # Returns
    ///
    /// A `Result` containing the system status as JSON or an error message.
    async fn status(&self) -> Result<Value, String> {
        self.send_request("GET", "status", None).await
    }

    /// Logs into the CashGuard system.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn login(&self) -> Result<(), String> {
        self.send_request("PUT", "login", None).await.map(|_| ())
    }

    /// Logs out of the CashGuard system.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn logout(&self) -> Result<(), String> {
        self.send_request("PUT", "logout", None).await.map(|_| ())
    }

    /// Sets the amount due for a transaction.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `amount_due` - The amount due for the transaction.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure
    async fn set_amount_due(&self, transaction_id: &str, amount_due: f64) -> Result<(), String> {
        let amount_due_int = amount_due as i64;

        let endpoint = format!(
            "transactions/{}?status=amountDue&amountDue={}",
            transaction_id, amount_due_int
        );

        self.send_request("PUT", &endpoint, None).await.map(|_| ())
    }


    /// Enqueues a transaction.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `amount_due` - Optional amount due for the transaction.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn enqueue_transaction(
        &self,
        transaction_id: &str,
        amount_due: Option<f64>,
    ) -> Result<(), String> {
        let mut endpoint = format!("queue/{}", transaction_id);
        if let Some(amount) = amount_due {
            endpoint.push_str(&format!("?amountDue={}", amount));
        }

        self.send_request("PUT", &endpoint, None).await.map(|_| ())
    }


    /// Initiates a transaction in the CashGuard system.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `amount_due` - The amount due for the transaction.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn initiate_transaction(
        &self,
        transaction_id: &str,
        amount_due: f64,
    ) -> Result<(), String> {
        // Construir la URL con parámetros en el query string
        let endpoint = format!(
            "transactions/{}?status=initiated&currency=EUR&amountDue={}",
            transaction_id, amount_due
        );

        // Llamar a send_request con la URL completa (sin params en body)
        self.send_request("PUT", &endpoint, None).await.map(|_| ())
    }


    /// Prepares the CashGuard system for a transaction by polling its status.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `polling_interval` - The interval to wait between status checks.
    /// * `write` - A reference to the WebSocket writer.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn pre_start_transaction(
        &self,
        transaction_id: &str,
        polling_interval: Duration,
        write: WebSocketWrite,
    ) -> Result<(), String> {
        loop {
            let status = self.status().await?;
            let system_status = status.get("status").and_then(|s| s.as_str()).unwrap_or("");

            match system_status {
                "Logged Off" => {
                    info!("System is logged off, logging in...");
                    self.login().await?;
                }
                "Busy" => {
                    info!("System is busy, waiting...");
                    sleep(polling_interval).await;
                }
                _ => break,
            }

            if self
                .processing_ids
                .lock()
                .await
                .contains(&transaction_id.to_string())
            {
                if let Some(ws_lock) = &write {
                    let mut ws = ws_lock.write().await;
                    ws.send(Message::Text(
                        json!({
                            "status": "error",
                            "message": "Transaction no longer in queue.",
                        })
                            .to_string(),
                    ))
                        .await
                        .unwrap_or_default();
                }
            }
        }
        Ok(())
    }

    /// Sends a final response through WebSocket.
    ///
    /// # Arguments
    ///
    /// * `write` - A reference to the WebSocket writer.
    /// * `response` - The JSON response string to be sent.
    async fn final_response(&self, write: &WebSocketWrite, response: &str) {
        if let Some(write) = &write {
            let mut ws = write.write().await;
            ws.send(Message::Text(response.to_string()))
                .await
                .unwrap_or_default();
        }
    }

    /// Processes a transaction with proper polling until the amount due is met.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `amount_due` - The amount due for the transaction.
    /// * `write` - A reference to the WebSocket writer.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn process_transaction(
        &self,
        transaction_id: &str,
        amount_due: f64,
        write: WebSocketWrite,
    ) -> Result<(), String> {
        let mut processing_ids = self.processing_ids.lock().await;

        if processing_ids.contains(&transaction_id.to_string()) {
            return Err(format!(
                "Transaction {} is already being processed.",
                transaction_id
            ));
        } else {
            info!("Transaction {} is not being processed.", transaction_id);
            processing_ids.push(transaction_id.to_string());
        }

        drop(processing_ids); // Release lock

        // Pre-start transaction
        info!("Processing transaction: {} pre-start", transaction_id);
        self.pre_start_transaction(transaction_id, Duration::from_secs(2), write.clone())
            .await?;

        // Enqueue transaction
        info!("Processing transaction: {} enqueue", transaction_id);
        self.enqueue_transaction(transaction_id, Some(amount_due))
            .await?;

        // Initiate transaction
        info!("Processing transaction: {} initiate", transaction_id);
        self.initiate_transaction(transaction_id, amount_due)
            .await?;

        let mut current_amount = 0.0;
        let mut last_reported_amount = 0.0;

        // Polling for status until amount is received
        while current_amount < amount_due {
            tokio::time::sleep(Duration::from_secs(2)).await;

            let status = self.status().await?;
            current_amount = status.get("amount").and_then(|a| a.as_f64()).unwrap_or(0.0);

            if current_amount != last_reported_amount {
                last_reported_amount = current_amount;
                let response = json!({
                "status": "progress",
                "transactionId": transaction_id,
                "currentAmount": current_amount,
                "amountDue": amount_due,
                });

                self.final_response(&write, &response.to_string()).await;
            }

            // Check if transaction is still in the processing list
            let processing_ids = self.processing_ids.lock().await;
            if !processing_ids.contains(&transaction_id.to_string()) {
                drop(processing_ids); // Release lock
                let error_response = json!({
                "status": "error",
                "message": "Transaction no longer in queue.",
                "transactionId": transaction_id,
            });
                self.final_response(&write, &error_response.to_string()).await;

                return Err(format!(
                    "Transaction {} is no longer in the queue. Aborting.",
                    transaction_id
                ));
            }
        }

        // Confirm amount received
        info!("Confirming amount received: {}", amount_due);
        self.set_amount_due(transaction_id, amount_due).await?;

        // Calculate refund if necessary
        let refund = if current_amount > amount_due {
            let refund_amount = current_amount - amount_due;
            info!("Refund issued: {}", refund_amount);
            refund_amount
        } else {
            info!("No refund necessary.");
            0.0
        };

        // Send success response
        let final_response = json!({
        "status": "success",
        "transactionId": transaction_id,
        "amountDue": amount_due,
        "amountRefund": refund,
        });

        self.final_response(&write, &final_response.to_string()).await;

        let mut processing_ids = self.processing_ids.lock().await;
        processing_ids.retain(|id| id != transaction_id);
        drop(processing_ids); // Release lock

        Ok(())
    }


    /// Handles a cash-out transaction.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `amount` - The amount to be withdrawn.
    /// * `write` - A reference to the WebSocket writer.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn cash_out_transaction(
        &self,
        transaction_id: &str,
        amount: f64,
        write: WebSocketWrite,
    ) -> Result<(), String> {
        let negative_amount = -amount.abs();
        self.pre_start_transaction(transaction_id, Duration::from_secs(2), write.clone())
            .await?;
        self.enqueue_transaction(transaction_id, Some(negative_amount))
            .await?;
        self.initiate_transaction(transaction_id, negative_amount)
            .await?;
        self.set_amount_due(transaction_id, negative_amount).await?;

        let response = json!({
            "status": "success",
            "message": "Cash out completed.",
            "transactionId": transaction_id,
        });

        self.final_response(&write, &response.to_string()).await;

        Ok(())
    }

    /// Sends a message through WebSocket.
    ///
    /// # Arguments
    ///
    /// * `write` - A reference to the WebSocket writer.
    /// * `message` - The JSON message to be sent.
    async fn send_message(&self, write: &WebSocketWrite, message: Value) {
        if let Some(ws_lock) = write {
            let serialized_message = Message::Text(message.to_string());
            let mut ws = ws_lock.write().await;
            if let Err(e) = ws.send(serialized_message).await {
                error!("Failed to send WebSocket message: {}", e);
            }
        }
    }

    /// Cancels a transaction in the CashGuard system.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `status` - The status of the transaction.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn cancel_transaction(&self, transaction_id: &str, status: &str) -> Result<(), String> {
        if status == "PendingActivation" {
            self.set_amount_due(transaction_id, 0.0).await?;
            self.send_request(
                "PUT",
                &format!("transactions/{}?status=released", transaction_id),
                None,
            )
                .await?;
        } else {
            self.set_amount_due(transaction_id, 0.0).await?;
        }
        Ok(())
    }

    /// Resets the CashGuard device.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn reset(&self) -> Result<(), String> {
        self.send_request("PUT", "Reset", None).await.map(|_| ())
    }

    /// Handles a generic transaction with optional parameters.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `status` - The status of the transaction.
    /// * `currency` - Optional currency for the transaction.
    /// * `amount_due` - Optional amount due for the transaction.
    /// * `in_amount` - Optional input amount.
    /// * `out_amount` - Optional output amount.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn _transaction(
        &self,
        transaction_id: &str,
        status: &str,
        currency: Option<&str>,
        amount_due: Option<f64>,
        in_amount: Option<f64>,
        out_amount: Option<f64>,
    ) -> Result<(), String> {
        let mut endpoint = format!("transactions/{}?status={}", transaction_id, status);
        if let Some(curr) = currency {
            endpoint.push_str(&format!("&currency={}", curr));
        }
        if let Some(amount) = amount_due {
            endpoint.push_str(&format!("&amountDue={}", amount));
        }
        if let Some(in_amt) = in_amount {
            endpoint.push_str(&format!("&in={}", in_amt));
        }
        if let Some(out_amt) = out_amount {
            endpoint.push_str(&format!("&out={}", out_amt));
        }
        self.send_request("PUT", &endpoint, None).await.map(|_| ())
    }

    /// Handles a repay transaction in the CashGuard system.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `in_amount` - The input amount for the transaction.
    /// * `out_amount` - The output amount for the transaction.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn _repay_transaction(
        &self,
        transaction_id: &str,
        in_amount: f64,
        out_amount: f64,
    ) -> Result<(), String> {
        self._transaction(transaction_id, "repaid", Some("EUR"), None, Some(in_amount), Some(out_amount))
            .await
    }

    /// Forces the release of a transaction using multiple methods including repay+release
    async fn force_release_transaction(&self, transaction_id: &str) -> Result<(), String> {
        info!("Force releasing transaction: {}", transaction_id);

        // Method 1: Try the complete repay+release process
        info!("Attempting complete cancellation process for transaction {}", transaction_id);

        // Step 1: Set amount to 0
        let _ = self.set_amount_due(transaction_id, 0.0).await;
        tokio::time::sleep(Duration::from_millis(300)).await;

        // Step 2: Repay transaction
        let repay_result = self.send_request(
            "PUT",
            &format!("transactions/{}?status=repaid&currency=EUR", transaction_id),
            None,
        ).await;

        if repay_result.is_ok() {
            info!("Repay successful for transaction {}, proceeding with release", transaction_id);
            tokio::time::sleep(Duration::from_millis(1000)).await;

            // Step 3: Release with values at 0
            let release_result = self.send_request(
                "PUT",
                &format!("transactions/{}?status=released&currency=EUR&in=0&out=0", transaction_id),
                None,
            ).await;

            if release_result.is_ok() {
                info!("Complete repay+release successful for transaction {}", transaction_id);
                return Ok(());
            }
        }

        // Method 2: Try direct release if repay failed
        info!("Trying direct release for transaction {}", transaction_id);
        let result1 = self.send_request(
            "PUT",
            &format!("transactions/{}?status=released", transaction_id),
            None,
        ).await;

        if result1.is_ok() {
            return Ok(());
        }

        // Method 3: Delete from queue if it's there
        info!("Trying queue deletion for transaction {}", transaction_id);
        let result2 = self.send_request("DELETE", &format!("queue/{}", transaction_id), None).await;

        if result2.is_ok() {
            return Ok(());
        }

        // If everything fails, log but continue
        error!("Could not completely cancel transaction {}, but continuing", transaction_id);
        Ok(()) // Return Ok to not block the process
    }
    /// NEW FUNCTIONALITY: Clears the entire queue by canceling transactions one by one
    /// and then processes the new transaction
    async fn clear_queue_and_process_new_transaction(
        &self,
        new_transaction_id: &str,
        amount_due: f64,
        write: WebSocketWrite,
    ) -> Result<(), String> {
        info!("Starting queue cleanup before processing transaction: {}", new_transaction_id);

        // 1. Get current queue
        let queue = self.get_queue().await.unwrap_or(json!({}));

        if let Some(queue_data) = queue.as_array() {
            if !queue_data.is_empty() {
                info!("Found {} transactions in queue, proceeding to cancel one by one", queue_data.len());

                // 2. Cancel each transaction in the queue one by one
                for item in queue_data {
                    let transaction_id = item
                        .get("transactionId")
                        .and_then(|t| t.as_str())
                        .unwrap_or("");
                    let status = item.get("status").and_then(|s| s.as_str()).unwrap_or("");
                    let being_handled = item.get("beingHandledBySystem").and_then(|b| b.as_bool()).unwrap_or(false);

                    if !transaction_id.is_empty() {
                        info!("Cancelling transaction: {} with status: {} (beingHandled: {})", transaction_id, status, being_handled);

                        match self.cancel_single_transaction(transaction_id, status, being_handled).await {
                            Ok(_) => {
                                info!("Transaction {} cancelled successfully", transaction_id);

                                // Send progress notification
                                let progress_response = json!({
                                    "status": "clearing_queue",
                                    "message": format!("Cancelled transaction: {}", transaction_id),
                                    "transactionId": transaction_id,
                                });
                                self.final_response(&write, &progress_response.to_string()).await;

                                // Small pause between cancellations
                                tokio::time::sleep(Duration::from_millis(1000)).await;
                            }
                            Err(e) => {
                                error!("Error cancelling transaction {}: {}", transaction_id, e);
                                // Continue with next transaction even if this one fails
                            }
                        }

                        // Remove from processing_ids if it's there
                        let mut processing_ids = self.processing_ids.lock().await;
                        processing_ids.retain(|id| id != transaction_id);
                        drop(processing_ids);
                    }
                }

                // 3. Verify that the queue is empty after cleanup - retry if needed
                for retry_attempt in 0..3 {
                    let final_queue = self.get_queue().await.unwrap_or(json!({}));
                    if let Some(final_queue_data) = final_queue.as_array() {
                        if !final_queue_data.is_empty() {
                            error!("Queue still has {} transactions after cleanup attempt {}", final_queue_data.len(), retry_attempt + 1);
                            // Additional cleanup attempt if needed
                            for item in final_queue_data {
                                let transaction_id = item.get("transactionId").and_then(|t| t.as_str()).unwrap_or("");
                                let status = item.get("status").and_then(|s| s.as_str()).unwrap_or("");
                                let being_handled = item.get("beingHandledBySystem").and_then(|b| b.as_bool()).unwrap_or(false);
                                if !transaction_id.is_empty() {
                                    info!("Retry cleanup: cancelling {} with status {} (beingHandled: {})", transaction_id, status, being_handled);
                                    let _ = self.force_release_transaction(transaction_id).await;
                                    tokio::time::sleep(Duration::from_millis(1000)).await;
                                }
                            }
                        } else {
                            info!("Queue cleaned successfully, it's empty");
                            break;
                        }
                    }
                }
            } else {
                info!("Queue is already empty, no cleanup needed");
            }
        }

        // 4. Notify that the queue is clean and begin new transaction
        info!("Queue cleaned, starting new transaction: {}", new_transaction_id);

        let success_response = json!({
            "status": "queue_cleared",
            "message": "Queue cleared, starting new transaction",
            "newTransactionId": new_transaction_id,
        });
        self.final_response(&write, &success_response.to_string()).await;

        // 5. Process the new transaction
        self.process_transaction(new_transaction_id, amount_due, write).await
    }

    /// Handles a generic transaction with optional parameters.
    ///
    /// # Arguments
    ///
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `status` - The status of the transaction.
    /// * `currency` - Optional currency for the transaction.
    /// * `amount_due` - Optional amount due for the transaction.
    /// * `in_amount` - Optional input amount.
    /// * `out_amount` - Optional output amount.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure.
    async fn _release_transaction(
        &self,
        transaction_id: &str,
        in_amount: f64,
        out_amount: f64,
    ) -> Result<(), String> {
        self._transaction(
            transaction_id,
            "released",
            Some("EUR"),
            None,
            Some(in_amount),
            Some(out_amount),
        )
            .await
    }
    async fn cancel_single_transaction(&self, transaction_id: &str, status: &str, being_handled: bool) -> Result<(), String> {
        info!("Cancelling individual transaction: {} with status: {} (beingHandled: {})", transaction_id, status, being_handled);

        // Try different methods based on status and being_handled flag
        match status {
            "InQueue" => {
                // For queued transactions, simply remove them
                info!("Transaction {} is queued, removing directly", transaction_id);
                self.send_request("DELETE", &format!("queue/{}", transaction_id), None).await.map(|_| ())
            }
            "PendingActivation" => {
                // For pending transactions, set amount to 0 and release
                info!("Transaction {} is pending, cancelling with amountDue=0", transaction_id);
                self.set_amount_due(transaction_id, 0.0).await?;
                tokio::time::sleep(Duration::from_millis(300)).await;
                self.send_request(
                    "PUT",
                    &format!("transactions/{}?status=released", transaction_id),
                    None,
                ).await.map(|_| ())
            }
            "MovedFromQueue" => {
                // For transactions moved from queue and being handled by system
                // Follow the documentation process: repay + release with values at 0
                info!("Transaction {} is moved from queue, following complete cancellation process", transaction_id);

                if being_handled {
                    // Transaction is actively being processed, need full cancellation process
                    info!("Transaction {} is being handled by system, doing repay+release", transaction_id);

                    // Step 1: Repay transaction (return any money)
                    info!("Step 1: Repaying transaction {}", transaction_id);
                    let repay_result = self.send_request(
                        "PUT",
                        &format!("transactions/{}?status=repaid&currency=EUR", transaction_id),
                        None,
                    ).await;

                    if let Err(e) = repay_result {
                        error!("Repay failed for transaction {}: {}, trying alternative", transaction_id, e);
                        // Try setting amount to 0 first
                        let _ = self.set_amount_due(transaction_id, 0.0).await;
                    }

                    // Wait a bit between repay and release
                    tokio::time::sleep(Duration::from_millis(1000)).await;

                    // Step 2: Release transaction with values at 0
                    info!("Step 2: Releasing transaction {} with values at 0", transaction_id);
                    self.send_request(
                        "PUT",
                        &format!("transactions/{}?status=released&currency=EUR&in=0&out=0", transaction_id),
                        None,
                    ).await.map(|_| ())
                } else {
                    // Not being handled, simpler release
                    info!("Transaction {} moved but not being handled, direct release", transaction_id);
                    self.set_amount_due(transaction_id, 0.0).await?;
                    tokio::time::sleep(Duration::from_millis(300)).await;
                    self.send_request(
                        "PUT",
                        &format!("transactions/{}?status=released", transaction_id),
                        None,
                    ).await.map(|_| ())
                }
            }
            "Initiated" => {
                // For initiated transactions, also follow repay+release process
                info!("Transaction {} is initiated, following repay+release process", transaction_id);

                // Step 1: Set amount due to 0 first
                let _ = self.set_amount_due(transaction_id, 0.0).await;
                tokio::time::sleep(Duration::from_millis(300)).await;

                // Step 2: Repay if there's money involved
                info!("Step 1: Repaying transaction {}", transaction_id);
                let repay_result = self.send_request(
                    "PUT",
                    &format!("transactions/{}?status=repaid&currency=EUR", transaction_id),
                    None,
                ).await;

                if let Err(e) = repay_result {
                    error!("Repay failed for transaction {}: {}, continuing with release", transaction_id, e);
                }

                // Wait between operations
                tokio::time::sleep(Duration::from_millis(1000)).await;

                // Step 3: Release transaction
                info!("Step 2: Releasing transaction {}", transaction_id);
                self.send_request(
                    "PUT",
                    &format!("transactions/{}?status=released&currency=EUR&in=0&out=0", transaction_id),
                    None,
                ).await.map(|_| ())
            }
            _ => {
                // For any other status, try generic cancellation
                info!("Transaction {} has unknown status '{}', trying generic cancellation", transaction_id, status);
                self.force_release_transaction(transaction_id).await
            }
        }
    }
    /// Retrieves the transaction queue from the CashGuard system.
    ///
    /// # Returns
    ///
    /// A `Result` containing the queue as JSON or an error message.
    async fn get_queue(&self) -> Result<Value, String> {
        self.send_request("GET", "queue", None).await
    }

    /// Handles a command from the WebSocket and executes the appropriate action.
    ///
    /// # Arguments
    ///
    /// * `write` - A reference to the WebSocket writer.
    /// * `command` - The command to be executed.
    /// * `transaction_id` - The unique ID of the transaction.
    /// * `amount_due` - The amount due for the transaction.
    ///
    /// # Returns
    ///
    /// A `Result` indicating success or failure, with a message.
    async fn handle_command(&self, write: &WebSocketWrite, command: String, transaction_id: &String, amount_due: f64) -> Result<(i32, String), (i32, String)> {
        Ok(match command.as_str() {
            "PROCESS_TRANSACTION" => {
                info!("Processing new transaction with automatic queue clearing: {}", transaction_id);

                if let Err(e) = self
                    .clear_queue_and_process_new_transaction(&transaction_id, amount_due, write.clone())
                    .await
                {
                    error!("Error processing transaction with queue clearing: {}", e);
                    return Err((1, e));
                }

                (0, json!({"status": "success", "message": "Transaction processed successfully after clearing queue"}).to_string())
            }
            "CASH_OUT" => {
                if let Err(e) = self
                    .cash_out_transaction(&transaction_id, amount_due, write.clone())
                    .await
                {
                    error!("Failed to process cash out: {}", e);
                    return Err((1, e));
                }
                (0, "Cash out completed successfully".to_string())
            }
            "RESET" => {
                // Simulate getting queue and resetting device
                let queue = self
                    .send_request("GET", "queue", None)
                    .await
                    .unwrap_or(json!({}));
                if let Some(queue_data) = queue.as_array() {
                    for item in queue_data {
                        let transaction_id = item
                            .get("transactionId")
                            .and_then(|t| t.as_str())
                            .unwrap_or("");
                        let status = item.get("status").and_then(|s| s.as_str()).unwrap_or("");
                        match self.cancel_transaction(transaction_id, status).await {
                            Ok(_) => {
                                info!("Transaction {} cancelled.", transaction_id);
                            }
                            Err(e) => {
                                error!("Failed to cancel transaction {}: {}", transaction_id, e);
                            }
                        }
                    }
                }
                match self.reset().await {
                    Ok(_) => {
                        info!("CashGuard device reset.");
                    }
                    Err(e) => {
                        error!("Failed to reset CashGuard device: {}", e);
                        return Err((1, e));
                    }
                }

                let response = json!({
                    "status": "success",
                    "message": "CashGuard device reset.",
                });
                self.send_message(&write, response).await;
                (0, "Device reset successfully".to_string())
            }
            "CONTENTS" => {
                let contents = self
                    .send_request("GET", "contents", None)
                    .await
                    .unwrap_or(json!({}));
                let response = json!({
                    "status": "success",
                    "contents": contents,
                    "command": command,
                });
                self.send_message(&write, response).await;
                (0, "Contents retrieved successfully".to_string())
            }
            "STATUS" => {
                let status = self.status().await.unwrap_or(json!({}));
                let response = json!({
                    "status": "success",
                    "system_status": status,
                    "command": command,
                });
                self.send_message(&write, response).await;
                (0, "Status retrieved successfully".to_string())
            }
            "INITIATE_TRANSACTION" => {
                if let Err(e) = self.initiate_transaction(&transaction_id, amount_due).await {
                    error!("Failed to initiate transaction: {}", e);
                    return Err((1, e));
                }
                let response = json!({
                    "status": "success",
                    "message": "Transaction initiated.",
                });
                self.send_message(&write, response).await;
                (0, "Transaction initiated successfully".to_string())
            },
            "SET_AMOUNT_DUE" => {
                if let Err(e) = self.set_amount_due(&transaction_id, amount_due).await {
                    error!("Failed to set amount due: {}", e);
                    return Err((1, e));
                }
                let response = json!({
                    "status": "success",
                    "message": "Amount due set.",
                });
                self.send_message(&write, response).await;
                (0, "Amount due set successfully".to_string())
            },
            "CANCEL_TRANSACTION" => {
                if let Err(e) = self.set_amount_due(&transaction_id, 0.0).await {
                    error!(
                        "Failed to cancel transaction {}, trying to release instead: {}",
                        transaction_id, e
                    );
                    self.send_request(
                        "PUT",
                        &format!("transactions/{}?status=released", transaction_id),
                        None,
                    )
                        .await
                        .unwrap_or_default();
                }
                let response = json!({
                    "status": "cancelled",
                    "message": "Transaction cancelled.",
                });
                self.send_message(&write, response).await;
                // remove trasaction from processing_ids
                let mut processing_ids = self.processing_ids.lock().await;
                processing_ids.retain(|id| id != transaction_id);
                drop(processing_ids); // Release lock
                (0, "Transaction cancelled successfully".to_string())
            }
            "RELEASE_TRANSACTION" => {
                let queue = self
                    .send_request("GET", "queue", None)
                    .await
                    .unwrap_or(json!({}));
                if let Some(queue_data) = queue.as_array() {
                    for item in queue_data {
                        let t_id = item
                            .get("transactionId")
                            .and_then(|t| t.as_str())
                            .unwrap_or("");
                        if t_id == transaction_id {
                            let status = item.get("status").and_then(|s| s.as_str()).unwrap_or("");
                            match self.cancel_transaction(t_id, status).await {
                                Ok(_) => {
                                    let response = json!({
                                        "status": "success",
                                        "message": "Transaction released.",
                                    });
                                    self.send_message(&write, response).await;
                                    return Err((0, "Transaction released successfully".to_string()));
                                }
                                Err(e) => {
                                    error!("Failed to release transaction: {}", e);
                                    return Err((1, e));
                                }
                            }
                        }
                    }
                }
                (0, "Transaction released successfully".to_string())
            }
            "GET_QUEUE" => {
                match self.get_queue().await {
                    Ok(queue) => {
                        let response = json!({
                            "status": "success",
                            "queue": queue,
                            "command": command,
                        });
                        self.send_message(&write, response).await;
                        (0, "Queue retrieved successfully".to_string())
                    }
                    Err(e) => {
                        error!("Failed to get queue: {}", e);
                        (1, e)
                    }
                }
            }
            "LOGOUT" => {
                if let Err(e) = self.logout().await {
                    error!("Failed to log out: {}", e);
                    return Err((1, e));
                }
                let response = json!({
                    "status": "success",
                    "message": "Logged out.",
                });
                self.send_message(&write, response).await;
                (0, "Logged out successfully".to_string())
            }
            "LOGIN" => {
                if let Err(e) = self.login().await {
                    error!("Failed to log in: {}", e);
                    return Err((1, e));
                }
                let response = json!({
                    "status": "success",
                    "message": "Logged in.",
                });
                self.send_message(&write, response).await;
                (0, "Logged in successfully".to_string())
            }
            "CLEAR_TRANSACTION" =>{
                // New command to manually clear queue
                info!("Manually clearing queue");
                let queue = self.get_queue().await.unwrap_or(json!({}));

                if let Some(queue_data) = queue.as_array() {
                    for item in queue_data {
                        let transaction_id = item.get("transactionId").and_then(|t| t.as_str()).unwrap_or("");
                        let status = item.get("status").and_then(|s| s.as_str()).unwrap_or("");
                        let being_handled = item.get("beingHandledBySystem").and_then(|b| b.as_bool()).unwrap_or(false);
                        if !transaction_id.is_empty() {
                            let _ = self.cancel_single_transaction(transaction_id, status, being_handled).await;
                            tokio::time::sleep(Duration::from_millis(1000)).await;
                        }
                    }
                }

                let response = json!({
                    "status": "success",
                    "message": "Queue cleared manually.",
                });
                self.send_message(&write, response).await;
                (0, json!({"status": "success", "message": "Queue cleared successfully"}).to_string())

            }
            _ => {
                error!("Unknown command: {}", command);
                (1, format!("Unknown command: {}", command))
            }
        })
    }
}

#[async_trait]
impl Service for CashGuardService {
    /// Executes a service action based on the provided JSON input.
    ///
    /// # Arguments
    ///
    /// * `action` - A JSON value containing the action details (e.g., command, transaction ID, amount).
    /// * `write` - A `WebSocketWrite` used to send responses back through WebSocket.
    ///
    /// # Returns
    ///
    /// A tuple containing:
    /// * `i32` - Status code (0 for success, 1 for failure).
    /// * `String` - A descriptive message regarding the action result.
    async fn run(&self, action: Value, write: WebSocketWrite) -> (i32, String) {
        let action_data = action.get("ACTION").and_then(|a| a.as_object());
        if action_data.is_none() {
            error!("Invalid action format: missing 'ACTION'");
            return (1, "Invalid action format: missing 'ACTION'".to_string());
        }
        let action_data = action_data.unwrap();

        let command = action_data
            .get("command")
            .and_then(|c| c.as_str())
            .unwrap_or("")
            .to_string();
        let transaction_id = match action_data.get("transaction_id") {
            Some(Value::String(s)) => s.clone(),
            Some(Value::Number(n)) => n.to_string(),
            _ => "".to_string(),
        };

        let amount_due = action_data
            .get("amount_due")
            .and_then(|a| a.as_f64())
            .unwrap_or(0.0);


        match self.handle_command(&write, command, &transaction_id, amount_due).await {
            Ok(value) => value,
            Err(value) => return value,
        }
    }

    /// Converts the service instance into a `dyn Any` reference.
    ///
    /// # Returns
    ///
    /// A reference to `dyn Any` for dynamic type checks
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }

    /// Stops the service, performing any necessary cleanup tasks.
    fn stop_service(&self) {
        info!("CashGuard service stopped.");
    }

    /// Retrieves the current version of the CashGuard service.
    ///
    /// # Returns
    ///
    /// A `String` containing the version of the service.
    fn get_version(&self) -> String {
        CASH_GUARD_VERSION.to_string()
    }
}