use crate::db::get_client;
use crate::errors::{AppError, AppErrorType};

use chrono::{DateTime, Local};
use deadpool_postgres::Pool;
use serde::{Deserialize, Serialize};
use tokio_pg_mapper::FromTokioPostgresRow;
use tokio_pg_mapper_derive::PostgresMapper;

#[derive(Serialize, Deserialize, PostgresMapper)]
#[pg_mapper(table = "commit")]
/// Commit model
pub struct Commit {
    pub hash: String,
    pub tree: Option<String>,
    pub text: String,
    pub date: DateTime<Local>,
    pub author_email: String, // Reference to Email
    pub author_name: String,
    pub committer_email: String, // Reference to Email
    pub committer_name: String,
    pub repository_url: String, // Reference to Repository
}

impl Commit {
    /// Find all commits. Order them by descrescent `date` field
    pub async fn find_all(pool: Pool) -> Result<Vec<Commit>, AppError> {
        let client = get_client(pool.clone()).await.unwrap();
        let statement = client
            .prepare("SELECT * FROM commit ORDER BY date DESC")
            .await?;

        let commits = client
            .query(&statement, &[])
            .await?
            .iter()
            .map(|row| Commit::from_row_ref(row).unwrap())
            .collect::<Vec<Commit>>();

        Ok(commits)
    }

    // Find a commit that it has an hash equals to `hash`
    pub async fn find(pool: Pool, hash: String) -> Result<Commit, AppError> {
        let client = get_client(pool.clone()).await.unwrap();
        let statement = client
            .prepare("SELECT * FROM commit WHERE hash = $1")
            .await?;

        let commit = client
            .query_opt(&statement, &[&hash])
            .await?
            .map(|row| Commit::from_row_ref(&row).unwrap());

        match commit {
            Some(commit) => Ok(commit),
            None => Err(AppError {
                error_type: AppErrorType::NotFoundError,
                cause: None,
                message: Some("Commit not found".to_string()),
            }),
        }
    }
}