use axum::{

    Json, Router,

    extract::{Path, State},

    routing::get,

};

use tenet_aws::{

    models::component::{CreateArchitectureComponentRequest, UpdateArchitectureComponentRequest},

    services::crud::ParentScope,

};

use crate::http::{AppState, JsonResponse, ProjectRequest, UserInfo};

use crate::routes::policy::require_org_admin;

use super::shared::{ContainerComponentPath, ContainerPath};

fn container_scope(user: &UserInfo, path: &ContainerPath) -> ParentScope {

    ParentScope {

        org_id: path.org_id.clone(),

        project_id: path.project_id.clone(),

        parent_id: path.container_id.clone(),

        user_id: user.id.clone(),

    }

}

fn component_scope(user: &UserInfo, path: &ContainerComponentPath) -> ParentScope {

    ParentScope {

        org_id: path.org_id.clone(),

        project_id: path.project_id.clone(),

        parent_id: path.container_id.clone(),

        user_id: user.id.clone(),

    }

}

fn component_id(path: &ContainerComponentPath) -> tenet_aws::models::component::ComponentId {

    path.component_id.clone()

}

pub fn router() -> axum::Router<AppState> {

    Router::new()

        .route(

            "/organisations/{org_id}/projects/{project_id}/containers/{container_id}/components",

            get(list_components).post(create_component),

        )

        .route(

            "/organisations/{org_id}/projects/{project_id}/containers/{container_id}/components/{component_id}",

            get(get_component).put(update_component).delete(delete_component),

        )

}

async fn list_components(

    State(state): State<AppState>,

    req: ProjectRequest<ContainerPath>,

) -> axum::response::Response {

    let ProjectRequest { user, path } = req;

    let scope = container_scope(&user, &path);

    JsonResponse::ok_result_with_context(

        state

            .component

            .list_architecture_components_for_container(

                &scope.org_id,

                &scope.project_id,

                &scope.parent_id,

            )

            .await,

        "Failed to list components",

    )

}

async fn create_component(

    State(state): State<AppState>,

    req: ProjectRequest<ContainerPath>,

    Json(body): Json<CreateArchitectureComponentRequest>,

) -> axum::response::Response {

    let ProjectRequest { user, path } = req;

    let scope = container_scope(&user, &path);

    JsonResponse::created_result_with_context(

        state

            .component

            .create_component(

                &scope.org_id,

                &scope.project_id,

                &scope.user_id,

                &scope.parent_id,

                &body,

            )

            .await,

        "Failed to create component",

    )

}

async fn get_component(

    State(state): State<AppState>,

    req: ProjectRequest<ContainerComponentPath>,

) -> axum::response::Response {

    let ProjectRequest { user, path } = req;

    let scope = component_scope(&user, &path);

    let id = component_id(&path);

    JsonResponse::ok_result_with_context(

        state

            .component

            .get_architecture_component_scoped_to_container(

                &scope.org_id,

                &scope.project_id,

                &scope.parent_id,

                &id,

            )

            .await,

        "Failed to get component",

    )

}

async fn update_component(

    State(state): State<AppState>,

    req: ProjectRequest<ContainerComponentPath>,

    Json(body): Json<UpdateArchitectureComponentRequest>,

) -> axum::response::Response {

    let ProjectRequest { user, path } = req;

    let scope = component_scope(&user, &path);

    let id = component_id(&path);

    JsonResponse::ok_result_with_context(

        state

            .component

            .update_architecture_component_scoped_to_container(

                &scope.org_id,

                &scope.project_id,

                &scope.user_id,

                &scope.parent_id,

                &id,

                body,

            )

            .await,

        "Failed to update component",

    )

}

async fn delete_component(

    State(state): State<AppState>,

    user: UserInfo,

    Path(path): Path<ContainerComponentPath>,

) -> axum::response::Response {

    if let Err(err) = require_org_admin(&state, &path.org_id, &user.id).await {

        return JsonResponse::error(err);

    }

    let scope = component_scope(&user, &path);

    let id = component_id(&path);

    JsonResponse::no_content_result_with_context(

        state

            .component

            .delete_architecture_component_scoped_to_container(

                &scope.org_id,

                &scope.project_id,

                &scope.user_id,

                &scope.parent_id,

                &id,

            )

            .await,

        "Failed to delete component",

    )

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::routes::test_support;

    #[allure_rs::allure_parent_suite("tenet-api")]

    #[allure_rs::allure_test]

    #[tokio::test]

    async fn test_component_routes_exist() {

        let _router = router();

    }

    #[allure_rs::allure_parent_suite("tenet-api")]

    #[allure_rs::allure_test]

    #[test]

    fn test_component_scope_mapping() {

        let user = test_support::user("user-3");

        let list_path = ContainerPath {

            org_id: test_support::org_id(),

            project_id: test_support::project_id(),

            container_id: test_support::app_id(),

        };

        let item_path = ContainerComponentPath {

            org_id: test_support::org_id(),

            project_id: test_support::project_id(),

            container_id: test_support::app_id(),

            component_id: test_support::library_id(),

        };

        let list_scope = container_scope(&user, &list_path);

        let item_scope = component_scope(&user, &item_path);

        let id = component_id(&item_path);

        assert_eq!(list_scope.user_id.to_string(), "user-3");

        assert_eq!(

            item_scope.project_id.to_string(),

            test_support::PROJECT_ID_STR

        );

        assert_eq!(item_scope.parent_id.to_string(), test_support::APP_ID_STR);

        assert_eq!(id.to_string(), test_support::LIB_ID_STR);

    }

}