use crate::async_handler;
use actix::{Handler, ResponseActFuture, WrapFuture};
use sqlx::PgPool;

use crate::database::Database;
use crate::model::*;

use super::Result;

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("Can't create account")]
    CantCreate,
    #[error("Can't find account does to lack of identity")]
    NoIdentity,
    #[error("Account order does not exists")]
    NotExists,
    #[error("Failed to load all accounts")]
    All,
}

#[derive(actix::Message)]
#[rtype(result = "Result<Vec<AccountOrder>>")]
pub struct AllAccountOrders;

async_handler!(AllAccountOrders, all_account_orders, Vec<AccountOrder>);

pub async fn all_account_orders(_msg: AllAccountOrders, pool: PgPool) -> Result<Vec<AccountOrder>> {
    sqlx::query_as(
        r#"
SELECT id, buyer_id, status
FROM account_orders
    "#,
    )
    .fetch_all(&pool)
    .await
    .map_err(|e| {
        log::error!("{e:?}");
        super::Error::AccountOrder(Error::All)
    })
}

#[derive(actix::Message)]
#[rtype(result = "Result<AccountOrder>")]
pub struct CreateAccountOrder {
    pub buyer_id: AccountId,
    pub status: OrderStatus,
}

async_handler!(CreateAccountOrder, create_account_order, AccountOrder);

async fn create_account_order(msg: CreateAccountOrder, db: PgPool) -> Result<AccountOrder> {
    sqlx::query_as(
        r#"
INSERT INTO account_orders (buyer_id, status)
VALUES ($1, $2)
RETURNING id, buyer_id, status
    "#,
    )
    .bind(msg.buyer_id)
    .bind(msg.status)
    .fetch_one(&db)
    .await
    .map_err(|e| {
        log::error!("{e:?}");
        super::Error::AccountOrder(Error::CantCreate)
    })
}

#[derive(actix::Message)]
#[rtype(result = "Result<AccountOrder>")]
pub struct FindAccountOrder {
    pub id: AccountOrderId,
}

async_handler!(FindAccountOrder, find_account_order, AccountOrder);

async fn find_account_order(msg: FindAccountOrder, db: PgPool) -> Result<AccountOrder> {
    sqlx::query_as(
        r#"
SELECT id, buyer_id, status
FROM account_orders
WHERE id = $1
    "#,
    )
    .bind(msg.id)
    .fetch_one(&db)
    .await
    .map_err(|e| {
        log::error!("{e:?}");
        super::Error::AccountOrder(Error::NotExists)
    })
}