use models::repo::repo_license;
use sea_orm::{ActiveModelTrait, EntityTrait, QueryOrder, QuerySelect, Set};
use serde::{Deserialize, Serialize};
use time::OffsetDateTime;
use utoipa::ToSchema;

use crate::service::GitService;
use crate::share::errors::GitError;

#[derive(Debug, Clone, Serialize, ToSchema)]
pub struct LicenseDto {
    pub name: String,
    pub display_name: String,
    pub description: Option<String>,
    pub body: String,
    pub url: Option<String>,
    pub created_at: OffsetDateTime,
    pub updated_at: OffsetDateTime,
}

impl From<repo_license::Model> for LicenseDto {
    fn from(m: repo_license::Model) -> Self {
        Self {
            name: m.name,
            display_name: m.display_name,
            description: m.description,
            body: m.body,
            url: m.url,
            created_at: m.created_at,
            updated_at: m.updated_at,
        }
    }
}

#[derive(Debug, Clone, Deserialize, ToSchema)]
pub struct UpsertLicenseCmd {
    pub display_name: String,
    pub description: Option<String>,
    pub body: String,
    pub url: Option<String>,
}

impl GitService {
    pub async fn get_license(&self, name: &str) -> Result<LicenseDto, GitError> {
        let row = repo_license::Entity::find_by_id(name.to_string())
            .one(self.db_read())
            .await?
            .ok_or(GitError::NotFound)?;
        Ok(row.into())
    }

    pub async fn list_licenses(
        &self,
        limit: u64,
        offset: u64,
    ) -> Result<Vec<LicenseDto>, GitError> {
        let rows = repo_license::Entity::find()
            .order_by_asc(repo_license::Column::Name)
            .limit(limit)
            .offset(offset)
            .all(self.db_read())
            .await?;
        Ok(rows.into_iter().map(Into::into).collect())
    }

    pub async fn upsert_license(
        &self,
        name: &str,
        cmd: UpsertLicenseCmd,
    ) -> Result<LicenseDto, GitError> {
        if name.is_empty() {
            return Err(GitError::InvalidArgument(
                "license name must not be empty".to_string(),
            ));
        }
        if cmd.display_name.is_empty() {
            return Err(GitError::InvalidArgument(
                "license display_name must not be empty".to_string(),
            ));
        }
        if cmd.body.is_empty() {
            return Err(GitError::InvalidArgument(
                "license body must not be empty".to_string(),
            ));
        }
        let now = OffsetDateTime::now_utc();
        let existing = repo_license::Entity::find_by_id(name.to_string())
            .one(self.db_read())
            .await?;
        let saved = if let Some(row) = existing {
            let mut am: repo_license::ActiveModel = row.into();
            am.display_name = Set(cmd.display_name);
            am.description = Set(cmd.description);
            am.body = Set(cmd.body);
            am.url = Set(cmd.url);
            am.updated_at = Set(now);
            am.update(self.db_write()).await?
        } else {
            let am = repo_license::ActiveModel {
                name: Set(name.to_string()),
                display_name: Set(cmd.display_name),
                description: Set(cmd.description),
                body: Set(cmd.body),
                url: Set(cmd.url),
                created_at: Set(now),
                updated_at: Set(now),
            };
            am.insert(self.db_write()).await?
        };
        Ok(saved.into())
    }

    pub async fn license_exists(&self, name: &str) -> Result<bool, GitError> {
        let row = repo_license::Entity::find_by_id(name.to_string())
            .one(self.db_read())
            .await?;
        Ok(row.is_some())
    }
}