tetratto-core 16.0.1

use std::collections::HashMap;
use crate::model::{
    auth::{Notification, User},
    economy::{CoinTransfer, CoinTransferMethod, CoinTransferSource, Product},
    Error, Result,
};
use crate::{auto_method, DataManager};
use oiseau::{cache::Cache, execute, get, params, query_row, query_rows, PostgresRow};

impl DataManager {
    /// Get a [`CoinTransfer`] from an SQL row.
    pub(crate) fn get_transfer_from_row(x: &PostgresRow) -> CoinTransfer {
        CoinTransfer {
            id: get!(x->0(i64)) as usize,
            created: get!(x->1(i64)) as usize,
            sender: get!(x->2(i64)) as usize,
            receiver: get!(x->3(i64)) as usize,
            amount: get!(x->4(i32)),
            is_pending: get!(x->5(i32)) as i8 == 1,
            method: serde_json::from_str(&get!(x->6(String))).unwrap(),
            source: serde_json::from_str(&get!(x->7(String))).unwrap(),
        }
    }

    auto_method!(get_transfer_by_id(usize as i64)@get_transfer_from_row -> "SELECT * FROM transfers WHERE id = $1" --name="transfer" --returns=CoinTransfer --cache-key-tmpl="atto.transfer:{}");

    /// Fill a list of transfers with their users and product.
    pub async fn fill_transfers(
        &self,
        list: Vec<CoinTransfer>,
    ) -> Result<Vec<(User, User, Option<Product>, CoinTransfer)>> {
        let mut out = Vec::new();
        let mut seen_users: HashMap<usize, User> = HashMap::new();
        let mut seen_products: HashMap<usize, Product> = HashMap::new();

        for transfer in list {
            out.push((
                if let Some(user) = seen_users.get(&transfer.sender) {
                    user.to_owned()
                } else {
                    let user = self.get_user_by_id(transfer.sender).await?;
                    seen_users.insert(user.id, user.clone());
                    user
                },
                if let Some(user) = seen_users.get(&transfer.receiver) {
                    user.to_owned()
                } else {
                    let user = self.get_user_by_id(transfer.receiver).await?;
                    seen_users.insert(user.id, user.clone());
                    user
                },
                match transfer.method {
                    CoinTransferMethod::Transfer => None,
                    CoinTransferMethod::Purchase(id) => {
                        if let Some(product) = seen_products.get(&id) {
                            Some(product.to_owned())
                        } else {
                            match self.get_product_by_id(id).await {
                                Ok(product) => {
                                    seen_products.insert(product.id, product.clone());
                                    Some(product)
                                }
                                Err(_) => None,
                            }
                        }
                    }
                },
                transfer,
            ));
        }

        Ok(out)
    }

    /// Get all transfers by user.
    ///
    /// # Arguments
    /// * `id` - the ID of the user to fetch transfers for
    /// * `batch` - the limit of items in each page
    /// * `page` - the page number
    pub async fn get_transfers_by_user(
        &self,
        id: usize,
        batch: usize,
        page: usize,
    ) -> Result<Vec<CoinTransfer>> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = query_rows!(
            &conn,
            "SELECT * FROM transfers WHERE sender = $1 OR receiver = $1 ORDER BY created DESC LIMIT $2 OFFSET $3",
            &[&(id as i64), &(batch as i64), &((page * batch) as i64)],
            |x| { Self::get_transfer_from_row(x) }
        );

        if res.is_err() {
            return Err(Error::GeneralNotFound("transfer".to_string()));
        }

        Ok(res.unwrap())
    }

    /// Get a transfer by user and method.
    ///
    /// # Arguments
    /// * `id` - the ID of the user to fetch transfers for
    /// * `method` - the transfer method
    pub async fn get_transfer_by_sender_method(
        &self,
        id: usize,
        method: CoinTransferMethod,
    ) -> Result<CoinTransfer> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = query_row!(
            &conn,
            "SELECT * FROM transfers WHERE sender = $1 AND method = $2 LIMIT 1",
            params![&(id as i64), &serde_json::to_string(&method).unwrap()],
            |x| { Ok(Self::get_transfer_from_row(x)) }
        );

        if res.is_err() {
            return Err(Error::GeneralNotFound("transfer".to_string()));
        }

        Ok(res.unwrap())
    }

    /// Create a new transfer in the database.
    ///
    /// # Arguments
    /// * `data` - a mock [`CoinTransfer`] object to insert
    pub async fn create_transfer(&self, data: &mut CoinTransfer, apply: bool) -> Result<usize> {
        // check values
        let mut sender = self.get_user_by_id(data.sender).await?;
        let mut receiver = self.get_user_by_id(data.receiver).await?;

        if sender.id == self.0.0.system_user {
            // system user can create coins from the void
            sender.coins = i32::MAX;
        }

        let (sender_bankrupt, receiver_bankrupt) = data.apply(&mut sender, &mut receiver);

        if sender_bankrupt | receiver_bankrupt {
            return Err(Error::MiscError(
                "One party of this transfer cannot afford this".to_string(),
            ));
        }

        if apply {
            if sender.id != self.0.0.system_user {
                self.update_user_coins(sender.id, sender.coins).await?;
            }

            self.update_user_coins(receiver.id, receiver.coins).await?;

            // handle refund notification
            if data.source == CoinTransferSource::Refund {
                self.create_notification(Notification::new(
                    "A coin refund has been issued to your account!".to_string(),
                    "You've been issued a refund for a prior purchase. The product will remain in your account, but your coins have been returned.".to_string(),
                    receiver.id,
                ))
                .await?;
            }
        } else {
            // we haven't applied the transfer, so this must be pending
            data.is_pending = true;
        }

        // ...
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = execute!(
            &conn,
            "INSERT INTO transfers VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
            params![
                &(data.id as i64),
                &(data.created as i64),
                &(data.sender as i64),
                &(data.receiver as i64),
                &data.amount,
                &{ if data.is_pending { 1 } else { 0 } },
                &serde_json::to_string(&data.method).unwrap(),
                &serde_json::to_string(&data.source).unwrap(),
            ]
        );

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        Ok(data.id)
    }

    /// Apply a pending transfer.
    pub async fn apply_transfer(&self, id: usize) -> Result<()> {
        let transfer = self.get_transfer_by_id(id).await?;

        let mut sender = self.get_user_by_id(transfer.sender).await?;
        let mut receiver = self.get_user_by_id(transfer.receiver).await?;
        let (sender_bankrupt, receiver_bankrupt) = transfer.apply(&mut sender, &mut receiver);

        if sender_bankrupt | receiver_bankrupt {
            return Err(Error::MiscError(
                "One party of this transfer cannot afford this".to_string(),
            ));
        }

        self.update_user_coins(sender.id, sender.coins).await?;
        self.update_user_coins(receiver.id, receiver.coins).await?;
        self.update_transfer_is_pending(id, 0).await?;

        self.create_notification(Notification::new(
            "Purchase fulfilled!".to_string(),
            format!(
                "You've just successfully fulfilled a purchase for a [product](/product/{}).",
                match transfer.method {
                    CoinTransferMethod::Purchase(x) => x,
                    _ => 0,
                }
            ),
            receiver.id,
        ))
        .await?;

        self.create_notification(Notification::new(
            "Purchase fulfilled!".to_string(),
            format!(
                "Your purchase for a [product](/product/{}) has been fulfilled.",
                match transfer.method {
                    CoinTransferMethod::Purchase(x) => x,
                    _ => 0,
                }
            ),
            sender.id,
        ))
        .await?;

        Ok(())
    }

    auto_method!(update_transfer_is_pending(i32) -> "UPDATE transfers SET is_pending = $1 WHERE id = $2" --cache-key-tmpl="atto.transfer:{}");
}