package testing

import (
	"testing"
	"time"

	"b612.me/stardb"
	_ "modernc.org/sqlite"
)

func TestDefaultPoolConfig(t *testing.T) {
	config := stardb.DefaultPoolConfig()

	if config.MaxOpenConns != 25 {
		t.Errorf("Expected MaxOpenConns 25, got %d", config.MaxOpenConns)
	}

	if config.MaxIdleConns != 5 {
		t.Errorf("Expected MaxIdleConns 5, got %d", config.MaxIdleConns)
	}

	if config.ConnMaxLifetime != time.Hour {
		t.Errorf("Expected ConnMaxLifetime 1 hour, got %v", config.ConnMaxLifetime)
	}

	if config.ConnMaxIdleTime != 10*time.Minute {
		t.Errorf("Expected ConnMaxIdleTime 10 minutes, got %v", config.ConnMaxIdleTime)
	}
}

func TestStarDB_SetPoolConfig(t *testing.T) {
	db := stardb.NewStarDB()
	err := db.Open("sqlite", ":memory:")
	if err != nil {
		t.Fatalf("Failed to open database: %v", err)
	}
	defer db.Close()

	config := &stardb.PoolConfig{
		MaxOpenConns:    50,
		MaxIdleConns:    10,
		ConnMaxLifetime: 30 * time.Minute,
		ConnMaxIdleTime: 5 * time.Minute,
	}

	db.SetPoolConfig(config)

	stats := db.Stats()
	if stats.MaxOpenConnections != 50 {
		t.Errorf("Expected MaxOpenConnections 50, got %d", stats.MaxOpenConnections)
	}
}

func TestStarDB_SetPoolConfig_Partial(t *testing.T) {
	db := stardb.NewStarDB()
	err := db.Open("sqlite", ":memory:")
	if err != nil {
		t.Fatalf("Failed to open database: %v", err)
	}
	defer db.Close()

	// Only set MaxOpenConns
	config := &stardb.PoolConfig{
		MaxOpenConns: 100,
	}

	db.SetPoolConfig(config)

	stats := db.Stats()
	if stats.MaxOpenConnections != 100 {
		t.Errorf("Expected MaxOpenConnections 100, got %d", stats.MaxOpenConnections)
	}
}

func TestStarDB_SetPoolConfig_Zero(t *testing.T) {
	db := stardb.NewStarDB()
	err := db.Open("sqlite", ":memory:")
	if err != nil {
		t.Fatalf("Failed to open database: %v", err)
	}
	defer db.Close()

	// Zero values should be ignored
	config := &stardb.PoolConfig{
		MaxOpenConns: 0,
		MaxIdleConns: 0,
	}

	db.SetPoolConfig(config)

	// Should not panic or error
	err = db.Ping()
	if err != nil {
		t.Errorf("Ping failed after SetPoolConfig with zero values: %v", err)
	}
}

func TestOpenWithPool_Default(t *testing.T) {
	db, err := stardb.OpenWithPool("sqlite", ":memory:", nil)
	if err != nil {
		t.Fatalf("OpenWithPool failed: %v", err)
	}
	defer db.Close()

	err = db.Ping()
	if err != nil {
		t.Errorf("Ping failed: %v", err)
	}

	stats := db.Stats()
	if stats.MaxOpenConnections != 25 {
		t.Errorf("Expected default MaxOpenConnections 25, got %d", stats.MaxOpenConnections)
	}
}

func TestOpenWithPool_Custom(t *testing.T) {
	config := &stardb.PoolConfig{
		MaxOpenConns:    15,
		MaxIdleConns:    3,
		ConnMaxLifetime: 20 * time.Minute,
		ConnMaxIdleTime: 3 * time.Minute,
	}

	db, err := stardb.OpenWithPool("sqlite", ":memory:", config)
	if err != nil {
		t.Fatalf("OpenWithPool failed: %v", err)
	}
	defer db.Close()

	err = db.Ping()
	if err != nil {
		t.Errorf("Ping failed: %v", err)
	}

	stats := db.Stats()
	if stats.MaxOpenConnections != 15 {
		t.Errorf("Expected MaxOpenConnections 15, got %d", stats.MaxOpenConnections)
	}
}

func TestOpenWithPool_InvalidDriver(t *testing.T) {
	config := stardb.DefaultPoolConfig()

	db, err := stardb.OpenWithPool("invalid_driver", "invalid_conn", config)
	if err == nil {
		db.Close()
		t.Error("Expected error with invalid driver, got nil")
	}
}

func TestOpenWithPool_Query(t *testing.T) {
	db, err := stardb.OpenWithPool("sqlite", ":memory:", nil)
	if err != nil {
		t.Fatalf("OpenWithPool failed: %v", err)
	}
	defer db.Close()

	// Create table
	_, err = db.Exec(`CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)`)
	if err != nil {
		t.Fatalf("Failed to create table: %v", err)
	}

	// Insert data
	_, err = db.Exec(`INSERT INTO test (name) VALUES (?)`, "Alice")
	if err != nil {
		t.Fatalf("Failed to insert data: %v", err)
	}

	// Query data
	rows, err := db.Query("SELECT * FROM test")
	if err != nil {
		t.Fatalf("Query failed: %v", err)
	}
	defer rows.Close()

	if rows.Length() != 1 {
		t.Errorf("Expected 1 row, got %d", rows.Length())
	}
}

func TestPoolConfig_AllFields(t *testing.T) {
	db := stardb.NewStarDB()
	err := db.Open("sqlite", ":memory:")
	if err != nil {
		t.Fatalf("Failed to open database: %v", err)
	}
	defer db.Close()

	config := &stardb.PoolConfig{
		MaxOpenConns:    30,
		MaxIdleConns:    8,
		ConnMaxLifetime: 45 * time.Minute,
		ConnMaxIdleTime: 7 * time.Minute,
	}

	db.SetPoolConfig(config)

	// Verify by checking stats
	stats := db.Stats()
	if stats.MaxOpenConnections != 30 {
		t.Errorf("Expected MaxOpenConnections 30, got %d", stats.MaxOpenConnections)
	}

	// Test that connections work
	err = db.Ping()
	if err != nil {
		t.Errorf("Ping failed after SetPoolConfig: %v", err)
	}
}

func TestPoolConfig_NegativeValues(t *testing.T) {
	db := stardb.NewStarDB()
	err := db.Open("sqlite", ":memory:")
	if err != nil {
		t.Fatalf("Failed to open database: %v", err)
	}
	defer db.Close()

	// Negative values should be ignored
	config := &stardb.PoolConfig{
		MaxOpenConns: -1,
		MaxIdleConns: -1,
	}

	db.SetPoolConfig(config)

	// Should not panic or error
	err = db.Ping()
	if err != nil {
		t.Errorf("Ping failed after SetPoolConfig with negative values: %v", err)
	}
}

func TestOpenWithPool_MultipleConnections(t *testing.T) {
	config := &stardb.PoolConfig{
		MaxOpenConns: 5,
		MaxIdleConns: 2,
	}

	db, err := stardb.OpenWithPool("sqlite", ":memory:", config)
	if err != nil {
		t.Fatalf("OpenWithPool failed: %v", err)
	}
	defer db.Close()

	// Create table
	_, err = db.Exec(`CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)`)
	if err != nil {
		t.Fatalf("Failed to create table: %v", err)
	}

	// Perform multiple operations
	for i := 0; i < 10; i++ {
		_, err = db.Exec(`INSERT INTO test (value) VALUES (?)`, "test")
		if err != nil {
			t.Errorf("Insert %d failed: %v", i, err)
		}
	}

	// Verify
	rows, err := db.Query("SELECT COUNT(*) as count FROM test")
	if err != nil {
		t.Fatalf("Query failed: %v", err)
	}
	defer rows.Close()

	count := rows.Row(0).MustInt("count")
	if count != 10 {
		t.Errorf("Expected 10 rows, got %d", count)
	}
}