from __future__ import annotations

import sys
from typing import Any

from ..k8s.client import get_json as _default_get_json
from .cluster_state_flux_events import *
from .cluster_state_nodes import *
from .cluster_state_pods import *
from .cluster_state_workloads import *


PodFetchResult = tuple[list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]], dict[str, Any]]


def _get_json(path: str) -> dict[str, Any]:
    facade = sys.modules.get("ariadne.services.cluster_state")
    getter = getattr(facade, "get_json", _default_get_json) if facade is not None else _default_get_json
    return getter(path)

def _fetch_nodes(errors: list[str]) -> tuple[dict[str, Any], list[dict[str, Any]], dict[str, Any]]:
    nodes: dict[str, Any] = {}
    details: list[dict[str, Any]] = []
    summary: dict[str, Any] = {}
    try:
        payload = _get_json("/api/v1/nodes")
        nodes = _summarize_nodes(payload)
        details = _node_details(payload)
        summary = _summarize_inventory(details)
    except Exception as exc:
        errors.append(f"nodes: {exc}")
    return nodes, details, summary


def _fetch_flux(errors: list[str]) -> dict[str, Any]:
    try:
        payload = _get_json(
            "/apis/kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations"
        )
        return _summarize_kustomizations(payload)
    except Exception as exc:
        errors.append(f"flux: {exc}")
    return {}


def _fetch_pods(errors: list[str]) -> PodFetchResult:
    workloads: list[dict[str, Any]] = []
    namespace_pods: list[dict[str, Any]] = []
    namespace_nodes: list[dict[str, Any]] = []
    node_pods: list[dict[str, Any]] = []
    pod_issues: dict[str, Any] = {}
    try:
        pods_payload = _get_json("/api/v1/pods?limit=5000")
        workloads = _summarize_workloads(pods_payload)
        namespace_pods = _summarize_namespace_pods(pods_payload)
        namespace_nodes = _summarize_namespace_nodes(pods_payload)
        node_pods = _summarize_node_pods(pods_payload)
        pod_issues = _summarize_pod_issues(pods_payload)
    except Exception as exc:
        errors.append(f"pods: {exc}")
    return workloads, namespace_pods, namespace_nodes, node_pods, pod_issues


def _fetch_jobs(errors: list[str]) -> dict[str, Any]:
    try:
        jobs_payload = _get_json("/apis/batch/v1/jobs?limit=2000")
        return _summarize_jobs(jobs_payload)
    except Exception as exc:
        errors.append(f"jobs: {exc}")
    return {}

def _fetch_longhorn(errors: list[str]) -> dict[str, Any]:
    try:
        payload = _get_json(
            "/apis/longhorn.io/v1beta2/namespaces/longhorn-system/volumes"
        )
        return _summarize_longhorn_volumes(payload)
    except Exception as exc:
        errors.append(f"longhorn: {exc}")
    return {}


def _fetch_workload_health(errors: list[str]) -> dict[str, Any]:
    try:
        deployments_payload = _get_json("/apis/apps/v1/deployments?limit=2000")
        statefulsets_payload = _get_json("/apis/apps/v1/statefulsets?limit=2000")
        daemonsets_payload = _get_json("/apis/apps/v1/daemonsets?limit=2000")
        deployments = _summarize_deployments(deployments_payload)
        statefulsets = _summarize_statefulsets(statefulsets_payload)
        daemonsets = _summarize_daemonsets(daemonsets_payload)
        return _summarize_workload_health(deployments, statefulsets, daemonsets)
    except Exception as exc:
        errors.append(f"workloads_health: {exc}")
    return {}


def _fetch_events(errors: list[str]) -> dict[str, Any]:
    try:
        events_payload = _get_json("/api/v1/events?limit=2000")
        return _summarize_events(events_payload)
    except Exception as exc:
        errors.append(f"events: {exc}")
    return {}

__all__ = [name for name in globals() if (name.startswith("_") and not name.startswith("__")) or name in {"ClusterStateSummary", "SignalContext"}]