use crate::app_config::AppConfig;
use crate::controllers::HttpResult;
use crate::extractors::auth_extractor::AuthExtractor;
use crate::virtweb_client;
use crate::virtweb_client::{GroupID, VMCaps, VMInfo};
use actix_web::HttpResponse;

#[derive(serde::Serialize)]
struct ServerConfig {
    authenticated: bool,
    disable_auth: bool,
}

pub async fn config(auth: AuthExtractor) -> HttpResult {
    Ok(HttpResponse::Ok().json(ServerConfig {
        authenticated: auth.is_authenticated(),
        disable_auth: AppConfig::get().unsecure_disable_login,
    }))
}

#[derive(Default, Debug, serde::Serialize)]
pub struct Rights {
    groups: Vec<GroupInfo>,
    vms: Vec<VMInfoAndCaps>,
    sys_info: bool,
}

#[derive(Debug, serde::Serialize)]
pub struct GroupInfo {
    id: GroupID,
    vms: Vec<VMInfo>,
    #[serde(flatten)]
    caps: VMCaps,
}

#[derive(Debug, serde::Serialize)]
pub struct VMInfoAndCaps {
    #[serde(flatten)]
    info: VMInfo,
    #[serde(flatten)]
    caps: VMCaps,
}

pub async fn rights() -> HttpResult {
    let rights = virtweb_client::get_token_info().await?;

    let mut res = Rights {
        groups: vec![],
        vms: vec![],
        sys_info: rights.can_retrieve_system_info(),
    };

    for g in rights.list_groups() {
        let group_vms = virtweb_client::group_vm_info(&g).await?;

        res.groups.push(GroupInfo {
            id: g.clone(),
            vms: group_vms,
            caps: VMCaps {
                can_get_state: rights.is_route_allowed("GET", &g.route_vm_state(None)),
                can_start: rights.is_route_allowed("GET", &g.route_vm_start(None)),
                can_shutdown: rights.is_route_allowed("GET", &g.route_vm_shutdown(None)),
                can_kill: rights.is_route_allowed("GET", &g.route_vm_kill(None)),
                can_reset: rights.is_route_allowed("GET", &g.route_vm_reset(None)),
                can_suspend: rights.is_route_allowed("GET", &g.route_vm_suspend(None)),
                can_resume: rights.is_route_allowed("GET", &g.route_vm_resume(None)),
                can_screenshot: rights.is_route_allowed("GET", &g.route_vm_screenshot(None)),
            },
        })
    }

    for v in rights.list_vm() {
        let vm_info = virtweb_client::vm_info(v).await?;

        res.vms.push(VMInfoAndCaps {
            info: vm_info,
            caps: VMCaps {
                can_get_state: rights.is_route_allowed("GET", &v.route_state()),
                can_start: rights.is_route_allowed("GET", &v.route_start()),
                can_shutdown: rights.is_route_allowed("GET", &v.route_shutdown()),
                can_kill: rights.is_route_allowed("GET", &v.route_kill()),
                can_reset: rights.is_route_allowed("GET", &v.route_reset()),
                can_suspend: rights.is_route_allowed("GET", &v.route_suspend()),
                can_resume: rights.is_route_allowed("GET", &v.route_resume()),
                can_screenshot: rights.is_route_allowed("GET", &v.route_screenshot()),
            },
        })
    }

    Ok(HttpResponse::Ok().json(res))
}