import json
from django.http import JsonResponse
from django.views.generic import TemplateView, View
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt

# Globaler In-Memory Speicher für die gepushten Cluster-States (simuliert eine DB)
# Struktur: { "repo_name": { ... d3_tree_data ... } }
CLUSTER_STATES = {}

class DashboardView(TemplateView):
    template_name = "monitor/dashboard.html"

@method_decorator(csrf_exempt, name='dispatch')
class StatePushReceiverView(View):
    """
    Der offizielle Enterprise-Endpunkt: Nimmt das anonymisierte 'terraform show -json'
    aus JEDER Pipeline der Welt per POST entgegen.
    """
    def post(self, request, *args, **kwargs):
        # Einfacher API-Token Check (Best Practice für dein Produkt)
        token = request.headers.get("Authorization")
        if token != "Bearer boday-cloudmon-super-token-2026":
            return JsonResponse({"error": "Unauthorized"}, status=401)

        try:
            # Das rohe Terraform-JSON einlesen
            tf_data = json.loads(request.body.decode('utf-8'))
            
            # Wir holen uns den Repo-Namen aus den Query-Parametern (?repo=boday_tf)
            repo_name = request.GET.get("repo", "default_cluster")

            # Parser für das standardisierte Terraform-JSON (Format von: terraform show -json)
            # In der JSON-Ausgabe liegen alle angelegten Ressourcen flach im 'values' Block
            values = tf_data.get("values", {}).get("root_module", {}).get("resources", [])
            
            ingresses = []
            services = {}
            deployments = {}

            for res in values:
                res_type = res.get("type")
                res_name = res.get("name")
                values_inner = res.get("values", {})

                if res_type == "kubernetes_ingress_v1":
                    ingresses.append({
                        "name": values_inner.get("metadata", [{}])[0].get("name", res_name) if isinstance(values_inner.get("metadata"), list) else values_inner.get("metadata", {}).get("name", res_name),
                        "rules": values_inner.get("spec", [{}])[0].get("rule", []) if isinstance(values_inner.get("spec"), list) else values_inner.get("spec", {}).get("rule", [])
                    })
                elif res_type in ["kubernetes_service", "kubernetes_service_v1"]:
                    svc_name = values_inner.get("metadata", [{}])[0].get("name", res_name) if isinstance(values_inner.get("metadata"), list) else values_inner.get("metadata", {}).get("name", res_name)
                    services[svc_name] = {"name": svc_name, "type": "Service"}
                elif res_type in ["kubernetes_deployment", "kubernetes_deployment_v1"]:
                    dep_name = values_inner.get("metadata", [{}])[0].get("name", res_name) if isinstance(values_inner.get("metadata"), list) else values_inner.get("metadata", {}).get("name", res_name)
                    deployments[dep_name] = {"name": dep_name, "type": "Deployment"}

            # D3.js Baumstruktur aufbauen
            root_node = {
                "name": f"Cluster: {repo_name}",
                "type": "Root",
                "children": []
            }

            for ing in ingresses:
                ing_node = {"name": ing["name"], "type": "Ingress", "children": []}
                for rule in ing["rules"]:
                    paths = rule.get("http", [{}])[0].get("path", []) if isinstance(rule.get("http"), list) else rule.get("http", {}).get("path", [])
                    for path in paths:
                        backend_svc = path.get("backend", [{}])[0].get("service", [{}])[0].get("name") if isinstance(path.get("backend"), list) else path.get("backend", {}).get("service", {}).get("name")
                        
                        if backend_svc in services:
                            svc_node = {"name": backend_svc, "type": "Service", "children": []}
                            for dep_name in deployments.keys():
                                if dep_name in backend_svc or backend_svc in dep_name:
                                    svc_node["children"].append({"name": dep_name, "type": "Deployment", "children": []})
                            ing_node["children"].append(svc_node)
                root_node["children"].append(ing_node)

            # Im globalen RAM-Speicher sichern
            CLUSTER_STATES[repo_name] = root_node
            return JsonResponse({"status": "success", "message": f"State für {repo_name} aktualisiert!"})

        except Exception as e:
            return JsonResponse({"error": str(e)}, status=400)


class ClusterGraphDataView(View):
    """ Liefert die Daten an das D3.js Frontend aus """
    def get(self, request, *args, **kwargs):
        repo_name = request.GET.get("repo", "boday_tf")
        # Holt die Daten aus dem Speicher, Fallback auf leeren Root-Knoten
        data = CLUSTER_STATES.get(repo_name, {
            "name": f"Warte auf ersten Push für '{repo_name}'...",
            "type": "Root",
            "children": []
        })
        return JsonResponse(data)