//
use crate::{api_result::APIResult, f, FullCtx};

use crate::nextcloud::model::{NextcloudHostname, NextcloudPassword, NextcloudUsername};
use model::{Board, Card, NextcloudBoardId, Stack};

pub mod model;

#[cfg(test)]
mod tests;

pub(crate) struct DeckClient<'ctx> {
    ctx: &'ctx FullCtx,
    hostname: &'ctx NextcloudHostname,
    username: &'ctx NextcloudUsername,
    password: &'ctx NextcloudPassword,
}
impl<'ctx> DeckClient<'ctx> {
    pub fn new(ctx: &'ctx FullCtx) -> Self {
        Self {
            ctx,
            hostname: &ctx.cfg.nextcloud.hostname,
            username: &ctx.cfg.nextcloud.username,
            password: &ctx.cfg.nextcloud.password,
        }
    }

    fn url(&self, path: impl Into<String>) -> String {
        f!(
            "https://{}/index.php/apps/deck/api/v1.0/{}",
            self.hostname,
            path.into()
        )
    }

    pub async fn get_boards(&self) -> APIResult<Vec<Board>> {
        APIResult::new(
            self.ctx
                .net
                .get(self.url("boards"))
                .basic_auth(self.username.as_str(), Some(self.password.as_str()))
                .header("accept", "application/json")
                .send()
                .await,
            &self.ctx.prt,
        )
        .await
    }

    pub async fn get_board(&self, board_id: NextcloudBoardId) -> APIResult<Board> {
        APIResult::new(
            self.ctx
                .net
                .get(self.url(f!("boards/{board_id}")))
                .basic_auth(self.username.as_str(), Some(self.password.as_str()))
                .header("accept", "application/json")
                .send()
                .await,
            &self.ctx.prt,
        )
        .await
    }

    pub async fn create_board(&self, title: &str, color: &str) -> APIResult<Board> {
        APIResult::new(
            self.ctx
                .net
                .post(self.url("boards"))
                .basic_auth(self.username.as_str(), Some(self.password.as_str()))
                .header("accept", "application/json")
                .body(
                    serde_json::json!({
                        "title": title,
                        "color": color
                    })
                    .to_string(),
                )
                .send()
                .await,
            &self.ctx.prt,
        )
        .await
    }

    pub async fn get_stacks(&self, board_id: NextcloudBoardId) -> APIResult<Vec<Stack>> {
        APIResult::new(
            self.ctx
                .net
                .get(self.url(f!("boards/{board_id}/stacks")))
                .basic_auth(self.username.as_str(), Some(self.password.as_str()))
                .header("accept", "application/json")
                .send()
                .await,
            &self.ctx.prt,
        )
        .await
    }

    pub async fn create_card(
        &self,
        board_id: i64,
        stack_id: i64,
        title: &str,
        description: Option<&str>,
    ) -> APIResult<Card> {
        let url = format!(
            "https://{}/index.php/apps/deck/api/v1.0/boards/{}/stacks/{}/cards",
            self.hostname, board_id, stack_id
        );

        let mut json = serde_json::json!({
            "title": title,
        });

        if let Some(desc) = description {
            json["description"] = serde_json::Value::String(desc.to_string());
        }

        APIResult::new(
            self.ctx
                .net
                .post(&url)
                .basic_auth(self.username.as_str(), Some(self.password.as_str()))
                .header("accept", "application/json")
                .body(json.to_string())
                .send()
                .await,
            &self.ctx.prt,
        )
        .await
    }
}