package norm

import (
	_ "github.com/mattn/go-sqlite3"
	"testing"
)

func TestDeleteCompileSuccess(t *testing.T) {
	tests := []struct {
		name         string
		stmt         Compiler
		expectedSql  string
		expectedArgs []any
	}{
		{
			name:        "Delete all users",
			stmt:        Delete().From("users"),
			expectedSql: "DELETE FROM users",
		},
		{
			name: "Delete active users only",
			stmt: Delete().
				From("users").
				Where(Eq("active", true)),
			expectedSql:  "DELETE FROM users WHERE (active) = (?)",
			expectedArgs: []any{true},
		},
		{
			name: "Delete users in Engineering",
			stmt: Delete().
				From("users").
				Where(Eq("department", "Engineering")),
			expectedSql:  "DELETE FROM users WHERE (department) = (?)",
			expectedArgs: []any{"Engineering"},
		},
		{
			name: "Delete users with age > 30",
			stmt: Delete().
				From("users").
				Where(Gt("age", 30)),
			expectedSql:  "DELETE FROM users WHERE (age) > (?)",
			expectedArgs: []any{30},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			sql, args := test.stmt.MustCompile()

			if sql != test.expectedSql {
				t.Errorf("Expected '%s', got '%s'", test.expectedSql, sql)
			}

			if len(args) != len(test.expectedArgs) {
				t.Errorf("Expected '%d' args, got '%d' args", len(test.expectedArgs), len(args))
			}

			for i := range len(args) {
				if args[i] != test.expectedArgs[i] {
					t.Errorf("Expected '%s', got '%s' at index %d", test.expectedArgs[i], args[i], i)
				}
			}
		})
	}
}

func TestDeleteCompileFail(t *testing.T) {
	tests := []struct {
		name          string
		stmt          Compiler
		expectedError string
	}{
		{
			name:          "No from clause",
			stmt:          Delete(),
			expectedError: "FROM clause is required",
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			sql, args, err := test.stmt.Compile()
			if err == nil {
				t.Error("Expected error, got nil")
			}

			if err.Error() != test.expectedError {
				t.Errorf("Expected error '%s', got '%s'", test.expectedError, err.Error())
			}

			if sql != "" {
				t.Errorf("Expected empty SQL on error, got '%s'", sql)
			}

			if args != nil {
				t.Errorf("Expected empty args on error, got '%q'", args)
			}
		})
	}
}

func TestDeleteIntegration(t *testing.T) {
	tests := []struct {
		name         string
		stmt         Execer
		expectedRows int64
	}{
		{
			name:         "Delete all users",
			stmt:         Delete().From("users"),
			expectedRows: 6,
		},
		{
			name: "Delete active users only",
			stmt: Delete().
				From("users").
				Where(Eq("active", true)),
			expectedRows: 4,
		},
		{
			name: "Select users in Engineering",
			stmt: Delete().
				From("users").
				Where(Eq("department", "Engineering")),
			expectedRows: 3,
		},
		{
			name: "Delete users with age > 30",
			stmt: Delete().
				From("users").
				Where(Gt("age", 30)),
			expectedRows: 2,
		},
		{
			name: "Delete users with salary between 70000 and 80000",
			stmt: Delete().
				From("users").
				Where(Gte("salary", 70000.0).And(Lte("salary", 80000.0))),
			expectedRows: 3,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			db := setupTestDB(t)
			defer db.Close()

			res, err := test.stmt.Exec(db)
			if err != nil {
				t.Fatalf("Failed to execute query: %v", err)
			}

			count, err := res.RowsAffected()
			if err != nil {
				t.Fatalf("Failed to execute query: %v", err)
			}

			if count != test.expectedRows {
				t.Errorf("Expected %d rows, got %d", test.expectedRows, count)
			}
		})
	}
}