package testing

import (
	"context"
	"testing"
	"time"

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

func TestStarDB_Open(t *testing.T) {
	db := &stardb.StarDB{}
	err := db.Open("sqlite", ":memory:")
	if err != nil {
		t.Errorf("Open failed: %v", err)
	}
	defer db.Close()

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

func TestStarDB_Query(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	rows, err := db.Query("SELECT * FROM users WHERE age > ?", 25)
	if err != nil {
		t.Fatalf("Query failed: %v", err)
	}
	defer rows.Close()

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

	if len(rows.Columns()) != 7 {
		t.Errorf("Expected 7 columns, got %d", len(rows.Columns()))
	}
}

func TestStarDB_QueryContext(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

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

	rows, err := db.QueryContext(ctx, "SELECT * FROM users WHERE name = ?", "Alice")
	if err != nil {
		t.Fatalf("QueryContext failed: %v", err)
	}
	defer rows.Close()

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

func TestStarDB_Exec(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	result, err := db.Exec("UPDATE users SET age = ? WHERE name = ?", 26, "Alice")
	if err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	affected, err := result.RowsAffected()
	if err != nil {
		t.Fatalf("RowsAffected failed: %v", err)
	}

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

func TestStarDB_ExecContext(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	ctx := context.Background()
	result, err := db.ExecContext(ctx, "DELETE FROM users WHERE name = ?", "Charlie")
	if err != nil {
		t.Fatalf("ExecContext failed: %v", err)
	}

	affected, err := result.RowsAffected()
	if err != nil {
		t.Fatalf("RowsAffected failed: %v", err)
	}

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

func TestStarDB_QueryStmt(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	rows, err := db.QueryStmt("SELECT * FROM users WHERE age > ?", 25)
	if err != nil {
		t.Fatalf("QueryStmt failed: %v", err)
	}
	defer rows.Close()

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

func TestStarDB_ExecStmt(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	result, err := db.ExecStmt("UPDATE users SET age = ? WHERE name = ?", 27, "Bob")
	if err != nil {
		t.Fatalf("ExecStmt failed: %v", err)
	}

	affected, err := result.RowsAffected()
	if err != nil {
		t.Fatalf("RowsAffected failed: %v", err)
	}

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

func TestStarDB_Prepare(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	stmt, err := db.Prepare("SELECT * FROM users WHERE name = ?")
	if err != nil {
		t.Fatalf("Prepare failed: %v", err)
	}
	defer stmt.Close()

	rows, err := stmt.Query("Alice")
	if err != nil {
		t.Fatalf("Stmt.Query failed: %v", err)
	}
	defer rows.Close()

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

func TestStarDB_Transaction(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	tx, err := db.Begin()
	if err != nil {
		t.Fatalf("Begin failed: %v", err)
	}

	_, err = tx.Exec("UPDATE users SET age = ? WHERE name = ?", 28, "Alice")
	if err != nil {
		tx.Rollback()
		t.Fatalf("Tx.Exec failed: %v", err)
	}

	err = tx.Commit()
	if err != nil {
		t.Fatalf("Commit failed: %v", err)
	}

	// Verify the change
	rows, err := db.Query("SELECT age FROM users WHERE name = ?", "Alice")
	if err != nil {
		t.Fatalf("Query failed: %v", err)
	}
	defer rows.Close()

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

func TestStarDB_TransactionRollback(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	tx, err := db.Begin()
	if err != nil {
		t.Fatalf("Begin failed: %v", err)
	}

	_, err = tx.Exec("UPDATE users SET age = ? WHERE name = ?", 99, "Alice")
	if err != nil {
		t.Fatalf("Tx.Exec failed: %v", err)
	}

	err = tx.Rollback()
	if err != nil {
		t.Fatalf("Rollback failed: %v", err)
	}

	// Verify the change was rolled back
	rows, err := db.Query("SELECT age FROM users WHERE name = ?", "Alice")
	if err != nil {
		t.Fatalf("Query failed: %v", err)
	}
	defer rows.Close()

	age := rows.Row(0).MustInt("age")
	if age == 99 {
		t.Errorf("Expected age to be rolled back, but got %d", age)
	}
}

func TestStarDB_SetMaxConnections(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	db.SetMaxOpenConns(10)
	db.SetMaxIdleConns(5)

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