#!/usr/bin/env python3

import json
import requests
import os
import tempfile
from icecream import ic
# Configuration du test
PLUGIN_URL = "http://localhost:8090/api/v1/getparams.execute"
AUTH_TOKEN = "my-plugin-token"  # Le même token que dans votre plugin

# Exemple de fichier .argocd.json
example_json = {
    "source": {
        "repoURL": "https://github.com/didlawowo/helm-portal",
        "targetRevision": "main",
        "path": "helm"
    },
    "project": "raspberry-apps",
    "destination": {
        "namespace": "helm-portal"
    },
    "syncPolicy": {
        "syncOptions": {
            "CreateNamespace": True
        }
    },
    "clusters": {
        "vcluster": {
            "enabled": False
        },
        "in-cluster": {
            "enabled": True,
            "valuesRevision": "main"
        }
    }
}

# Créer un fichier temporaire pour notre exemple
def setup_test_environment():
    print("🔧 Configuration de l'environnement de test...")
    temp_dir = tempfile.mkdtemp()
    app_dir = os.path.join(temp_dir, "deployed-charts", "helm-portal")
    os.makedirs(app_dir, exist_ok=True)
    
    # Écrire notre exemple JSON dans un fichier .argocd.json
    with open(os.path.join(app_dir, ".argocd.json"), "w") as f:
        json.dump(example_json, f, indent=2)
    
    print(f"📁 Fichier exemple créé dans {app_dir}/.argocd.json")
    return temp_dir

# Ce qu'Argo CD envoie au plugin
def simulate_argocd_request():
    print("\n🔄 Simulation de la requête d'Argo CD:")
    
    # Format de la requête envoyée par Argo CD
    request_data = {
        "applicationSetName": "discovery-all-clusters",
        "input": {
            "parameters": {
                "repoURL": "https://github.com/didlawowo/continuous-delivery.git",
                "path": "deployed-charts/**/.argocd.json",
                "revision": "main"
            }
        }
    }
    
    print(json.dumps(request_data, indent=2))
    return request_data

# Ce que le plugin est censé retourner à Argo CD
def expected_plugin_response(base_dir):
    print("\n✅ Réponse attendue du plugin:")
    
    # En se basant uniquement sur l'exemple JSON avec in-cluster activé
    expected_response = {
        "output": {
            "parameters": [
                {
                    "name": "in-cluster",
                    "path": {
                        "path": "deployed-charts/helm-portal",
                        "basename": "helm-portal"
                    },
                    "project": "raspberry-apps",
                    "destination": {
                        "name": "in-cluster",
                        "namespace": "helm-portal"
                    },
                    "source": {
                        "repoURL": "https://github.com/didlawowo/helm-portal",
                        "targetRevision": "main",
                        "path": "helm"
                    },
                    "syncPolicy": {
                        "syncOptions": {
                            "CreateNamespace": True
                        }
                    },
                    "valuesRevision": "main",
                    "clusters": {
                        "in-cluster": {
                            "enabled": True,
                            "valuesRevision": "main"
                        }
                    }
                }
                # Notez qu'il n'y a pas d'entrée pour "vcluster" car "enabled" est false
            ]
        }
    }
    
    print(json.dumps(expected_response, indent=2))
    return expected_response

# Test d'envoi réel au plugin (si disponible)
def test_real_plugin(request_data):
    print("\n🧪 Test d'envoi au plugin réel (optionnel):")
    
    try:
        response = requests.post(
            PLUGIN_URL,
            json=request_data,
            headers={"Authorization": f"Bearer {AUTH_TOKEN}"},
            timeout=5
        )
        ic(response)
        
        if response.status_code == 200:
            print("✅ Réponse reçue (200 OK)")
            print(json.dumps(response.json(), indent=2))
            return response.json()
        else:
            print(f"❌ Erreur: Le plugin a répondu avec le code {response.status_code}")
            print(response.text)
            return None
    except requests.exceptions.RequestException as e:
        print(f"❌ Erreur de connexion: {e}")
        print("ℹ️ Si le plugin n'est pas encore en cours d'exécution, c'est normal.")
        return None

# Validation de la réponse du plugin par rapport à la réponse attendue
def validate_response(actual, expected):
    print("\n🔍 Validation de la réponse:")
    
    if actual is None:
        print("⚠️ Impossible de valider: pas de réponse du plugin")
        return
    
    # Vérifier que la structure générale est correcte
    if "output" not in actual or "parameters" not in actual["output"]:
        print("❌ Structure incorrecte: 'output.parameters' manquant")
        return
    
    # Vérifier que seuls les clusters activés sont présents
    params = actual["output"]["parameters"]
    print(f"✅ Nombre de paramètres retournés: {len(params)}")
    
    # Vérifier que vcluster (désactivé) n'est pas présent
    has_vcluster = any(p.get("name") == "vcluster" for p in params)
    if has_vcluster:
        print("❌ Erreur: 'vcluster' (désactivé) est présent dans les paramètres")
    else:
        print("✅ Le cluster désactivé 'vcluster' n'est pas présent")
    
    # Vérifier que in-cluster (activé) est présent
    has_incluster = any(p.get("name") == "in-cluster" for p in params)
    if has_incluster:
        print("✅ Le cluster activé 'in-cluster' est présent")
    else:
        print("❌ Erreur: 'in-cluster' (activé) n'est pas présent dans les paramètres")
    
    print("\n✅ TEST TERMINÉ")

# Exécution du test
if __name__ == "__main__":
    base_dir = setup_test_environment()
    request_data = simulate_argocd_request()
    expected_response = expected_plugin_response(base_dir)
    
    # Test optionnel avec le plugin réel
    print("\nVoulez-vous tester avec le plugin réel? (O/N)")
    choice = input().strip().upper()
    
    if choice == "O":
        actual_response = test_real_plugin(request_data)
        validate_response(actual_response, expected_response)
    else:
        print("\nTest terminé sans appel au plugin réel.")