use crate::items::{CreatedItem, Item};
use async_graphql::{Context, EmptySubscription, Object, Schema};
use como_domain::item::queries::{GetItemQuery, GetItemsQuery};
use como_domain::item::requests::CreateItemDto;
use como_domain::projects::mutation::CreateProjectMutation;
use como_domain::projects::queries::GetProjectQuery;
use como_domain::projects::ProjectDto;
use como_domain::users::User;
use como_infrastructure::register::ServiceRegister;

pub type ComoSchema = Schema<QueryRoot, MutationRoot, EmptySubscription>;

pub struct MutationRoot;

#[Object]
impl MutationRoot {
    async fn create_item(
        &self,
        ctx: &Context<'_>,
        item: CreateItemDto,
    ) -> anyhow::Result<CreatedItem> {
        let services_register = ctx.data_unchecked::<ServiceRegister>();

        let created_item = services_register.item_service.add_item(item).await?;

        Ok(CreatedItem {
            id: created_item.id,
        })
    }

    async fn create_project(
        &self,
        ctx: &Context<'_>,
        request: CreateProjectMutation,
    ) -> anyhow::Result<ProjectDto> {
        let user = ctx.data_unchecked::<User>();

        let services_register = ctx.data_unchecked::<ServiceRegister>();

        let project = services_register
            .project_service
            .create_project(request, user)
            .await?;

        Ok(project)
    }
}

pub struct QueryRoot;

#[Object]
impl QueryRoot {
    async fn get_item(&self, ctx: &Context<'_>, query: GetItemQuery) -> anyhow::Result<Item> {
        let item = ctx
            .data_unchecked::<ServiceRegister>()
            .item_service
            .get_item(query)
            .await?;

        Ok(Item::from(item))
    }

    async fn get_items(
        &self,
        ctx: &Context<'_>,
        query: GetItemsQuery,
    ) -> anyhow::Result<Vec<Item>> {
        let items = ctx
            .data_unchecked::<ServiceRegister>()
            .item_service
            .get_items(query)
            .await?;

        Ok(items.iter().map(|i| Item::from(i.clone())).collect())
    }

    // Projects
    async fn get_project(
        &self,
        ctx: &Context<'_>,
        query: GetProjectQuery,
    ) -> anyhow::Result<ProjectDto> {
        ctx.data_unchecked::<ServiceRegister>()
            .project_service
            .get_project(query)
            .await
    }

    async fn get_projects(&self, ctx: &Context<'_>) -> anyhow::Result<Vec<ProjectDto>> {
        let user = ctx.data_unchecked::<User>();

        ctx.data_unchecked::<ServiceRegister>()
            .project_service
            .get_projects(user)
            .await
    }
}