package handlers

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap/zaptest"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

// TestHealthHandler_Readiness_DegradedMode vérifie que /readyz retourne "degraded" si Redis/RabbitMQ down
// MOD-P1-006: Test pour valider que /readyz tolère Redis/RabbitMQ down
func TestHealthHandler_Readiness_DegradedMode(t *testing.T) {
	// Créer une DB SQLite en mémoire pour le test
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	if err != nil {
		t.Skipf("SQLite not available: %v", err)
	}

	logger := zaptest.NewLogger(t)

	// Créer un handler avec Redis/RabbitMQ nil (simule services down)
	handler := NewHealthHandler(db, logger, nil, nil, "test")

	gin.SetMode(gin.TestMode)
	router := gin.New()
	router.GET("/readyz", handler.Readiness)

	req, _ := http.NewRequest("GET", "/readyz", nil)
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)

	// MOD-P1-006: /readyz doit retourner 200 OK même si Redis/RabbitMQ down (degraded)
	assert.Equal(t, http.StatusOK, w.Code)

	// Vérifier que la réponse contient "degraded" ou "ready"
	// Note: RespondSuccess wrap la réponse dans {"success": true, "data": {...}}
	var responseWrapper map[string]interface{}
	err = json.Unmarshal(w.Body.Bytes(), &responseWrapper)
	require.NoError(t, err)

	// Extraire la réponse data
	data, ok := responseWrapper["data"].(map[string]interface{})
	require.True(t, ok, "Response should have 'data' field")

	// MOD-P1-006: Status doit être "degraded" si Redis/RabbitMQ down, ou "ready" si DB OK
	// (Dans ce test, DB est OK mais Redis/RabbitMQ sont nil, donc devrait être "degraded")
	// Note: Le comportement exact dépend de l'implémentation de checkRedis/checkRabbitMQ
	// Si ces checks retournent "error" quand nil, alors status devrait être "degraded"
	status, ok := data["status"].(string)
	require.True(t, ok, "Response should have 'status' field")
	assert.Contains(t, []string{"ready", "degraded"}, status, "Status should be 'ready' or 'degraded'")

	// Vérifier que les checks sont présents
	checks, ok := data["checks"].(map[string]interface{})
	require.True(t, ok, "Response should have 'checks' field")
	assert.Contains(t, checks, "database", "Should have database check")
}

// TestHealthHandler_Readiness_DatabaseCritical vérifie que /readyz retourne "not_ready" si DB down
// MOD-P1-006: Test pour valider que DB est critique (not_ready si DB down)
func TestHealthHandler_Readiness_DatabaseCritical(t *testing.T) {
	// Créer une DB SQLite invalide (fermée) pour simuler DB down
	// Note: SQLite en mémoire ne peut pas vraiment simuler une DB down
	// Ce test vérifie juste que le handler gère correctement les erreurs DB

	logger := zaptest.NewLogger(t)

	// Créer un handler avec DB nil (simule DB down)
	handler := NewHealthHandler(nil, logger, nil, nil, "test")

	gin.SetMode(gin.TestMode)
	router := gin.New()
	router.GET("/readyz", handler.Readiness)

	req, _ := http.NewRequest("GET", "/readyz", nil)
	w := httptest.NewRecorder()
	router.ServeHTTP(w, req)

	// MOD-P1-006: /readyz doit retourner 503 Service Unavailable si DB down (not_ready)
	assert.Equal(t, http.StatusServiceUnavailable, w.Code)

	// Vérifier que la réponse contient "not_ready"
	// Note: Si DB down, le handler retourne directement c.JSON() sans RespondSuccess
	var response HealthResponse
	err := json.Unmarshal(w.Body.Bytes(), &response)
	require.NoError(t, err)

	assert.Equal(t, "not_ready", response.Status, "Status should be 'not_ready' if DB down")
}
