use std::path::PathBuf;

use anyhow::Result;
use serde_json::{json, Value};

use crate::client::{
    authenticated_or_local_trusted_request, list_attached_nodes_if_available_with_session,
    list_task_events_if_available_with_session, stored_session_for_coordinator, JsonLineSession,
};
use crate::config::{effective_project_scope, read_cli_session, read_project_config};
use crate::process_events::{quota_current_usage, quota_limits_value, quota_next_blocked_action};
use crate::QuotaStatusArgs;

pub(crate) fn quota_status_report(args: QuotaStatusArgs, cwd: PathBuf) -> Result<Value> {
    let config = read_project_config(&cwd)?;
    let stored_session = read_cli_session(&cwd)?;
    let mut effective_scope = effective_project_scope(&args.scope, config.as_ref());
    if effective_scope.coordinator.is_none() {
        effective_scope.coordinator = stored_session
            .as_ref()
            .filter(|session| session.session_secret.is_some())
            .map(|session| session.coordinator.clone());
    }
    if let Some(bound_session) = effective_scope
        .coordinator
        .as_deref()
        .and_then(|coordinator| {
            stored_session_for_coordinator(coordinator, stored_session.as_ref())
        })
    {
        effective_scope.tenant = bound_session.tenant.clone();
        effective_scope.project = bound_session.project.clone();
        effective_scope.user = bound_session.user.clone();
    }
    let coordinator = effective_scope.coordinator.clone();
    let attached_nodes = list_attached_nodes_if_available_with_session(
        coordinator.as_deref(),
        &effective_scope,
        stored_session.as_ref(),
    )?;
    let task_events = list_task_events_if_available_with_session(
        coordinator.as_deref(),
        &effective_scope,
        None,
        stored_session.as_ref(),
    )?;
    let quota_status = if let Some(coordinator) = coordinator.as_deref() {
        let mut session = JsonLineSession::connect(coordinator)?;
        Some(session.request(authenticated_or_local_trusted_request(
            coordinator,
            stored_session.as_ref(),
            json!({ "type": "quota_status" }),
            json!({
                "type": "quota_status",
                "tenant": effective_scope.tenant,
                "project": effective_scope.project,
                "actor_user": effective_scope.user,
            }),
        )?)?)
    } else {
        None
    };
    let mut current_usage = quota_current_usage(&attached_nodes, task_events.as_ref());
    if let (Some(object), Some(status)) = (current_usage.as_object_mut(), quota_status.as_ref()) {
        object.insert(
            "scoped_resource_usage".to_owned(),
            status.get("usage").cloned().unwrap_or(Value::Null),
        );
        object.insert(
            "window_started_epoch_seconds".to_owned(),
            status
                .get("window_started_epoch_seconds")
                .cloned()
                .unwrap_or(Value::Null),
        );
    }
    let limits = quota_status
        .as_ref()
        .and_then(|status| status.pointer("/limits/limits"))
        .cloned()
        .unwrap_or_else(quota_limits_value);
    let window_seconds = quota_status
        .as_ref()
        .and_then(|status| status.get("window_seconds"))
        .cloned()
        .unwrap_or(Value::Null);
    let quota_tier = quota_status
        .as_ref()
        .and_then(|status| status.get("policy_label"))
        .cloned()
        .unwrap_or(Value::Null);
    Ok(json!({
        "command": "quota status",
        "tenant": effective_scope.tenant,
        "project": effective_scope.project,
        "user": effective_scope.user,
        "coordinator": coordinator,
        "project_config": config,
        "policy_surface": "generic public quota categories; hosted tuning remains private policy",
        "limits": limits,
        "window_seconds": window_seconds,
        "current_usage": current_usage,
        "attached_nodes": attached_nodes,
        "task_events": task_events,
        "next_blocked_action": quota_next_blocked_action(&current_usage),
        "quota_configuration_source": if quota_status.is_some() { "coordinator" } else { "unavailable_offline" },
        "quota_tier": quota_tier,
        "private_abuse_heuristics_exposed": false,
        "quota_response": quota_status,
    }))
}