package health

import (
	"context"
	"testing"
	"time"

	"git.dcentral.systems/toolz/goplt/internal/infra/database"
)

func TestNewDatabaseChecker(t *testing.T) {
	t.Parallel()

	dsn := "postgres://goplt:goplt_password@localhost:5432/goplt?sslmode=disable"
	if testing.Short() {
		t.Skip("Skipping database test in short mode")
	}

	cfg := database.Config{
		DSN:            dsn,
		MaxConnections: 10,
		MaxIdleConns:   5,
	}

	client, err := database.NewClient(cfg)
	if err != nil {
		t.Skipf("Skipping test - database not available: %v", err)
	}
	defer func() {
		if err := client.Close(); err != nil {
			t.Logf("Failed to close client: %v", err)
		}
	}()

	checker := NewDatabaseChecker(client)

	if checker == nil {
		t.Fatal("Expected checker, got nil")
	}

	// Verify it implements the interface (compile-time check)
	// If checker doesn't implement health.HealthChecker, this won't compile
	_ = checker
}

func TestDatabaseChecker_Check_Healthy(t *testing.T) {
	t.Parallel()

	dsn := "postgres://goplt:goplt_password@localhost:5432/goplt?sslmode=disable"
	if testing.Short() {
		t.Skip("Skipping database test in short mode")
	}

	cfg := database.Config{
		DSN:            dsn,
		MaxConnections: 10,
		MaxIdleConns:   5,
	}

	client, err := database.NewClient(cfg)
	if err != nil {
		t.Skipf("Skipping test - database not available: %v", err)
	}
	defer func() {
		if err := client.Close(); err != nil {
			t.Logf("Failed to close client: %v", err)
		}
	}()

	checker := NewDatabaseChecker(client)

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	if err := checker.Check(ctx); err != nil {
		t.Errorf("Expected healthy check, got error: %v", err)
	}
}

func TestDatabaseChecker_Check_Unhealthy(t *testing.T) {
	t.Parallel()

	// Create a client with invalid DSN to simulate unhealthy state
	cfg := database.Config{
		DSN:            "postgres://invalid:invalid@localhost:9999/invalid?sslmode=disable",
		MaxConnections: 10,
		MaxIdleConns:   5,
	}

	client, err := database.NewClient(cfg)
	if err == nil {
		// If connection succeeds, we can't test unhealthy state
		// So we'll just verify the checker is created
		defer func() {
			if err := client.Close(); err != nil {
				t.Logf("Failed to close client: %v", err)
			}
		}()
		t.Skip("Could not create unhealthy client for testing")
	}

	// For this test, we'll create a mock client that will fail on ping
	// Since we can't easily create an unhealthy client, we'll skip this test
	// if we can't create an invalid connection
	t.Skip("Skipping unhealthy test - requires invalid database connection")
}