package lang

import (
	"strings"
	"testing"
)

const accountRowSource = `
@table("accounts")
data class AccountRow(
    @id var id: String,
    var customerId: String,
    @column("kind") var accountType: String,
    var balance: Double
)
`

func TestParseSQLMetadata(t *testing.T) {
	program, err := Parse(accountRowSource)
	if err != nil {
		t.Fatalf("parse failed: %v", err)
	}
	if len(program.Classes) != 1 {
		t.Fatalf("expected one class, got %d", len(program.Classes))
	}
	class := program.Classes[0]
	if class.Table != "accounts" {
		t.Fatalf("table = %q, want accounts", class.Table)
	}
	if !class.Fields[0].ID {
		t.Fatal("id field is missing @id metadata")
	}
	if class.Fields[2].Column != "kind" {
		t.Fatalf("accountType column = %q, want kind", class.Fields[2].Column)
	}
	if got := sqlColumn(class.Fields[1]); got != "customer_id" {
		t.Fatalf("default customerId column = %q, want customer_id", got)
	}
}

func TestGenerateSQLSelect(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
fun accountQuery(customerId: String): GotlinSQLQuery {
    return sql.from<AccountRow>()
        .where { row -> row.customerId == customerId && row.balance > 0.0 }
        .orderBy { row -> row.accountType }
        .build()
}
`)
	for _, want := range []string{
		"type GotlinSQLQuery struct",
		"SQL  string",
		"Args []any",
		`SQL: "SELECT id, customer_id, kind, balance FROM accounts WHERE (customer_id = $1 AND balance > $2) ORDER BY kind"`,
		`Args: []any{customerId, 0.0}`,
	} {
		if !strings.Contains(code, want) {
			t.Fatalf("generated Go missing %q:\n%s", want, code)
		}
	}
	if strings.Contains(code, `github.com/jackc/pgx/v5`) {
		t.Fatalf("build-only SQL unexpectedly emitted pgx runtime:\n%s", code)
	}
}

func TestGenerateSQLSelectUsesTypedLocalAsArgument(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
fun accountQuery(): GotlinSQLQuery {
    val customerId = "customer-1"
    return sql.from<AccountRow>().where { it.customerId == customerId }.build()
}

`)
	if want := `Args: []any{customerId}`; !strings.Contains(code, want) {
		t.Fatalf("generated Go missing %q:\n%s", want, code)
	}
}

func TestGeneratedQueryCanBePassedToVariadicPGXCall(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
import pgxpool "github.com/jackc/pgx/v5/pgxpool"
fun execute(pool: *pgxpool.Pool, ctx: Context, customerId: String) {
    val query = sql.from<AccountRow>().where { it.customerId == customerId }.build()
    pool.query(ctx, query.sql, *query.args)
}
`)
	if want := `pool.Query(ctx, query.SQL, query.Args...)`; !strings.Contains(code, want) {
		t.Fatalf("generated Go missing %q:\n%s", want, code)
	}
}

func TestGenerateSQLFetchTerminal(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
import context
import pgxpool "github.com/jackc/pgx/v5/pgxpool"

fun accounts(pool: *pgxpool.Pool, ctx: context.Context, customerId: String): List<*AccountRow> {
    return sql.from<AccountRow>()
        .where { it.customerId == customerId }
        .fetch(pool, ctx).unwrap()
}
`)
	for _, want := range []string{
		`"github.com/jackc/pgx/v5"`,
		`func accounts(pool *pgxpool.Pool, ctx context.Context, customerId string) []*AccountRow`,
		`return gotlinResultUnwrap(gotlinSQLFetch[AccountRow](pool, ctx, GotlinSQLQuery{SQL: "SELECT id, customer_id, kind, balance FROM accounts WHERE customer_id = $1", Args: []any{customerId}}, gotlinSQLScanAccountRow))`,
		`defer rows.Close()`,
		`values = append(values, value)`,
		`err := row.Scan(&value.Id, &value.CustomerId, &value.AccountType, &value.Balance)`,
	} {
		if !strings.Contains(code, want) {
			t.Fatalf("generated Go missing %q:\n%s", want, code)
		}
	}
}

func TestGenerateSQLSingleInfersRowSelectors(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
import context
import pgxpool "github.com/jackc/pgx/v5/pgxpool"

fun balance(pool: *pgxpool.Pool, ctx: context.Context, id: String): Double {
    val account = sql.from<AccountRow>().where { it.id == id }.single(pool, ctx).unwrap()
    return account.balance
}
`)
	for _, want := range []string{
		`account := gotlinResultUnwrap(gotlinSQLSingle[AccountRow](pool, ctx, GotlinSQLQuery{SQL: "SELECT id, customer_id, kind, balance FROM accounts WHERE id = $1", Args: []any{id}}, gotlinSQLScanAccountRow))`,
		`return account.Balance`,
		`GotlinResult[*T]{Err: gotlinSQLError("SQL single() expected exactly one row, got zero")}`,
		`GotlinResult[*T]{Err: gotlinSQLError("SQL single() expected exactly one row, got more than one")}`,
	} {
		if !strings.Contains(code, want) {
			t.Fatalf("generated Go missing %q:\n%s", want, code)
		}
	}
}

func TestGenerateSQLIteratorTerminalAndTypedValue(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
import context
import pgxpool "github.com/jackc/pgx/v5/pgxpool"

fun printAccounts(pool: *pgxpool.Pool, ctx: context.Context) {
    val rows = sql.from<AccountRow>().iterator(pool, ctx).unwrap()
    defer rows.close()
    while (rows.next()) {
        val account = rows.value()
        println(account.customerId)
    }
    val checked = rows.err()
}
`)
	for _, want := range []string{
		`rows := gotlinResultUnwrap(gotlinSQLIterate[AccountRow](pool, ctx, GotlinSQLQuery{SQL: "SELECT id, customer_id, kind, balance FROM accounts", Args: []any{}}, gotlinSQLScanAccountRow))`,
		`defer rows.close()`,
		`for rows.next()`,
		`account := rows.value()`,
		`fmt.Println(account.CustomerId)`,
		`_ = rows.err()`,
		`type GotlinSQLIterator[T any] struct`,
		`func (iterator *GotlinSQLIterator[T]) next() bool`,
		`func (iterator *GotlinSQLIterator[T]) value() *T`,
		`func (iterator *GotlinSQLIterator[T]) close()`,
		`func (iterator *GotlinSQLIterator[T]) err() error`,
	} {
		if !strings.Contains(code, want) {
			t.Fatalf("generated Go missing %q:\n%s", want, code)
		}
	}
}

func TestGenerateSQLSelectInClassMethodUsesTypedParameter(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
class AccountQueries {
    fun byCustomer(customerId: String): GotlinSQLQuery {
        return sql.from<AccountRow>().where { it.customerId == customerId }.build()
    }
}
`)
	if want := `Args: []any{customerId}`; !strings.Contains(code, want) {
		t.Fatalf("generated Go missing %q:\n%s", want, code)
	}
}

func TestGenerateSQLInsertDoNothing(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
fun insertAccount(row: AccountRow): GotlinSQLQuery {
    return sql.insert<AccountRow>(row).onConflict { it.id }.doNothing().build()
}
`)
	for _, want := range []string{
		`SQL: "INSERT INTO accounts (id, customer_id, kind, balance) VALUES ($1, $2, $3, $4) ON CONFLICT (id) DO NOTHING"`,
		`Args: []any{row.Id, row.CustomerId, row.AccountType, row.Balance}`,
	} {
		if !strings.Contains(code, want) {
			t.Fatalf("generated Go missing %q:\n%s", want, code)
		}
	}
}

func TestGenerateSQLInsertDoUpdate(t *testing.T) {
	code := compileSQL(t, accountRowSource+`
fun upsertAccount(row: AccountRow): GotlinSQLQuery {
    return sql.insert<AccountRow>(row)
        .onConflict { it.id }
        .doUpdate { excluded -> set(AccountRow.balance, excluded.balance) }
        .build()
}
`)
	if want := `SQL: "INSERT INTO accounts (id, customer_id, kind, balance) VALUES ($1, $2, $3, $4) ON CONFLICT (id) DO UPDATE SET balance = EXCLUDED.balance"`; !strings.Contains(code, want) {
		t.Fatalf("generated Go missing %q:\n%s", want, code)
	}
}

func TestGenerateSQLCompositeConflictAndMultipleUpdates(t *testing.T) {
	code := compileSQL(t, `
@table("balances")
data class BalanceRow(@id var tenantId: String, @id var id: String, var amount: Double, var pending: Double)

fun upsert(row: BalanceRow): GotlinSQLQuery {
    return sql.insert<BalanceRow>(row)
        .onConflict { listOf(it.tenantId, it.id) }
        .doUpdate { excluded ->
            set(BalanceRow.amount, excluded.amount)
            set(BalanceRow.pending, excluded.pending)
        }
        .build()
}
`)
	if want := `ON CONFLICT (tenant_id, id) DO UPDATE SET amount = EXCLUDED.amount, pending = EXCLUDED.pending`; !strings.Contains(code, want) {
		t.Fatalf("generated Go missing %q:\n%s", want, code)
	}
}

func TestRejectInvalidSQLQueries(t *testing.T) {
	tests := []struct {
		name string
		src  string
		want string
	}{
		{
			name: "unknown row class",
			src:  `fun query(): GotlinSQLQuery { return sql.from<MissingRow>().build() }`,
			want: `SQL row class "MissingRow" does not exist`,
		},
		{
			name: "missing table metadata",
			src:  `data class Row(var id: String) fun query(): GotlinSQLQuery { return sql.from<Row>().build() }`,
			want: "requires @table",
		},
		{
			name: "unknown predicate field",
			src:  accountRowSource + `fun query(): GotlinSQLQuery { return sql.from<AccountRow>().where { it.missing == "x" }.build() }`,
			want: "has no field missing",
		},
		{
			name: "incompatible predicate operands",
			src:  accountRowSource + `fun query(customerId: String): GotlinSQLQuery { return sql.from<AccountRow>().where { it.balance == customerId }.build() }`,
			want: "incompatible types Double and String",
		},
		{
			name: "non numeric ordering predicate",
			src:  accountRowSource + `fun query(): GotlinSQLQuery { return sql.from<AccountRow>().where { it.customerId > "a" }.build() }`,
			want: "ordering comparison requires numeric operands",
		},
		{
			name: "unknown order field",
			src:  accountRowSource + `fun query(): GotlinSQLQuery { return sql.from<AccountRow>().orderBy { it.missing }.build() }`,
			want: "has no field missing",
		},
		{
			name: "conflict field must be id",
			src:  accountRowSource + `fun query(row: AccountRow): GotlinSQLQuery { return sql.insert<AccountRow>(row).onConflict { it.customerId }.doNothing().build() }`,
			want: "must be annotated @id",
		},
		{
			name: "unknown conflict field",
			src:  accountRowSource + `fun query(row: AccountRow): GotlinSQLQuery { return sql.insert<AccountRow>(row).onConflict { it.missing }.doNothing().build() }`,
			want: "has no field missing",
		},
		{
			name: "unknown update target",
			src:  accountRowSource + `fun query(row: AccountRow): GotlinSQLQuery { return sql.insert<AccountRow>(row).onConflict { it.id }.doUpdate { excluded -> set(AccountRow.missing, excluded.balance) }.build() }`,
			want: "has no field missing",
		},
		{
			name: "incompatible update fields",
			src:  accountRowSource + `fun query(row: AccountRow): GotlinSQLQuery { return sql.insert<AccountRow>(row).onConflict { it.id }.doUpdate { excluded -> set(AccountRow.balance, excluded.accountType) }.build() }`,
			want: "has type Double",
		},
		{
			name: "wrong insert row type",
			src: accountRowSource + `
@table("other") data class OtherRow(@id var id: String)
fun query(row: OtherRow): GotlinSQLQuery { return sql.insert<AccountRow>(row).onConflict { it.id }.doNothing().build() }
`,
			want: "cannot insert value of type OtherRow",
		},
		{
			name: "incomplete chain",
			src:  accountRowSource + `fun query(): GotlinSQLQuery { return sql.from<AccountRow>() }`,
			want: "must end with build()",
		},
		{
			name: "fetch missing arguments",
			src:  accountRowSource + `fun query(): List<*AccountRow> { return sql.from<AccountRow>().fetch().unwrap() }`,
			want: "fetch() expects exactly pool and ctx positional arguments",
		},
		{
			name: "single extra argument",
			src:  accountRowSource + `fun query(pool: Any, ctx: Any): *AccountRow { return sql.from<AccountRow>().single(pool, ctx, ctx).unwrap() }`,
			want: "single() expects exactly pool and ctx positional arguments",
		},
		{
			name: "iterator named arguments",
			src:  accountRowSource + `fun query(pool: Any, ctx: Any): GotlinSQLIterator<AccountRow> { return sql.from<AccountRow>().iterator(pool = pool, ctx = ctx).unwrap() }`,
			want: "iterator() expects exactly pool and ctx positional arguments",
		},
		{
			name: "fetch type arguments",
			src:  accountRowSource + `fun query(pool: Any, ctx: Any): List<*AccountRow> { return sql.from<AccountRow>().fetch<String>(pool, ctx) }`,
			want: "fetch() expects exactly pool and ctx positional arguments",
		},
		{
			name: "fetch invalid pool type",
			src:  accountRowSource + `fun query(pool: String, ctx: Any): List<*AccountRow> { return sql.from<AccountRow>().fetch(pool, ctx).unwrap() }`,
			want: "pool argument has non-query type String",
		},
		{
			name: "single invalid context type",
			src:  accountRowSource + `fun query(pool: Any, ctx: Int): *AccountRow { return sql.from<AccountRow>().single(pool, ctx).unwrap() }`,
			want: "ctx argument has non-context type Int",
		},
		{
			name: "insert execution terminal",
			src:  accountRowSource + `fun query(row: AccountRow, pool: Any, ctx: Any): List<*AccountRow> { return sql.insert<AccountRow>(row).fetch(pool, ctx).unwrap() }`,
			want: "fetch() is only supported for sql.from",
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			program, err := Parse(test.src)
			if err != nil {
				t.Fatalf("parse failed: %v", err)
			}
			_, err = GenerateGo(program)
			if err == nil || !strings.Contains(err.Error(), test.want) {
				t.Fatalf("error = %v, want substring %q", err, test.want)
			}
		})
	}
}

func TestRejectInvalidSQLAnnotations(t *testing.T) {
	for _, test := range []struct {
		src  string
		want string
	}{
		{`@table("accounts") class Row(var id: String)`, "table is only valid on data classes"},
		{`@table("bad-name") data class Row(var id: String)`, "invalid SQL table name"},
		{`data class Row(@column("bad-name") var id: String)`, "invalid SQL column name"},
	} {
		_, err := Parse(test.src)
		if err == nil || !strings.Contains(err.Error(), test.want) {
			t.Fatalf("Parse() error = %v, want substring %q", err, test.want)
		}
	}
}

func compileSQL(t *testing.T, src string) string {
	t.Helper()
	program, err := Parse(src)
	if err != nil {
		t.Fatalf("parse failed: %v", err)
	}
	out, err := GenerateGo(program)
	if err != nil {
		t.Fatalf("Go generation failed: %v", err)
	}
	return string(out)
}