pub mod panel;

use crate::panels::panel::{PanelRequired, PanelUpdate};
use panel::Panel;
use sqlx::SqlitePool;
use uuid::Uuid;

pub struct PanelService {
    pool: SqlitePool,
}

impl PanelService {
    pub fn new(pool: SqlitePool) -> Self {
        Self { pool }
    }

    pub async fn create(&self, name: &str, data: &str) -> anyhow::Result<Uuid> {
        let id = Uuid::new_v4();
        let id_string = id.to_string();

        let mut transaction = self.pool.begin().await?;

        let _ = sqlx::query!(
            r#"
                INSERT INTO PANELS (id, name, data, deleted)
                VALUES ($1, $2, $3, FALSE);
            "#,
            id_string,
            name,
            data
        )
        .execute(&mut *transaction)
        .await?;

        transaction.commit().await?;

        Ok(id)
    }

    pub async fn read_all(&self) -> anyhow::Result<Vec<PanelRequired>> {
        let mut transaction = self.pool.begin().await?;

        let panels = sqlx::query_as!(
            PanelRequired,
            r#"
                    SELECT id, name
                    FROM PANELS
                    WHERE deleted = FALSE
                "#,
        )
        .fetch_all(&mut *transaction)
        .await?;

        transaction.commit().await?;

        Ok(panels)
    }

    pub async fn read(&self, id: Uuid) -> anyhow::Result<Option<Panel>> {
        let mut transaction = self.pool.begin().await?;

        let panel = sqlx::query_as(
            r#"
                    SELECT id, name, data
                    FROM PANELS
                    WHERE id = $1 AND deleted = FALSE
                "#,
        )
        .bind(id.to_string())
        .fetch_optional(&mut *transaction)
        .await?;

        transaction.commit().await?;

        Ok(panel)
    }

    pub async fn update(&self, id: Uuid, data: PanelUpdate) -> anyhow::Result<()> {
        let id = id.to_string();
        let mut transaction = self.pool.begin().await?;

        if let Some(name) = data.name {
            let _ = sqlx::query!(
                r#"
                        UPDATE PANELS
                        SET name = $2
                        WHERE id = $1;
                    "#,
                id,
                name
            )
            .execute(&mut *transaction)
            .await?;
        }
        if let Some(data) = data.data {
            let _ = sqlx::query!(
                r#"
                        UPDATE PANELS
                        SET data = $2
                        WHERE id = $1;
                    "#,
                id,
                data
            )
            .execute(&mut *transaction)
            .await?;
        }

        transaction.commit().await?;

        Ok(())
    }

    pub async fn delete(&self, id: Uuid) -> anyhow::Result<()> {
        let id = id.to_string();
        let mut transaction = self.pool.begin().await?;

        let _ = sqlx::query!(
            r#"
                    UPDATE PANELS
                    SET deleted = TRUE
                    WHERE id = $1;
                "#,
            id,
        )
        .execute(&mut *transaction)
        .await?;

        transaction.commit().await?;

        Ok(())
    }
}