use anyhow::{anyhow, Result};
use clusterflux_control::ControlSession;
use clusterflux_core::coordinator_wire_request;
use serde_json::{json, Value};

use crate::virtual_model::AdapterState;

pub(crate) fn client_user_request(state: &AdapterState, mut request: Value) -> Value {
    let Some(session_secret) = state.client_session_secret.as_deref() else {
        return request;
    };
    if let Value::Object(fields) = &mut request {
        fields.remove("tenant");
        fields.remove("project");
        fields.remove("actor_user");
    }
    json!({
        "type": "authenticated",
        "session_secret": session_secret,
        "request": request,
    })
}

pub(super) struct CoordinatorSession {
    session: ControlSession,
}

impl CoordinatorSession {
    pub(super) fn connect(addr: &str) -> Result<Self> {
        Ok(Self {
            session: ControlSession::connect(addr)?,
        })
    }

    pub(super) fn request(&mut self, request: Value) -> Result<Value> {
        let response = self.request_allow_error(request)?;
        if response.get("type").and_then(Value::as_str) == Some("error") {
            return Err(anyhow!(
                "{}",
                response
                    .get("message")
                    .and_then(Value::as_str)
                    .unwrap_or("coordinator returned an error")
            ));
        }
        Ok(response)
    }

    pub(super) fn request_allow_error(&mut self, request: Value) -> Result<Value> {
        let wire_request = coordinator_wire_request("dap-1", request);
        Ok(self.session.request(&wire_request)?)
    }
}

pub(super) fn coordinator_request(addr: &str, request: Value) -> Result<Value> {
    CoordinatorSession::connect(addr)?.request(request)
}

pub(super) fn coordinator_request_allow_error(addr: &str, request: Value) -> Result<Value> {
    CoordinatorSession::connect(addr)?.request_allow_error(request)
}