// vtest build: present_sqlite3? && !sanitize-memory-clang
// vtest vflags: -prod
// Tests for generic ORM with WHERE clause variable shadowing field names.
// This tests the fix for the bug where `select from T where status == status`
// (where `status` is both a field name and a local variable) was incorrectly
// optimized to `true` by the transformer, resulting in empty WHERE clauses.
import db.sqlite

pub enum TestStatus as u8 {
    pending
    active
    completed
}

pub struct GenericRecord[T] {
pub:
    id      int @[primary; sql: serial]
    status  TestStatus
    payload T @[sql: '-']
}

struct TestPayload {
    value int
}

// Test that WHERE clause works when variable name shadows field name
fn test_generic_where_variable_shadows_field() {
    mut db := sqlite.connect(':memory:') or { panic(err) }
    defer { db.close() or {} }

    sql db {
        create table GenericRecord[TestPayload]
    } or { panic(err) }

    // Insert records with different statuses
    r1 := GenericRecord[TestPayload]{
        status:  .pending
        payload: TestPayload{
            value: 1
        }
    }
    r2 := GenericRecord[TestPayload]{
        status:  .active
        payload: TestPayload{
            value: 2
        }
    }
    r3 := GenericRecord[TestPayload]{
        status:  .active
        payload: TestPayload{
            value: 3
        }
    }
    r4 := GenericRecord[TestPayload]{
        status:  .completed
        payload: TestPayload{
            value: 4
        }
    }

    sql db {
        insert r1 into GenericRecord[TestPayload]
        insert r2 into GenericRecord[TestPayload]
        insert r3 into GenericRecord[TestPayload]
        insert r4 into GenericRecord[TestPayload]
    } or { panic(err) }

    // Test: variable `status` shadows field `status`
    // Before the fix, this would return all rows or error because
    // `status == status` was optimized to `true`
    status := TestStatus.active
    results := sql db {
        select from GenericRecord[TestPayload] where status == status
    } or { panic(err) }

    assert results.len == 2, 'Expected 2 active records, got ${results.len}'

    // Test with different status values
    status2 := TestStatus.pending
    pending_results := sql db {
        select from GenericRecord[TestPayload] where status == status2
    } or { panic(err) }
    assert pending_results.len == 1, 'Expected 1 pending record, got ${pending_results.len}'

    status3 := TestStatus.completed
    completed_results := sql db {
        select from GenericRecord[TestPayload] where status == status3
    } or { panic(err) }
    assert completed_results.len == 1, 'Expected 1 completed record, got ${completed_results.len}'
}

// Test generic select helper function with shadowed variable
fn generic_select_by_status[T](db &sqlite.DB, status TestStatus) ![]GenericRecord[T] {
    return sql db {
        select from GenericRecord[T] where status == status
    }!
}

fn test_generic_function_where_shadow() {
    mut db := sqlite.connect(':memory:') or { panic(err) }
    defer { db.close() or {} }

    sql db {
        create table GenericRecord[TestPayload]
    } or { panic(err) }

    r1 := GenericRecord[TestPayload]{
        status:  .pending
        payload: TestPayload{
            value: 10
        }
    }
    r2 := GenericRecord[TestPayload]{
        status:  .active
        payload: TestPayload{
            value: 20
        }
    }

    sql db {
        insert r1 into GenericRecord[TestPayload]
        insert r2 into GenericRecord[TestPayload]
    } or { panic(err) }

    // Call generic function where parameter shadows field name
    active_records := generic_select_by_status[TestPayload](&db, .active) or { panic(err) }
    assert active_records.len == 1, 'Expected 1 active record from generic function'
    assert active_records[0].status == .active

    pending_records := generic_select_by_status[TestPayload](&db, .pending) or { panic(err) }
    assert pending_records.len == 1, 'Expected 1 pending record from generic function'
    assert pending_records[0].status == .pending
}

// Test count with shadowed variable
fn test_generic_count_where_shadow() {
    mut db := sqlite.connect(':memory:') or { panic(err) }
    defer { db.close() or {} }

    sql db {
        create table GenericRecord[TestPayload]
    } or { panic(err) }

    for i in 0 .. 5 {
        r := GenericRecord[TestPayload]{
            status:  if i < 3 { .active } else { .completed }
            payload: TestPayload{
                value: i
            }
        }
        sql db {
            insert r into GenericRecord[TestPayload]
        } or { panic(err) }
    }

    status := TestStatus.active
    count := sql db {
        select count from GenericRecord[TestPayload] where status == status
    } or { panic(err) }

    assert count == 3, 'Expected count 3, got ${count}'
}

// Test that table name doesn't include generic brackets
fn test_generic_table_name() {
    mut db := sqlite.connect(':memory:') or { panic(err) }
    defer { db.close() or {} }

    // This should create table named "GenericRecord", not "GenericRecord[TestPayload]"
    sql db {
        create table GenericRecord[TestPayload]
    } or { panic(err) }

    // Insert and select should work without SQL syntax errors
    r := GenericRecord[TestPayload]{
        status:  .pending
        payload: TestPayload{
            value: 42
        }
    }
    sql db {
        insert r into GenericRecord[TestPayload]
    } or { panic(err) }

    results := sql db {
        select from GenericRecord[TestPayload]
    } or { panic(err) }

    assert results.len == 1
}