use crate::AppModules;
use crate::errors::AppError;
use context::Context;
use models::active_enums::MemberRole;
use models::project::{project_history_names, project_members, projects};
use models::repos::repo;
use sea_orm::*;
use uuid::Uuid;

impl AppModules {
    pub async fn find_project_by_name(&self, name: String) -> Result<projects::Model, AppError> {
        match projects::Entity::find()
            .filter(projects::Column::Name.eq(name.clone()))
            .one(&self.db.reader())
            .await
            .ok()
            .flatten()
        {
            Some(project) => Ok(project),
            None => match project_history_names::Entity::find()
                .filter(project_history_names::Column::HistoryName.eq(name))
                .one(&self.db.reader())
                .await
                .ok()
                .flatten()
            {
                Some(project) => self.find_project_by_uid(project.project_uid).await,
                None => Err(AppError::ProjectNotFound),
            },
        }
    }

    pub async fn find_project_by_uid(&self, uid: Uuid) -> Result<projects::Model, AppError> {
        projects::Entity::find_by_id(uid)
            .one(&self.db.reader())
            .await
            .ok()
            .flatten()
            .ok_or(AppError::ProjectNotFound)
    }

    pub async fn check_project_permission(
        &self,
        project_id: &Uuid,
        user_id: Uuid,
        required_scopes: &[MemberRole],
    ) -> Result<(), AppError> {
        let member = project_members::Entity::find()
            .filter(project_members::Column::ProjectId.eq(*project_id))
            .filter(project_members::Column::UserId.eq(user_id))
            .one(&self.db.reader())
            .await?;

        if let Some(member) = member {
            for scope in required_scopes {
                if &member.scope == scope {
                    return Ok(());
                }
            }
        }

        Err(AppError::NoPower)
    }
    pub async fn project_context_role(
        &self,
        context: &Context,
        project_name: String,
    ) -> Result<MemberRole, AppError> {
        let user_uid = context.user().ok_or(AppError::Unauthorized)?;
        let project = self.find_project_by_name(project_name).await?;
        let members = project_members::Entity::find()
            .filter(project_members::Column::ProjectId.eq(project.uid))
            .filter(project_members::Column::UserId.eq(user_uid))
            .one(&self.db.reader())
            .await
            .map_err(|_| AppError::InternalError)?
            .map(|m| m.scope);
        members.ok_or(AppError::Unauthorized)
    }

    pub async fn find_repo_by_name(
        &self,
        project_uid: Uuid,
        repo_name: &str,
    ) -> Result<repo::Model, AppError> {
        repo::Entity::find()
            .filter(repo::Column::ProjectUid.eq(project_uid))
            .filter(repo::Column::RepoName.eq(repo_name))
            .one(&self.db.reader())
            .await?
            .ok_or(AppError::NotFound(format!("Repository '{}' not found", repo_name)))
    }
}