use crate::db_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 order")]
    CantCreate,
    #[error("Can't find account order does to lack of identity")]
    NoIdentity,
    #[error("Account order does not exists")]
    NotExists,
    #[error("Failed to load all account orders")]
    All,
}

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

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

pub(crate) async fn all_account_orders(
    _msg: AllAccountOrders,
    pool: PgPool,
) -> Result<Vec<AccountOrder>> {
    sqlx::query_as(
        r#"
SELECT id, buyer_id, status, order_id
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,
    pub order_id: Option<OrderId>,
}

db_async_handler!(CreateAccountOrder, create_account_order, AccountOrder);

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

#[derive(actix::Message)]
#[rtype(result = "Result<AccountOrder>")]
pub struct UpdateAccountOrder {
    pub id: AccountOrderId,
    pub buyer_id: AccountId,
    pub status: OrderStatus,
    pub order_id: Option<OrderId>,
}

db_async_handler!(UpdateAccountOrder, update_account_order, AccountOrder);

pub(crate) async fn update_account_order(
    msg: UpdateAccountOrder,
    db: PgPool,
) -> Result<AccountOrder> {
    sqlx::query_as(
        r#"
UPDATE account_orders 
SET buyer_id = $2 AND status = $3 AND order_id = $4
WHERE id = $1
RETURNING id, buyer_id, status, order_id
    "#,
    )
    .bind(msg.id)
    .bind(msg.buyer_id)
    .bind(msg.status)
    .bind(msg.order_id)
    .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,
}

db_async_handler!(FindAccountOrder, find_account_order, AccountOrder);

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