/*
 * Copyright (c) 2025 SimcuTeam. All rights reserved.
 * SimOrm 单元测试（cjpm test），全部为纯逻辑测试，不连接数据库。
 * 覆盖：模型映射与命名策略 / 模型校验（无主键、多主键、Option、不支持类型）/
 *       ChangeTracker 操作队列 / OpenGaussDialect SQL 生成 / DdlFactory DDL 生成 /
 *       MigrationBuilder 链式调用 / QueryBuilder SQL 构建（假 executor 捕获 SQL）。
 */

package simcu::orm.tests

import std.collection.*
import std.database.sql.*
import std.fs.*
import std.reflect.*
import std.unittest.*
import std.unittest.testmacro.*
import simcu::orm.*

// ---------- 测试实体 ----------

@Table["users"]
class User {
    public var id: Int64 = 0
    public var name: String = ""
    public var age: Int32 = 0
}

@Table["orders"]
class Order {
    @Key
    public var orderId: String = ""
    @Column["full_name"]
    public var name: String = ""
    @Ignore
    public var temp: String = ""
}

class Product {
    @Key
    @AutoIncrement
    public var pid: Int64 = 0
    @Required
    @MaxLength[100]
    public var title: String = ""
    public var price: Float64 = 0.0
    public var active: Bool = true
}

class NoKeyEntity {
    public var name: String = ""
}

@Table["plain_keys"]
class PlainIdEntity {
    public var id: String = ""
    public var name: String = ""
}

class MultiKeyEntity {
    @Key
    public var a: String = ""
    @Key
    public var b: String = ""
}

class OptionEntity {
    public var id: Int64 = 0
    public var nick: ?String = None
}

enum TestColor {
    | Red
    | Green
}

enum AssetKind {
    | Passport
    | Package
}

class UnsupportedEntity {
    public var id: Int64 = 0
    public var color: TestColor = TestColor.Red
}

class EnumEntity {
    public var id: Int64 = 0
    public var kind: AssetKind = AssetKind.Passport
    public var optKind: ?AssetKind = None
}

class UnsupportedArrayEntity {
    public var id: Int64 = 0
    public var tags: Array<Int32> = Array<Int32>()
}

// ---------- 模型映射 ----------

@Test
class ModelMappingTests {
    @TestCase
    public func testUserModel(): Unit {
        let model = ModelCache.get<User>()
        @Expect(model.tableName, "users")
        @Expect(model.properties.size, 3)
        let kp = model.keyProperty.getOrThrow()
        @Expect(kp.name, "id")
        @Expect(kp.columnName, "id")
        @Expect(kp.isKey, true)
        @Expect(kp.autoIncrement, true)
        @Expect(kp.clientGenerated, false)
        @Expect(model.properties[1].name, "name")
        @Expect(model.properties[1].columnName, "name")
        @Expect(model.properties[2].columnName, "age")
        @Expect(model.mapColumn("age"), "age")
        @Expect(model.mapColumn("unknown"), "unknown")
    }

    @TestCase
    public func testOrderModel(): Unit {
        let model = ModelCache.get<Order>()
        @Expect(model.tableName, "orders")
        // @Ignore 字段不映射
        @Expect(model.properties.size, 2)
        let kp = model.keyProperty.getOrThrow()
        @Expect(kp.name, "orderId")
        @Expect(kp.columnName, "orderId")
        @Expect(kp.isKey, true)
        // String 主键 → 客户端生成，不自增
        @Expect(kp.clientGenerated, true)
        @Expect(kp.autoIncrement, false)
        // @Column 覆盖列名
        @Expect(model.properties[1].name, "name")
        @Expect(model.properties[1].columnName, "full_name")
        @Expect(model.mapColumn("name"), "full_name")
    }

    @TestCase
    public func testProductModel(): Unit {
        let model = ModelCache.get<Product>()
        @Expect(model.properties.size, 4)
        let kp = model.keyProperty.getOrThrow()
        @Expect(kp.name, "pid")
        @Expect(kp.columnName, "pid")
        @Expect(kp.isKey, true)
        @Expect(kp.autoIncrement, true)
        // @Required / @MaxLength
        let title = model.properties[1]
        @Expect(title.name, "title")
        @Expect(title.isRequired, true)
        @Expect(title.maxLength, 100)
        @Expect(model.properties[2].columnName, "price")
        @Expect(model.properties[3].columnName, "active")
    }

    @TestCase
    public func testEntityInstance(): Unit {
        let model = ModelCache.get<User>()
        let u = User()
        u.name = "alice"
        let instance = model.createInstance()
        // createInstance 走无参构造，字段为默认值
        model.setValue(instance, model.properties[1], "bob")
        @Expect((model.getValue(instance, model.properties[1]) as String).getOrThrow(), "bob")
    }
}

// ---------- 模型校验（异常） ----------

@Test
class ModelValidationTests {
    @TestCase
    public func testNoKeyThrows(): Unit {
        let threw = try { ModelCache.get<NoKeyEntity>(); false } catch (_: Exception) { true }
        @Expect(threw, true)
    }

    @TestCase
    public func testPlainIdRecognizedAsKey(): Unit {
        let model = ModelCache.get<PlainIdEntity>()
        let kp = model.keyProperty.getOrThrow()
        @Expect(kp.name, "id")
        @Expect(kp.columnName, "id")
        @Expect(kp.isKey, true)
        @Expect(kp.clientGenerated, true)
    }

    @TestCase
    public func testMultiKeyThrows(): Unit {
        let threw = try { ModelCache.get<MultiKeyEntity>(); false } catch (_: Exception) { true }
        @Expect(threw, true)
    }

    @TestCase
    public func testOptionFieldMaps(): Unit {
        // Option 字段现在受支持：映射为可空列
        let model = ModelCache.get<OptionEntity>()
        @Expect(model.properties.size, 2)
        let nick = model.properties[1]
        @Expect(nick.name, "nick")
        @Expect(nick.columnName, "nick")
        @Expect(nick.typeName(), "Option<String>")
        @Expect(nick.isOption(), true)
        @Expect(nick.effectiveTypeName(), "String")
        @Expect(nick.isRequired, false)
    }

    @TestCase
    public func testEnumFieldMaps(): Unit {
        // 简单枚举（含 Option 内层枚举）受支持：标记 isEnum，记录完整类型名
        let model = ModelCache.get<EnumEntity>()
        @Expect(model.properties.size, 3)
        let kind = model.properties[1]
        @Expect(kind.name, "kind")
        @Expect(kind.isEnum, true)
        @Expect(kind.enumTypeName != "", true)
        @Expect(kind.typeName(), "AssetKind")
        let optKind = model.properties[2]
        @Expect(optKind.name, "optKind")
        @Expect(optKind.isOption(), true)
        @Expect(optKind.isEnum, true)
        @Expect(optKind.enumTypeName != "", true)
    }

    @TestCase
    public func testUnsupportedTypeThrows(): Unit {
        // Array<Int32> 不在白名单 → 抛异常
        let threw = try { ModelCache.get<UnsupportedArrayEntity>(); false } catch (_: Exception) { true }
        @Expect(threw, true)
    }

    @TestCase
    public func testEnumToParamValue(): Unit {
        // 枚举值 → 构造器名（写库值）
        @Expect((TypeUtil.enumToParamValue(TestColor.Red) as String).getOrThrow(), "Red")
        @Expect((TypeUtil.enumToParamValue(TestColor.Green) as String).getOrThrow(), "Green")
        // 非枚举值原样返回
        @Expect((TypeUtil.enumToParamValue("abc") as String).getOrThrow(), "abc")
        @Expect((TypeUtil.enumToParamValue(Int64(18)) as Int64).getOrThrow(), 18)
    }

    @TestCase
    public func testEnumFromNameRoundTrip(): Unit {
        // 完整类型名 + 构造器名 → 反射构造枚举实例（读库值），构造器名与写库一致
        let full = TypeInfo.of(TestColor.Green).toString()
        let v = ValueReader.enumFromName(full, "Green")
        let et = if (let e: EnumTypeInfo <- TypeInfo.of(v)) { e } else { throw Exception("不是枚举") }
        let (ctor, _) = et.destruct(v)
        @Expect(ctor.name, "Green")
        // 不存在的构造器 → 抛异常
        let threw = try { ValueReader.enumFromName(full, "Blue"); false } catch (_: Exception) { true }
        @Expect(threw, true)
        // 非枚举类型名 → 抛异常
        let threw2 = try { ValueReader.enumFromName("std.core.String", "x"); false } catch (_: Exception) { true }
        @Expect(threw2, true)
    }
}

// ---------- 命名策略 ----------

@Test
class NamingPolicyTests {
    @TestCase
    public func testApplyNamingPolicy(): Unit {
        @Expect(ModelCache.applyNamingPolicy("_userName", ColumnNamingPolicy.SnakeCase), "user_name")
        @Expect(ModelCache.applyNamingPolicy("_id", ColumnNamingPolicy.SnakeCase), "id")
        @Expect(ModelCache.applyNamingPolicy("_name", ColumnNamingPolicy.StripUnderscore), "name")
        @Expect(ModelCache.applyNamingPolicy("_id", ColumnNamingPolicy.StripUnderscore), "id")
        @Expect(ModelCache.applyNamingPolicy("_id", ColumnNamingPolicy.Keep), "_id")
        @Expect(ModelCache.applyNamingPolicy("userName", ColumnNamingPolicy.Keep), "userName")
        @Expect(ModelCache.applyNamingPolicy("__nickName", ColumnNamingPolicy.SnakeCase), "nick_name")
        @Expect(ModelCache.applyNamingPolicy("name2", ColumnNamingPolicy.SnakeCase), "name2")
    }
}

// ---------- ChangeTracker 操作队列 ----------

@Test
class ChangeTrackerTests {
    @TestCase
    public func testQueueOrder(): Unit {
        let tracker = ChangeTracker()
        let u1 = User()
        let u2 = User()
        tracker.add(u1, EntityState.Added)
        tracker.add(u2, EntityState.Modified)
        tracker.add(u1, EntityState.Deleted)
        @Expect(tracker.count(), 3)
        let entries = tracker.getEntries()
        let s0 = match (entries[0].state) { case EntityState.Added => true; case _ => false }
        let s1 = match (entries[1].state) { case EntityState.Modified => true; case _ => false }
        let s2 = match (entries[2].state) { case EntityState.Deleted => true; case _ => false }
        @Expect(s0, true)
        @Expect(s1, true)
        @Expect(s2, true)
        tracker.clear()
        @Expect(tracker.count(), 0)
    }
}

// ---------- OpenGaussDialect SQL 生成 ----------

@Test
class ISqlDialectTests {
    @TestCase
    public func testQuoteInsertUpdateDelete(): Unit {
        let d = OpenGaussDialect()
        @Expect(d.quoteName("users"), "\"users\"")
        let c = ArrayList<String>()
        c.add("id")
        c.add("name")
        @Expect(d.buildInsert("users", c, "id", true),
            "INSERT INTO \"users\" (\"id\", \"name\") VALUES (?, ?) RETURNING \"id\"")
        @Expect(d.buildInsert("users", c, "id", false),
            "INSERT INTO \"users\" (\"id\", \"name\") VALUES (?, ?)")
        @Expect(d.buildUpdate("users", c, "id"),
            "UPDATE \"users\" SET \"id\" = ?, \"name\" = ? WHERE \"id\" = ?")
        @Expect(d.buildDelete("users", "id"),
            "DELETE FROM \"users\" WHERE \"id\" = ?")
    }

    @TestCase
    public func testSelectAndCount(): Unit {
        let d = OpenGaussDialect()
        let c = ArrayList<String>()
        c.add("id")
        c.add("name")
        @Expect(d.buildSelect("users", c, "(\"age\" > ?)", "\"name\" ASC", 10, 5),
            "SELECT \"id\", \"name\" FROM \"users\" WHERE (\"age\" > ?) ORDER BY \"name\" ASC LIMIT 5 OFFSET 10")
        @Expect(d.buildSelect("users", c, "", "", 0, 0),
            "SELECT \"id\", \"name\" FROM \"users\"")
        let empty = ArrayList<String>()
        @Expect(d.buildSelect("users", empty, "", "", 0, 0),
            "SELECT * FROM \"users\"")
        @Expect(d.buildCount("users", ""),
            "SELECT COUNT(*) FROM \"users\"")
        @Expect(d.buildCount("users", "(\"age\" > ?)"),
            "SELECT COUNT(*) FROM \"users\" WHERE (\"age\" > ?)")
    }
}

// ---------- DdlFactory DDL 生成 ----------

@Test
class DdlFactoryTests {
    @TestCase
    public func testColumnTypeSql(): Unit {
        let d = OpenGaussDialect()
        @Expect(d.columnTypeSql(ColumnTypes.BigIntCol, true, 0), "BIGSERIAL")
        @Expect(d.columnTypeSql(ColumnTypes.BigIntCol, false, 0), "BIGINT")
        @Expect(d.columnTypeSql(ColumnTypes.IntCol, true, 0), "SERIAL")
        @Expect(d.columnTypeSql(ColumnTypes.IntCol, false, 0), "INTEGER")
        @Expect(d.columnTypeSql(ColumnTypes.SmallIntCol, false, 0), "SMALLINT")
        @Expect(d.columnTypeSql(ColumnTypes.TinyIntCol, false, 0), "SMALLINT")
        @Expect(d.columnTypeSql(ColumnTypes.TextCol, false, 100), "VARCHAR(100)")
        @Expect(d.columnTypeSql(ColumnTypes.TextCol, false, 0), "VARCHAR(255)")
        @Expect(d.columnTypeSql(ColumnTypes.BoolCol, false, 0), "BOOLEAN")
        @Expect(d.columnTypeSql(ColumnTypes.FloatCol, false, 0), "DOUBLE PRECISION")
        @Expect(d.columnTypeSql(ColumnTypes.RealCol, false, 0), "REAL")
        @Expect(d.columnTypeSql(ColumnTypes.DateTimeCol, false, 0), "TIMESTAMP")
        @Expect(d.columnTypeSql(ColumnTypes.DecimalCol, false, 0), "DECIMAL(18, 6)")
        @Expect(d.columnTypeSql(ColumnTypes.BinaryCol, false, 0), "BYTEA")
    }

    @TestCase
    public func testDropIndexAndAlterColumn(): Unit {
        let d = OpenGaussDialect()
        @Expect(d.buildDropIndex("ix_users_name", "users"), "DROP INDEX IF EXISTS \"ix_users_name\"")
        @Expect(d.buildAlterColumn("users", "\"name\" VARCHAR(128) NOT NULL"),
            "ALTER TABLE \"users\" ALTER COLUMN \"name\" VARCHAR(128) NOT NULL")
    }

    @TestCase
    public func testCreateTable(): Unit {
        let f = DdlFactory()
        let d = OpenGaussDialect()
        let op = MigrationOperation(MigrationOperationKind.CreateTable)
        op.tableName = "users"
        let id = ColumnDefinition("id", ColumnTypes.BigIntCol)
        id.primary()
        id.autoInc()
        id.notNull()
        let name = ColumnDefinition("name", ColumnTypes.TextCol)
        name.withMaxLength(100)
        name.notNull()
        let active = ColumnDefinition("active", ColumnTypes.BoolCol)
        active.withDefault(true)
        op.columnDefs.add(id)
        op.columnDefs.add(name)
        op.columnDefs.add(active)
        let sql = f.toSql(op, d)
        @Expect(sql.contains("CREATE TABLE IF NOT EXISTS \"users\""), true)
        @Expect(sql.contains("\"id\" BIGSERIAL NOT NULL PRIMARY KEY"), true)
        @Expect(sql.contains("\"name\" VARCHAR(100) NOT NULL"), true)
        @Expect(sql.contains("\"active\" BOOLEAN DEFAULT TRUE"), true)
    }

    @TestCase
    public func testAlterOperations(): Unit {
        let f = DdlFactory()
        let d = OpenGaussDialect()
        // ADD COLUMN
        let addOp = MigrationOperation(MigrationOperationKind.AddColumn)
        addOp.tableName = "users"
        let col = ColumnDefinition("email", ColumnTypes.TextCol)
        col.withDefault("unknown")
        addOp.column = Some(col)
        @Expect(f.toSql(addOp, d),
            "ALTER TABLE \"users\" ADD COLUMN \"email\" VARCHAR(255) DEFAULT 'unknown'")
        // DROP COLUMN
        let dropOp = MigrationOperation(MigrationOperationKind.DropColumn)
        dropOp.tableName = "users"
        dropOp.columnName = "email"
        @Expect(f.toSql(dropOp, d), "ALTER TABLE \"users\" DROP COLUMN \"email\"")
        // ALTER COLUMN
        let alterOp = MigrationOperation(MigrationOperationKind.AlterColumn)
        alterOp.tableName = "users"
        let nc = ColumnDefinition("name", ColumnTypes.TextCol)
        nc.withMaxLength(200)
        nc.notNull()
        alterOp.column = Some(nc)
        @Expect(f.toSql(alterOp, d),
            "ALTER TABLE \"users\" ALTER COLUMN \"name\" VARCHAR(200) NOT NULL")
        // RENAME COLUMN
        let renOp = MigrationOperation(MigrationOperationKind.RenameColumn)
        renOp.tableName = "users"
        renOp.columnName = "old_name"
        renOp.newColumnName = "new_name"
        @Expect(f.toSql(renOp, d),
            "ALTER TABLE \"users\" RENAME COLUMN \"old_name\" TO \"new_name\"")
    }

    @TestCase
    public func testTableAndIndexAndRaw(): Unit {
        let f = DdlFactory()
        let d = OpenGaussDialect()
        // DROP TABLE
        let dropOp = MigrationOperation(MigrationOperationKind.DropTable)
        dropOp.tableName = "users"
        @Expect(f.toSql(dropOp, d), "DROP TABLE IF EXISTS \"users\"")
        // CREATE INDEX（非唯一）
        let idxOp = MigrationOperation(MigrationOperationKind.CreateIndex)
        idxOp.indexName = "ix_users_name"
        idxOp.tableName = "users"
        idxOp.columnNames.add("name")
        @Expect(f.toSql(idxOp, d),
            "CREATE INDEX IF NOT EXISTS \"ix_users_name\" ON \"users\" (\"name\")")
        // CREATE UNIQUE INDEX
        idxOp.unique = true
        @Expect(f.toSql(idxOp, d),
            "CREATE UNIQUE INDEX IF NOT EXISTS \"ix_users_name\" ON \"users\" (\"name\")")
        // DROP INDEX
        let dropIdx = MigrationOperation(MigrationOperationKind.DropIndex)
        dropIdx.indexName = "ix_users_name"
        @Expect(f.toSql(dropIdx, d), "DROP INDEX IF EXISTS \"ix_users_name\"")
        // RAW SQL
        let rawOp = MigrationOperation(MigrationOperationKind.RawSql)
        rawOp.sql = "SELECT 1"
        @Expect(f.toSql(rawOp, d), "SELECT 1")
    }

    @TestCase
    public func testDefaultValueEscape(): Unit {
        let f = DdlFactory()
        let d = OpenGaussDialect()
        let op = MigrationOperation(MigrationOperationKind.AddColumn)
        op.tableName = "t"
        // 字符串默认值含单引号 → 转义
        let s = ColumnDefinition("remark", ColumnTypes.TextCol)
        s.withDefault("it's ok")
        op.column = Some(s)
        @Expect(f.toSql(op, d),
            "ALTER TABLE \"t\" ADD COLUMN \"remark\" VARCHAR(255) DEFAULT 'it''s ok'")
        // 数值默认值
        let op2 = MigrationOperation(MigrationOperationKind.AddColumn)
        op2.tableName = "t"
        let n = ColumnDefinition("cnt", ColumnTypes.IntCol)
        n.withDefault(Int64(18))
        op2.column = Some(n)
        @Expect(f.toSql(op2, d),
            "ALTER TABLE \"t\" ADD COLUMN \"cnt\" INTEGER DEFAULT 18")
        // 布尔默认值
        let op3 = MigrationOperation(MigrationOperationKind.AddColumn)
        op3.tableName = "t"
        let b = ColumnDefinition("flag", ColumnTypes.BoolCol)
        b.withDefault(false)
        op3.column = Some(b)
        @Expect(f.toSql(op3, d),
            "ALTER TABLE \"t\" ADD COLUMN \"flag\" BOOLEAN DEFAULT FALSE")
    }

    @TestCase
    public func testResolveColumnSqls(): Unit {
        let f = DdlFactory()
        let d = OpenGaussDialect()
        // 库中无同名列 → 直接 ADD
        let addOp = MigrationOperation(MigrationOperationKind.AddColumn)
        addOp.tableName = "users"
        let col = ColumnDefinition("email", ColumnTypes.TextCol)
        addOp.column = Some(col)
        let sqls1 = f.resolveColumnSqls(addOp, d, None)
        @Expect(sqls1.size, 1)
        @Expect(sqls1[0], "ALTER TABLE \"users\" ADD COLUMN \"email\" VARCHAR(255)")
        // 有同名列且类型一致 → 幂等跳过（0 条）
        let sqls2 = f.resolveColumnSqls(addOp, d, Some("character varying"))
        @Expect(sqls2.size, 0)
        // 有同名列但类型不同 → 先删后加（2 条）
        let sqls3 = f.resolveColumnSqls(addOp, d, Some("bigint"))
        @Expect(sqls3.size, 2)
        @Expect(sqls3[0], "ALTER TABLE \"users\" DROP COLUMN \"email\"")
        @Expect(sqls3[1], "ALTER TABLE \"users\" ADD COLUMN \"email\" VARCHAR(255)")
        // DateTime 列:库中为 BIGINT → 先删后加;库中已是 timestamp → 跳过
        let tsOp = MigrationOperation(MigrationOperationKind.AddColumn)
        tsOp.tableName = "t"
        let ts = ColumnDefinition("created_at", ColumnTypes.DateTimeCol)
        tsOp.column = Some(ts)
        let sqls4 = f.resolveColumnSqls(tsOp, d, Some("bigint"))
        @Expect(sqls4.size, 2)
        @Expect(sqls4[0], "ALTER TABLE \"t\" DROP COLUMN \"created_at\"")
        let sqls5 = f.resolveColumnSqls(tsOp, d, Some("timestamp without time zone"))
        @Expect(sqls5.size, 0)
        // 类型归一化:大小写/长度精度不影响比较
        @Expect(DdlFactory.normalizeTypeName("VARCHAR(100)"), "varchar")
        @Expect(DdlFactory.normalizeTypeName("BigInt"), "bigint")
        @Expect(DdlFactory.normalizeTypeName("timestamp without time zone"), "timestamp")
        @Expect(DdlFactory.normalizeTypeName("DECIMAL(18, 6)"), "decimal")
    }
}

// ---------- MigrationBuilder 链式调用 ----------

@Test
class MigrationBuilderTests {
    @TestCase
    public func testChainedCalls(): Unit {
        // 链式调用 API 面验证：整条链执行不抛异常（内部 operations 由 DdlFactory/Migrator 消费）
        let ok = try {
            let b = MigrationBuilder()
            b.createTable("t1") { tb =>
                tb.column("id", ColumnTypes.BigIntCol).primary().autoInc().notNull()
                tb.column("name", ColumnTypes.TextCol).withMaxLength(64).withDefault("none")
            }
            let idxCols = ArrayList<String>()
            idxCols.add("name")
            b.createIndex("ix_t1_name", "t1", idxCols)
            b.addColumn("t1", ColumnDefinition("age", ColumnTypes.IntCol).withDefault(Int64(0)))
            b.dropColumn("t1", "age")
            b.alterColumn("t1", ColumnDefinition("name", ColumnTypes.TextCol).withMaxLength(128))
            b.renameColumn("t1", "name", "nick")
            b.dropIndex("ix_t1_name", "t1")
            b.dropTable("t1")
            b.rawSql("VACUUM")
            true
        } catch (_: Exception) {
            false
        }
        @Expect(ok, true)
    }
}

// ---------- QueryBuilder（假 executor 捕获 SQL） ----------

@Test
class QueryBuilderTests {
    @TestCase
    public func testFilterAndSelect(): Unit {
        let model = ModelCache.get<User>()
        let dialect = OpenGaussDialect()
        let captured = ArrayList<String>()
        let paramsCaptured = ArrayList<ArrayList<Any>>()
        let qb = QueryBuilder<User>(model, dialect,
            { sql, params => captured.add(sql); paramsCaptured.add(params); ArrayList<User>() },
            { sql, params => 42 })
        qb.filter("age", ">", Int64(18))
        qb.filter("name", "=", "alice")
        let list = qb.toList()
        @Expect(list.size, 0)
        @Expect(captured.size, 1)
        @Expect(captured[0],
            "SELECT \"id\", \"name\", \"age\" FROM \"users\" WHERE (\"age\" > ?) AND (\"name\" = ?)")
        @Expect(paramsCaptured[0].size, 2)
        let p0 = (paramsCaptured[0][0] as Int64).getOrThrow()
        @Expect(p0, 18)
        let p1 = (paramsCaptured[0][1] as String).getOrThrow()
        @Expect(p1, "alice")
    }

    @TestCase
    public func testRawFilter(): Unit {
        let model = ModelCache.get<User>()
        let dialect = OpenGaussDialect()
        let captured = ArrayList<String>()
        let qb = QueryBuilder<User>(model, dialect,
            { sql, params => captured.add(sql); ArrayList<User>() },
            { sql, params => 42 })
        let ps = ArrayList<Any>()
        ps.add(Int64(18))
        ps.add(true)
        qb.filter("age > ? AND active = ?", ps)
        qb.toList()
        @Expect(captured[0],
            "SELECT \"id\", \"name\", \"age\" FROM \"users\" WHERE (age > ? AND active = ?)")
    }

    @TestCase
    public func testOrderPaging(): Unit {
        let model = ModelCache.get<User>()
        let dialect = OpenGaussDialect()
        let captured = ArrayList<String>()
        let qb = QueryBuilder<User>(model, dialect,
            { sql, params => captured.add(sql); ArrayList<User>() },
            { sql, params => 42 })
        qb.filter("age", ">", Int64(18))
        qb.orderBy("name")
        qb.orderByDesc("age")
        qb.skip(10)
        qb.take(5)
        qb.toList()
        @Expect(captured[0],
            "SELECT \"id\", \"name\", \"age\" FROM \"users\" WHERE (\"age\" > ?) ORDER BY \"name\" ASC, \"age\" DESC LIMIT 5 OFFSET 10")
    }

    @TestCase
    public func testCount(): Unit {
        let model = ModelCache.get<User>()
        let dialect = OpenGaussDialect()
        let captured = ArrayList<String>()
        let qb = QueryBuilder<User>(model, dialect,
            { sql, params => captured.add(sql); ArrayList<User>() },
            { sql, params => captured.add(sql); 42 })
        qb.filter("age", ">", Int64(18))
        let n = qb.count()
        @Expect(n, 42)
        @Expect(captured.size, 1)
        @Expect(captured[0], "SELECT COUNT(*) FROM \"users\" WHERE (\"age\" > ?)")
    }

    @TestCase
    public func testFirstAndPage(): Unit {
        let model = ModelCache.get<User>()
        let dialect = OpenGaussDialect()
        let captured = ArrayList<String>()
        let qb = QueryBuilder<User>(model, dialect,
            { sql, params => captured.add(sql); ArrayList<User>() },
            { sql, params => captured.add(sql); 42 })
        // first() 空结果 → None
        let first = qb.filter("age", ">", Int64(18)).first()
        @Expect(first.isNone(), true)
        @Expect(captured[0].contains("LIMIT 1"), true)
        // page(2, 10)：先 count 后 select，totalPages
        let result = qb.filter("age", ">", Int64(18)).page(2, 10)
        @Expect(result.total, 42)
        @Expect(result.page, 2)
        @Expect(result.pageSize, 10)
        @Expect(result.totalPages(), 5)
        @Expect(result.items.size, 0)
        @Expect(captured[1].startsWith("SELECT COUNT(*)"), true)
        @Expect(captured[2].contains("LIMIT 10 OFFSET 10"), true)
    }
}

// ---------- 模型生成迁移（MigrationGenerator） ----------

@Table["users"]
class UserV1 {
    public var id: Int64 = 0
    public var name: String = ""
}

@Table["users"]
class UserV2 {
    public var id: Int64 = 0
    public var name: String = ""
    public var age: Int32 = 0
}

@Table["items"]
class ItemV1 {
    public var id: Int64 = 0
    public var title: String = ""
}

@Table["items"]
class ItemV2 {
    public var id: Int64 = 0
    @MaxLength[100]
    public var title: String = ""
}

@Table["extra"]
class ExtraTable {
    public var id: Int64 = 0
}

@Table["keys"]
class KeyV1 {
    public var id: Int64 = 0
}

@Table["keys"]
class KeyV2 {
    @Key
    public var code: String = ""
}

@Test
class MigrationGeneratorTests {
    private func gen(): MigrationGenerator {
        MigrationGenerator()
    }

    private func upSql(m: Migration, dialect: ISqlDialect): ArrayList<String> {
        let builder = MigrationBuilder()
        m.up(builder)
        let f = DdlFactory()
        let sqls = ArrayList<String>()
        for (op in builder.getOperations()) {
            sqls.add(f.toSql(op, dialect))
        }
        sqls
    }

    private func downSql(m: Migration, dialect: ISqlDialect): ArrayList<String> {
        let builder = MigrationBuilder()
        m.down(builder)
        let f = DdlFactory()
        let sqls = ArrayList<String>()
        for (op in builder.getOperations()) {
            sqls.add(f.toSql(op, dialect))
        }
        sqls
    }

    @TestCase
    public func testInitialMigration(): Unit {
        let models = ArrayList<EntityModel>()
        models.add(ModelCache.get<User>())
        models.add(ModelCache.get<Product>())
        let m = gen().initial("20250701000000_InitialCreate", "初始建表", models)
        let d = OpenGaussDialect()
        let up = upSql(m, d)
        @Expect(up.size, 2)
        @Expect(up[0], "CREATE TABLE IF NOT EXISTS \"users\" (\n" +
            "  \"id\" BIGSERIAL NOT NULL PRIMARY KEY,\n" +
            "  \"name\" VARCHAR(255),\n" +
            "  \"age\" INTEGER\n)")
        @Expect(up[1], "CREATE TABLE IF NOT EXISTS \"Product\" (\n" +
            "  \"pid\" BIGSERIAL NOT NULL PRIMARY KEY,\n" +
            "  \"title\" VARCHAR(100) NOT NULL,\n" +
            "  \"price\" DOUBLE PRECISION,\n" +
            "  \"active\" BOOLEAN\n)")
        // down 为 up 逆序反转
        let down = downSql(m, d)
        @Expect(down.size, 2)
        @Expect(down[0], "DROP TABLE IF EXISTS \"Product\"")
        @Expect(down[1], "DROP TABLE IF EXISTS \"users\"")
    }

    @TestCase
    public func testDiffAddColumnAndDropTable(): Unit {
        let oldModels = ArrayList<EntityModel>()
        oldModels.add(ModelCache.get<UserV1>())
        oldModels.add(ModelCache.get<ExtraTable>())
        let newModels = ArrayList<EntityModel>()
        newModels.add(ModelCache.get<UserV2>())
        let m = gen().diff("20250801000000_AddAge", "新增 age 列并删表", oldModels, newModels)
        let d = OpenGaussDialect()
        let up = upSql(m, d)
        @Expect(up.size, 2)
        // 已有表加列
        @Expect(up[0], "ALTER TABLE \"users\" ADD COLUMN \"age\" INTEGER")
        // 删除表
        @Expect(up[1], "DROP TABLE IF EXISTS \"extra\"")
        // down 逆序反转：先恢复表，再删列
        let down = downSql(m, d)
        @Expect(down.size, 2)
        @Expect(down[0], "CREATE TABLE IF NOT EXISTS \"extra\" (\n  \"id\" BIGSERIAL NOT NULL PRIMARY KEY\n)")
        @Expect(down[1], "ALTER TABLE \"users\" DROP COLUMN \"age\"")
    }

    @TestCase
    public func testDiffAlterColumn(): Unit {
        let oldModels = ArrayList<EntityModel>()
        oldModels.add(ModelCache.get<ItemV1>())
        let newModels = ArrayList<EntityModel>()
        newModels.add(ModelCache.get<ItemV2>())
        let m = gen().diff("20250802000000_ChangeTitle", "调整 title 长度", oldModels, newModels)
        let d = OpenGaussDialect()
        let up = upSql(m, d)
        @Expect(up.size, 1)
        @Expect(up[0], "ALTER TABLE \"items\" ALTER COLUMN \"title\" VARCHAR(100)")
        let down = downSql(m, d)
        @Expect(down.size, 1)
        @Expect(down[0], "ALTER TABLE \"items\" ALTER COLUMN \"title\" VARCHAR(255)")
    }

    @TestCase
    public func testDiffKeyChangeThrows(): Unit {
        let oldModels = ArrayList<EntityModel>()
        oldModels.add(ModelCache.get<KeyV1>())
        let newModels = ArrayList<EntityModel>()
        newModels.add(ModelCache.get<KeyV2>())
        let threw = try {
            gen().diff("20250803000000_KeyChange", "改主键", oldModels, newModels)
            false
        } catch (_: Exception) {
            true
        }
        @Expect(threw, true)
    }

    @TestCase
    public func testColumnTypeMapping(): Unit {
        @Expect(match (MigrationGenerator.columnTypeFor("String")) { case ColumnTypes.TextCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Bool")) { case ColumnTypes.BoolCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Int8")) { case ColumnTypes.TinyIntCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Int32")) { case ColumnTypes.IntCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Int64")) { case ColumnTypes.BigIntCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Float32")) { case ColumnTypes.RealCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Float64")) { case ColumnTypes.FloatCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("DateTime")) { case ColumnTypes.DateTimeCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Decimal")) { case ColumnTypes.DecimalCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Array<Byte>")) { case ColumnTypes.BinaryCol => true; case _ => false }, true)
        // Option<X> 按内层类型映射
        @Expect(match (MigrationGenerator.columnTypeFor("Option<String>")) { case ColumnTypes.TextCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Option<Int64>")) { case ColumnTypes.BigIntCol => true; case _ => false }, true)
        @Expect(match (MigrationGenerator.columnTypeFor("Option<DateTime>")) { case ColumnTypes.DateTimeCol => true; case _ => false }, true)
        let threw = try {
            MigrationGenerator.columnTypeFor("Unknown")
            false
        } catch (_: Exception) {
            true
        }
        @Expect(threw, true)
    }

    @TestCase
    public func testOptionColumnDdl(): Unit {
        let models = ArrayList<EntityModel>()
        models.add(ModelCache.get<OptionEntity>())
        let m = gen().initial("20250910000000_OptionTable", "Option 字段建表", models)
        let d = OpenGaussDialect()
        let up = upSql(m, d)
        @Expect(up.size, 1)
        // 主键列 NOT NULL；Option 列 nullable（无 NOT NULL）
        @Expect(up[0].contains("\"id\" BIGSERIAL NOT NULL PRIMARY KEY"), true)
        @Expect(up[0].contains("\"nick\" VARCHAR(255)"), true)
        @Expect(up[0].contains("\"nick\" VARCHAR(255) NOT NULL"), false)
    }

    @TestCase
    public func testEnumColumnDdl(): Unit {
        // 枚举列按构造器名存 VARCHAR；Option<枚举> 列 nullable
        let models = ArrayList<EntityModel>()
        models.add(ModelCache.get<EnumEntity>())
        let m = gen().initial("20250911000000_EnumTable", "枚举字段建表", models)
        let d = OpenGaussDialect()
        let up = upSql(m, d)
        @Expect(up.size, 1)
        @Expect(up[0].contains("\"kind\" VARCHAR(255)"), true)
        @Expect(up[0].contains("\"optKind\" VARCHAR(255)"), true)
        @Expect(up[0].contains("\"optKind\" VARCHAR(255) NOT NULL"), false)
    }

    @TestCase
    public func testEnumSnapshotRoundTrip(): Unit {
        // 快照保留 isEnum 标记：diff 时枚举列能正确识别为 TextCol
        let ms = ArrayList<EntityModel>()
        ms.add(ModelCache.get<EnumEntity>())
        let snap = ModelSnapshot.capture(ms)
        let json = snap.toJson()
        @Expect(json.contains("\"enum\":true"), true)
        let back = ModelSnapshot.fromJson(json)
        @Expect(back.models[0].properties[1].isEnum, true)
        // 轻量模型 + 反射模型 diff：无变化 → 空操作
        let m = gen().diff("20250912000000_NoChange", "无变化", back.toModels(), ms)
        @Expect(upSql(m, OpenGaussDialect()).size, 0)
    }

    @TestCase
    public func testStringToEnumNoAlter(): Unit {
        // String 字段改为枚举：DB 层都是 VARCHAR → 无需 alter
        let oldModels = ArrayList<EntityModel>()
        oldModels.add(ModelCache.get<User>())
        let curModels = ArrayList<EntityModel>()
        curModels.add(ModelCache.get<EnumEntity>())
        let m = gen().diff("20250913000000_TypeChange", "String→enum", oldModels, curModels)
        // users 表被删、EnumEntity 表新增（表名不同），此用例只验证 columnDefinition 不抛异常
        let d = OpenGaussDialect()
        let sqls = upSql(m, d)
        @Expect(sqls.size, 2)
    }
}

// ---------- PostgreSQL 方言 ----------

@Test
class PostgreSqlDialectTests {
    @TestCase
    public func testPgInsertReturning(): Unit {
        let d = PostgreSqlDialect()
        let cols = ArrayList<String>()
        cols.add("name")
        cols.add("age")
        @Expect(d.buildInsert("users", cols, "id", true),
            "INSERT INTO \"users\" (\"name\", \"age\") VALUES (?, ?) RETURNING \"id\"")
        @Expect(d.buildInsert("users", cols, "id", false),
            "INSERT INTO \"users\" (\"name\", \"age\") VALUES (?, ?)")
    }

    @TestCase
    public func testPgCrudSql(): Unit {
        let d = PostgreSqlDialect()
        let cols = ArrayList<String>()
        cols.add("name")
        @Expect(d.buildUpdate("users", cols, "id"),
            "UPDATE \"users\" SET \"name\" = ? WHERE \"id\" = ?")
        @Expect(d.buildDelete("users", "id"),
            "DELETE FROM \"users\" WHERE \"id\" = ?")
        @Expect(d.buildCount("users", ""),
            "SELECT COUNT(*) FROM \"users\"")
        @Expect(d.buildSelect("users", ArrayList<String>(), "\"age\" > ?", "\"id\"", 10, 5),
            "SELECT * FROM \"users\" WHERE \"age\" > ? ORDER BY \"id\" LIMIT 5 OFFSET 10")
    }

    @TestCase
    public func testPgDdlSql(): Unit {
        let d = PostgreSqlDialect()
        @Expect(d.columnTypeSql(ColumnTypes.BigIntCol, true, 0), "BIGSERIAL")
        @Expect(d.columnTypeSql(ColumnTypes.IntCol, true, 0), "SERIAL")
        @Expect(d.columnTypeSql(ColumnTypes.TextCol, false, 100), "VARCHAR(100)")
        @Expect(d.columnTypeSql(ColumnTypes.TextCol, false, 0), "VARCHAR(255)")
        @Expect(d.columnTypeSql(ColumnTypes.BinaryCol, false, 0), "BYTEA")
        @Expect(d.buildAlterColumn("users", "VARCHAR(100)"),
            "ALTER TABLE \"users\" ALTER COLUMN VARCHAR(100)")
        @Expect(d.buildDropIndex("ix_users_name", "users"),
            "DROP INDEX IF EXISTS \"ix_users_name\"")
    }

    @TestCase
    public func testOpenGaussInheritsPg(): Unit {
        let d = OpenGaussDialect()
        let cols = ArrayList<String>()
        cols.add("name")
        @Expect(d.buildInsert("users", cols, "id", true),
            "INSERT INTO \"users\" (\"name\") VALUES (?) RETURNING \"id\"")
    }

    @TestCase
    public func testPgCreateDatabaseSql(): Unit {
        let d = PostgreSqlDialect()
        @Expect(d.createDatabaseSql("mydb"), "CREATE DATABASE \"mydb\"")
        @Expect(d.createDatabaseSql("my_db"), "CREATE DATABASE \"my_db\"")
        @Expect(d.databaseExistsSql(),
            "SELECT 1 FROM pg_database WHERE datname = ?")
        // openGauss 继承 PG
        let og = OpenGaussDialect()
        @Expect(og.createDatabaseSql("mydb"), "CREATE DATABASE \"mydb\"")
    }
}

// ---------- 应用继承 DbContext ----------

class FakeDatasource <: Datasource {
    public func setOption(_: String, _: String): Unit {}

    public func connect(): Connection {
        throw Exception("FakeDatasource 不支持真实连接")
    }

    public func isClosed(): Bool {
        false
    }

    public func close(): Unit {}

    public func ping(): Unit {}
}

class AppDbContext <: DbContext {
    let users: DbSet<User>
    let orders: DbSet<Order>

    init(ds: Datasource) {
        super(ds)
        users = set<User>()
        orders = set<Order>()
    }

    init(ds: Datasource, dialect: ISqlDialect) {
        super(ds, dialect)
        users = set<User>()
        orders = set<Order>()
    }
}

@Test
class DbContextInheritTests {
    @TestCase
    public func testInheritAndDbSets(): Unit {
        let ctx = AppDbContext(FakeDatasource())
        // 继承后暴露的 DbSet 属性可用
        let users = ctx.users
        let orders = ctx.orders
        @Expect(users is DbSet<User>, true)
        @Expect(orders is DbSet<Order>, true)
        // DbSet 操作连通到 context 的变更队列
        users.add(User())
        @Expect(ctx.pendingCount(), 1)
        orders.add(Order())
        @Expect(ctx.pendingCount(), 2)
        // 默认方言为 openGauss（继承 PG）
        @Expect(ctx.getDialect().quoteName("users"), "\"users\"")
    }

    @TestCase
    public func testCustomDialectAndMigrateApi(): Unit {
        let ctx = AppDbContext(FakeDatasource(), PostgreSqlDialect())
        @Expect(ctx.getDialect().quoteName("users"), "\"users\"")
        @Expect(ctx.pendingCount(), 0)
        // migrate 委托 Migrator；FakeDatasource 连接时会抛异常
        let threw = try {
            ctx.migrate(ArrayList<Migration>())
            false
        } catch (_: Exception) {
            true
        }
        @Expect(threw, true)
    }
}

// ---------- 模型快照 ----------

@Test
class ModelSnapshotTests {
    private func gen(): MigrationGenerator {
        MigrationGenerator()
    }

    private func models(): ArrayList<EntityModel> {
        let ms = ArrayList<EntityModel>()
        ms.add(ModelCache.get<User>())
        ms.add(ModelCache.get<Product>())
        ms
    }

    private func upSql(m: Migration, dialect: ISqlDialect): ArrayList<String> {
        let builder = MigrationBuilder()
        m.up(builder)
        let f = DdlFactory()
        let sqls = ArrayList<String>()
        for (op in builder.getOperations()) {
            sqls.add(f.toSql(op, dialect))
        }
        sqls
    }

    @TestCase
    public func testCaptureToJsonRoundTrip(): Unit {
        let snap = ModelSnapshot.capture(models())
        let json = snap.toJson()
        // 关键元数据落到 JSON
        @Expect(json.contains("\"table\":\"users\""), true)
        @Expect(json.contains("\"column\":\"id\""), true)
        @Expect(json.contains("\"type\":\"Int64\""), true)
        @Expect(json.contains("\"key\":true"), true)
        @Expect(json.contains("\"maxLen\":100"), true)
        @Expect(json.contains("\"required\":true"), true)

        let back = ModelSnapshot.fromJson(json)
        @Expect(back.models.size, 2)
        @Expect(back.models[0].tableName, "users")
        @Expect(back.models[1].tableName, "Product")
        // 轻量模型无反射句柄，typeName 走 typeNameOverride
        let lm = back.models[0]
        @Expect(lm.typeInfo.isNone(), true)
        @Expect(lm.keyProperty.getOrThrow().columnName, "id")
        @Expect(lm.keyProperty.getOrThrow().autoIncrement, true)
        // Product：类型 / 长度 / 必填 元数据保留
        let pm = back.models[1]
        @Expect(pm.properties[0].columnName, "pid")
        @Expect(pm.properties[0].typeName(), "Int64")
        @Expect(pm.properties[1].columnName, "title")
        @Expect(pm.properties[1].typeName(), "String")
        @Expect(pm.properties[1].maxLength, 100)
        @Expect(pm.properties[1].isRequired, true)
    }

    @TestCase
    public func testSaveLoadFile(): Unit {
        let path = "snapshot_test_tmp.json"
        if (exists(Path(path))) { remove(Path(path)) }
        ModelSnapshot.capture(models()).save(path)
        @Expect(exists(Path(path)), true)
        let loaded = ModelSnapshot.load(path)
        @Expect(loaded.isSome(), true)
        @Expect(loaded.getOrThrow().models.size, 2)
        @Expect(loaded.getOrThrow().models[1].properties[1].maxLength, 100)
        // 文件不存在 → None
        if (exists(Path(path))) { remove(Path(path)) }
        @Expect(ModelSnapshot.load(path).isNone(), true)
    }

    @TestCase
    public func testSnapshotModelsWorkWithDiff(): Unit {
        let snap = ModelSnapshot.capture(models())
        // 快照轻量模型 vs 反射模型：无变化 → 空操作
        let m = gen().diff("20250901000000_NoChange", "无变化", snap.toModels(), models())
        let d = OpenGaussDialect()
        @Expect(upSql(m, d).size, 0)
    }

    @TestCase
    public func testEnsureInitialThenNoChange(): Unit {
        let path = "snapshot_test_tmp.json"
        if (exists(Path(path))) { remove(Path(path)) }
        let d = OpenGaussDialect()
        // 首次：快照不存在 → initial 全量建表 + 保存快照
        let m1 = gen().ensure("20250901000000_Initial", "初始建表", path, models())
        let up1 = upSql(m1, d)
        @Expect(up1.size, 2)
        @Expect(up1[0].startsWith("CREATE TABLE IF NOT EXISTS \"users\""), true)
        @Expect(exists(Path(path)), true)
        @Expect(ModelSnapshot.load(path).getOrThrow().models.size, 2)
        // 二次：模型未变 → diff 空操作（依赖已存快照，无需调用方手存旧模型）
        let m2 = gen().ensure("20250902000000_NoChange", "无变化", path, models())
        @Expect(upSql(m2, d).size, 0)
        if (exists(Path(path))) { remove(Path(path)) }
    }

    @TestCase
    public func testEnsureDiffWithNewTable(): Unit {
        let path = "snapshot_test_tmp.json"
        if (exists(Path(path))) { remove(Path(path)) }
        let d = OpenGaussDialect()
        gen().ensure("20250901000000_Initial", "初始建表", path, models())
        // 模型新增 items 表后二次 ensure → 自动 diff 出 CreateTable
        let ms2 = models()
        ms2.add(ModelCache.get<ItemV2>())
        let m = gen().ensure("20250903000000_AddItems", "新增 items", path, ms2)
        let up = upSql(m, d)
        @Expect(up.size, 1)
        @Expect(up[0].startsWith("CREATE TABLE IF NOT EXISTS \"items\""), true)
        // 快照已覆盖为 3 个模型
        @Expect(ModelSnapshot.load(path).getOrThrow().models.size, 3)
        if (exists(Path(path))) { remove(Path(path)) }
    }
}