package testing

import (
	"context"
	"errors"
	"strings"
	"sync"
	"sync/atomic"
	"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_QueryRaw(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

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

	var (
		name  string
		count int
	)
	for rows.Next() {
		if err := rows.Scan(&name); err != nil {
			t.Fatalf("Scan failed: %v", err)
		}
		count++
	}
	if err := rows.Err(); err != nil {
		t.Fatalf("Rows.Err failed: %v", err)
	}
	if count != 2 {
		t.Errorf("Expected 2 rows, got %d", count)
	}
}

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

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

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

	if !rows.Next() {
		t.Fatal("Expected at least one row")
	}
	var name string
	if err := rows.Scan(&name); err != nil {
		t.Fatalf("Scan failed: %v", err)
	}
	if name != "Alice" {
		t.Errorf("Expected name Alice, got %s", name)
	}
}

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

	_, err := db.QueryRaw("   ")
	if !errors.Is(err, stardb.ErrQueryEmpty) {
		t.Fatalf("Expected ErrQueryEmpty, got %v", err)
	}
}

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

	var names []string
	err := db.ScanEach("SELECT name FROM users ORDER BY name", func(row *stardb.StarResult) error {
		names = append(names, row.MustString("name"))
		return nil
	})
	if err != nil {
		t.Fatalf("ScanEach failed: %v", err)
	}

	if len(names) != 3 {
		t.Fatalf("Expected 3 rows, got %d", len(names))
	}
	if names[0] != "Alice" || names[1] != "Bob" || names[2] != "Charlie" {
		t.Fatalf("Unexpected names: %v", names)
	}
}

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

	count := 0
	err := db.ScanEach("SELECT name FROM users ORDER BY name", func(row *stardb.StarResult) error {
		count++
		if row.MustString("name") == "Bob" {
			return stardb.ErrScanStopped
		}
		return nil
	})
	if err != nil {
		t.Fatalf("ScanEach stop failed: %v", err)
	}
	if count != 2 {
		t.Fatalf("Expected callback count 2, got %d", count)
	}
}

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

	err := db.ScanEach("SELECT name FROM users", nil)
	if !errors.Is(err, stardb.ErrScanFuncNil) {
		t.Fatalf("Expected ErrScanFuncNil, got %v", err)
	}
}

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

	var user User
	var names []string
	err := db.ScanEachORM("SELECT * FROM users ORDER BY name", &user, func(target interface{}) error {
		u := target.(*User)
		names = append(names, u.Name)
		return nil
	})
	if err != nil {
		t.Fatalf("ScanEachORM failed: %v", err)
	}

	if len(names) != 3 {
		t.Fatalf("Expected 3 names, got %d", len(names))
	}
	if names[0] != "Alice" || names[1] != "Bob" || names[2] != "Charlie" {
		t.Fatalf("Unexpected names: %v", names)
	}
}

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

	var user User
	err := db.ScanEachORM("SELECT * FROM users", &user, nil)
	if !errors.Is(err, stardb.ErrScanORMFuncNil) {
		t.Fatalf("Expected ErrScanORMFuncNil, got %v", err)
	}
}

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

	db.SetPlaceholderStyle(stardb.PlaceholderDollar)

	rows, err := db.Query("SELECT name FROM users WHERE name = ? AND age = ?", "Alice", 25)
	if err != nil {
		t.Fatalf("Query with dollar placeholders failed: %v", err)
	}
	defer rows.Close()

	if rows.Length() != 1 {
		t.Fatalf("Expected 1 row, got %d", rows.Length())
	}
	if got := rows.Row(0).MustString("name"); got != "Alice" {
		t.Fatalf("Expected Alice, got %s", got)
	}

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

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

	db.SetPlaceholderStyle(stardb.PlaceholderDollar)

	var beforeCount int64
	var afterCount int64
	var mu sync.Mutex
	var beforeQuery string
	var afterQuery string
	var afterErr error

	db.SetSQLHooks(
		func(ctx context.Context, query string, args []interface{}) {
			atomic.AddInt64(&beforeCount, 1)
			mu.Lock()
			beforeQuery = query
			mu.Unlock()
		},
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			atomic.AddInt64(&afterCount, 1)
			mu.Lock()
			afterQuery = query
			afterErr = err
			mu.Unlock()
		},
	)

	if _, err := db.Exec("UPDATE users SET age = ? WHERE name = ?", 31, "Bob"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	if atomic.LoadInt64(&beforeCount) == 0 {
		t.Fatal("Expected before hook to be called")
	}
	if atomic.LoadInt64(&afterCount) == 0 {
		t.Fatal("Expected after hook to be called")
	}
	if !strings.Contains(beforeQuery, "$1") {
		t.Fatalf("Expected converted query in before hook, got %s", beforeQuery)
	}
	if !strings.Contains(afterQuery, "$1") {
		t.Fatalf("Expected converted query in after hook, got %s", afterQuery)
	}
	if afterErr != nil {
		t.Fatalf("Expected nil error in after hook, got %v", afterErr)
	}

	_, execErr := db.Exec("UPDATE table_does_not_exist SET age = ? WHERE name = ?", 31, "Bob")
	if execErr == nil {
		t.Fatal("Expected execution error for invalid table")
	}
	if atomic.LoadInt64(&afterCount) < 2 {
		t.Fatalf("Expected after hook call count >= 2, got %d", atomic.LoadInt64(&afterCount))
	}
	if afterErr == nil {
		t.Fatal("Expected after hook to capture non-nil error for failed SQL")
	}
}

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

	var afterCount int64
	db.SetSQLHooks(
		nil,
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			atomic.AddInt64(&afterCount, 1)
		},
	)

	db.SetSQLSlowThreshold(time.Hour)
	if got := db.SQLSlowThreshold(); got != time.Hour {
		t.Fatalf("Expected threshold 1h, got %v", got)
	}

	if _, err := db.Exec("UPDATE users SET age = ? WHERE name = ?", 41, "Alice"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}
	if atomic.LoadInt64(&afterCount) != 0 {
		t.Fatalf("Expected after hook to be skipped under threshold, got %d", afterCount)
	}

	_, err := db.Exec("UPDATE table_does_not_exist SET age = ? WHERE name = ?", 31, "Bob")
	if err == nil {
		t.Fatal("Expected execution error for invalid table")
	}
	if atomic.LoadInt64(&afterCount) != 1 {
		t.Fatalf("Expected error path to trigger after hook, got %d", afterCount)
	}

	db.SetSQLSlowThreshold(0)
	if _, err := db.Exec("UPDATE users SET age = ? WHERE name = ?", 42, "Alice"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}
	if atomic.LoadInt64(&afterCount) != 2 {
		t.Fatalf("Expected after hook to run after disabling threshold, got %d", afterCount)
	}
}

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

	db.SetSQLFingerprintEnabled(true)

	var gotMeta stardb.SQLHookMeta
	var metaFound bool
	db.SetSQLHooks(
		nil,
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			gotMeta, metaFound = stardb.SQLHookMetaFromContext(ctx)
		},
	)

	if _, err := db.Exec("UPDATE   users   SET age = ? WHERE name = ?", 31, "Bob"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	if !metaFound {
		t.Fatal("Expected SQL fingerprint metadata in hook context")
	}
	if gotMeta.Fingerprint != "update users set age = ? where name = ?" {
		t.Fatalf("Unexpected fingerprint: %q", gotMeta.Fingerprint)
	}
}

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

	db.SetSQLFingerprintEnabled(true)
	db.SetSQLFingerprintMode(stardb.SQLFingerprintMaskLiterals)

	var gotMeta stardb.SQLHookMeta
	var metaFound bool
	db.SetSQLHooks(
		nil,
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			gotMeta, metaFound = stardb.SQLHookMetaFromContext(ctx)
		},
	)

	if _, err := db.Exec("UPDATE users SET age = 42 WHERE name = 'Bob' AND age < 100"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	if !metaFound {
		t.Fatal("Expected SQL fingerprint metadata in hook context")
	}
	if gotMeta.Fingerprint != "update users set age = ? where name = ? and age < ?" {
		t.Fatalf("Unexpected fingerprint for mask mode: %q", gotMeta.Fingerprint)
	}
}

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

	db.SetSQLFingerprintEnabled(true)
	db.SetSQLFingerprintMode(stardb.SQLFingerprintMaskLiterals)
	db.SetSQLFingerprintKeepComments(false) // default, explicit for clarity

	var gotMeta stardb.SQLHookMeta
	var metaFound bool
	db.SetSQLHooks(
		nil,
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			gotMeta, metaFound = stardb.SQLHookMetaFromContext(ctx)
		},
	)

	if _, err := db.Exec("UPDATE users SET age = 42 /* trace:abc */ WHERE name = 'Bob'"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	if !metaFound {
		t.Fatal("Expected SQL fingerprint metadata in hook context")
	}
	if gotMeta.Fingerprint != "update users set age = ? where name = ?" {
		t.Fatalf("Unexpected fingerprint with stripped comments: %q", gotMeta.Fingerprint)
	}
}

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

	db.SetSQLFingerprintEnabled(true)
	db.SetSQLFingerprintMode(stardb.SQLFingerprintMaskLiterals)
	db.SetSQLFingerprintKeepComments(true)

	var gotMeta stardb.SQLHookMeta
	var metaFound bool
	db.SetSQLHooks(
		nil,
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			gotMeta, metaFound = stardb.SQLHookMetaFromContext(ctx)
		},
	)

	if _, err := db.Exec("UPDATE users SET age = 42 /* trace:abc */ WHERE name = 'Bob'"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	if !metaFound {
		t.Fatal("Expected SQL fingerprint metadata in hook context")
	}
	if gotMeta.Fingerprint != "update users set age = ? /* trace:abc */ where name = ?" {
		t.Fatalf("Unexpected fingerprint with kept comments: %q", gotMeta.Fingerprint)
	}
}

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

	db.SetSQLFingerprintCounterEnabled(true)
	db.SetSQLFingerprintMode(stardb.SQLFingerprintMaskLiterals)
	db.SetSQLFingerprintKeepComments(false)

	if _, err := db.Exec("UPDATE users SET age = 41 WHERE name = 'Alice'"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}
	if _, err := db.Exec("UPDATE users SET age = 42 WHERE name = 'Bob'"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	counters := db.SQLFingerprintCounters()
	key := "update users set age = ? where name = ?"
	if counters[key] != 2 {
		t.Fatalf("Expected fingerprint %q count=2, got %d", key, counters[key])
	}

	db.ResetSQLFingerprintCounters()
	if got := len(db.SQLFingerprintCounters()); got != 0 {
		t.Fatalf("Expected counters to be reset, got %d", got)
	}
}

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

	db.SetSQLFingerprintCounterEnabled(false)
	if _, err := db.Exec("UPDATE users SET age = 31 WHERE name = ?", "Bob"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	if got := len(db.SQLFingerprintCounters()); got != 0 {
		t.Fatalf("Expected no counters when disabled, got %d", got)
	}
}

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

	db.SetSQLFingerprintEnabled(false)

	metaFound := false
	db.SetSQLHooks(
		nil,
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			_, metaFound = stardb.SQLHookMetaFromContext(ctx)
		},
	)

	if _, err := db.Exec("UPDATE users SET age = ? WHERE name = ?", 31, "Bob"); err != nil {
		t.Fatalf("Exec failed: %v", err)
	}
	if metaFound {
		t.Fatal("Expected no SQL fingerprint metadata when disabled")
	}
}

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 TestStarStmt_QueryRaw(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

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

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

	if !rows.Next() {
		t.Fatal("Expected one row for Bob")
	}
	var name string
	if err := rows.Scan(&name); err != nil {
		t.Fatalf("Scan failed: %v", err)
	}
	if name != "Bob" {
		t.Errorf("Expected Bob, got %s", name)
	}
}

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

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

	var names []string
	err = stmt.ScanEach(func(row *stardb.StarResult) error {
		names = append(names, row.MustString("name"))
		return nil
	}, 30)
	if err != nil {
		t.Fatalf("Stmt.ScanEach failed: %v", err)
	}
	if len(names) != 2 || names[0] != "Bob" || names[1] != "Charlie" {
		t.Fatalf("Unexpected names: %v", names)
	}
}

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

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

	var user User
	var names []string
	err = stmt.ScanEachORM(&user, func(target interface{}) error {
		u := target.(*User)
		names = append(names, u.Name)
		return nil
	}, 30)
	if err != nil {
		t.Fatalf("Stmt.ScanEachORM failed: %v", err)
	}
	if len(names) != 2 || names[0] != "Bob" || names[1] != "Charlie" {
		t.Fatalf("Unexpected names: %v", names)
	}
}

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

	var (
		beforeCount int64
		afterCount  int64
	)
	db.SetSQLHooks(
		func(ctx context.Context, query string, args []interface{}) {
			atomic.AddInt64(&beforeCount, 1)
		},
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			atomic.AddInt64(&afterCount, 1)
		},
	)

	stmt, err := db.Prepare("SELECT name 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.Fatalf("Expected 1 row, got %d", rows.Length())
	}
	if atomic.LoadInt64(&beforeCount) == 0 || atomic.LoadInt64(&afterCount) == 0 {
		t.Fatalf("Expected stmt execution to trigger hooks, before=%d after=%d", beforeCount, afterCount)
	}
}

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 TestStarTx_QueryRaw(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

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

	rows, err := tx.QueryRaw("SELECT name FROM users WHERE name = ?", "Charlie")
	if err != nil {
		t.Fatalf("Tx.QueryRaw failed: %v", err)
	}
	defer rows.Close()

	if !rows.Next() {
		t.Fatal("Expected one row for Charlie")
	}
	var name string
	if err := rows.Scan(&name); err != nil {
		t.Fatalf("Scan failed: %v", err)
	}
	if name != "Charlie" {
		t.Errorf("Expected Charlie, got %s", name)
	}
}

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

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

	var names []string
	err = tx.ScanEach("SELECT name FROM users WHERE age >= ? ORDER BY name", func(row *stardb.StarResult) error {
		names = append(names, row.MustString("name"))
		return nil
	}, 30)
	if err != nil {
		t.Fatalf("Tx.ScanEach failed: %v", err)
	}
	if len(names) != 2 || names[0] != "Bob" || names[1] != "Charlie" {
		t.Fatalf("Unexpected names: %v", names)
	}
}

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

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

	var user User
	var names []string
	err = tx.ScanEachORM("SELECT * FROM users WHERE age >= ? ORDER BY name", &user, func(target interface{}) error {
		u := target.(*User)
		names = append(names, u.Name)
		return nil
	}, 30)
	if err != nil {
		t.Fatalf("Tx.ScanEachORM failed: %v", err)
	}
	if len(names) != 2 || names[0] != "Bob" || names[1] != "Charlie" {
		t.Fatalf("Unexpected names: %v", names)
	}
}

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

	err := db.WithTx(func(tx *stardb.StarTx) error {
		_, err := tx.Exec("UPDATE users SET age = ? WHERE name = ?", 41, "Alice")
		return err
	})
	if err != nil {
		t.Fatalf("WithTx failed: %v", err)
	}

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

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

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

	expectedErr := errors.New("business error")
	err := db.WithTx(func(tx *stardb.StarTx) error {
		if _, err := tx.Exec("UPDATE users SET age = ? WHERE name = ?", 55, "Alice"); err != nil {
			return err
		}
		return expectedErr
	})
	if !errors.Is(err, expectedErr) {
		t.Fatalf("Expected %v, got %v", expectedErr, err)
	}

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

	if got := rows.Row(0).MustInt("age"); got == 55 {
		t.Fatalf("Expected rollback to keep original age, got %d", got)
	}
}

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)
	}
}

func TestStarDB_ConcurrentRuntimeAndQuery(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()
	db.SetMaxOpenConns(1)
	db.SetMaxIdleConns(1)

	db.SetSQLHooks(
		func(ctx context.Context, query string, args []interface{}) {},
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {},
	)

	var wg sync.WaitGroup

	for i := 0; i < 4; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 100; j++ {
				rows, err := db.Query("SELECT id FROM users WHERE name = ?", "Alice")
				if err != nil {
					t.Errorf("Concurrent query failed: %v", err)
					return
				}
				_ = rows.Close()
			}
		}()
	}

	for i := 0; i < 2; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 100; j++ {
				if j%2 == 0 {
					db.SetPlaceholderStyle(stardb.PlaceholderDollar)
					db.SetSQLSlowThreshold(time.Millisecond)
				} else {
					db.SetPlaceholderStyle(stardb.PlaceholderQuestion)
					db.SetSQLSlowThreshold(0)
				}
			}
		}()
	}

	wg.Wait()
}

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

	var beforeCount int64
	var afterCount int64
	db.SetSQLHooks(
		func(ctx context.Context, query string, args []interface{}) {
			atomic.AddInt64(&beforeCount, 1)
		},
		func(ctx context.Context, query string, args []interface{}, duration time.Duration, err error) {
			atomic.AddInt64(&afterCount, 1)
		},
	)

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

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

	if atomic.LoadInt64(&beforeCount) == 0 || atomic.LoadInt64(&afterCount) == 0 {
		t.Fatalf("Expected tx execution to trigger hooks, before=%d after=%d", beforeCount, afterCount)
	}
}