/*
 * query.cj - 完整查询构建器模块
 *
 * 提供链式 SQL 查询构建功能：
 * - SELECT 查询（支持 JOIN、子查询、分组、排序）
 * - INSERT 语句
 * - UPDATE 语句
 * - DELETE 语句
 * - 条件构建器
 * - SQL 注入防护
 *
 * 设计参考 MyBatis-Plus 和 jOOQ。
 */

package tybb2026::tycj_orm

import std.collection.*

// ============================================================================
// SQL 类型枚举
// ============================================================================

public enum SqlType {
    | Select
    | Insert
    | Update
    | Delete
}

// ============================================================================
// 排序方向枚举
// ============================================================================

public enum Direction {
    | Asc
    | Desc
}

// ============================================================================
// JOIN 类型枚举
// ============================================================================

public enum JoinType {
    | Inner
    | Left
    | Right
    | Full
    | Cross
}

// ============================================================================
// 排序规则类
// ============================================================================

public class Order {
    public var property: String
    public var direction: Direction

    public init(property!: String = "", direction!: Direction = Direction.Asc) {
        this.property = property
        this.direction = direction
    }
}

// ============================================================================
// JOIN 子句
// ============================================================================

public class JoinClause {
    public var joinType: JoinType = JoinType.Inner
    public var table: String = ""
    public var alias: String = ""
    public var onCondition: String = ""
    
    public init() {}
    
    public init(joinType: JoinType, table: String, alias: String, onCondition: String) {
        this.joinType = joinType
        this.table = table
        this.alias = alias
        this.onCondition = onCondition
    }
    
    public func toSql(): String {
        let joinKeyword = match (joinType) {
            case JoinType.Inner => "INNER JOIN"
            case JoinType.Left => "LEFT JOIN"
            case JoinType.Right => "RIGHT JOIN"
            case JoinType.Full => "FULL JOIN"
            case JoinType.Cross => "CROSS JOIN"
        }
        
        let tablePart = if (alias.isEmpty()) { table } else { "${table} AS ${alias}" }
        let onPart = if (onCondition.isEmpty()) { "" } else { " ON ${onCondition}" }
        
        "${joinKeyword} ${tablePart}${onPart}"
    }
}

// ============================================================================
// 条件构建器
// ============================================================================

/**
 * ConditionBuilder - 条件构建器
 *
 * 用于构建复杂的 WHERE 条件。
 */
public class ConditionBuilder {
    private var conditions: ArrayList<String> = ArrayList<String>()
    private var parameters: ArrayList<String> = ArrayList<String>()
    
    public init() {}
    
    // 添加条件
    public func add(condition: String): ConditionBuilder {
        conditions.add(condition)
        return this
    }
    
    // 等于条件
    public func eq(column: String, value: String): ConditionBuilder {
        conditions.add("${column} = ?")
        parameters.add(value)
        return this
    }
    
    // 不等于条件
    public func ne(column: String, value: String): ConditionBuilder {
        conditions.add("${column} <> ?")
        parameters.add(value)
        return this
    }
    
    // 大于条件
    public func gt(column: String, value: String): ConditionBuilder {
        conditions.add("${column} > ?")
        parameters.add(value)
        return this
    }
    
    // 大于等于条件
    public func ge(column: String, value: String): ConditionBuilder {
        conditions.add("${column} >= ?")
        parameters.add(value)
        return this
    }
    
    // 小于条件
    public func lt(column: String, value: String): ConditionBuilder {
        conditions.add("${column} < ?")
        parameters.add(value)
        return this
    }
    
    // 小于等于条件
    public func le(column: String, value: String): ConditionBuilder {
        conditions.add("${column} <= ?")
        parameters.add(value)
        return this
    }
    
    // LIKE 条件（自动转义通配符）
    public func like(column: String, value: String): ConditionBuilder {
        conditions.add("${column} LIKE ?")
        parameters.add("%${escapeLikePattern(value)}%")
        return this
    }

    // 转义 LIKE 模式中的通配符
    private func escapeLikePattern(value: String): String {
        var result = ""
        for (i in 0..value.size) {
            let c = value[i]
            // 转义 % _ [ ] 等特殊字符
            if (c == 37u8 || c == 95u8 || c == 91u8 || c == 93u8) { // % _ [ ]
                result = result + "\\" + String.fromUtf8([c])
            } else {
                result = result + String.fromUtf8([c])
            }
        }
        result
    }
    
    // LIKE 左模糊
    public func likeLeft(column: String, value: String): ConditionBuilder {
        conditions.add("${column} LIKE ?")
        parameters.add("%${escapeLikePattern(value)}")
        return this
    }

    // LIKE 右模糊
    public func likeRight(column: String, value: String): ConditionBuilder {
        conditions.add("${column} LIKE ?")
        parameters.add("${escapeLikePattern(value)}%")
        return this
    }
    
    // IS NULL 条件
    public func isNull(column: String): ConditionBuilder {
        conditions.add("${column} IS NULL")
        return this
    }
    
    // IS NOT NULL 条件
    public func isNotNull(column: String): ConditionBuilder {
        conditions.add("${column} IS NOT NULL")
        return this
    }
    
    // IN 条件（限制最大参数数量防止SQL过长）
    public func isIn(column: String, values: ArrayList<String>): ConditionBuilder {
        // 限制IN子句最大参数数量为1000（大多数数据库的限制）
        let maxInParams = 1000
        if (values.size > maxInParams) {
            throw IllegalArgumentException("IN子句参数数量超过最大限制 ${maxInParams}")
        }
        if (values.isEmpty()) {
            // 空列表时添加永假条件
            conditions.add("1=0")
            return this
        }
        let placeholders = ArrayList<String>()
        for (v in values) {
            placeholders.add("?")
            parameters.add(v)
        }
        conditions.add("${column} IN (${joinStrings(placeholders, ", ")})")
        return this
    }

    // NOT IN 条件（限制最大参数数量防止SQL过长）
    public func isNotIn(column: String, values: ArrayList<String>): ConditionBuilder {
        let maxInParams = 1000
        if (values.size > maxInParams) {
            throw IllegalArgumentException("NOT IN子句参数数量超过最大限制 ${maxInParams}")
        }
        if (values.isEmpty()) {
            // 空列表时添加永真条件
            conditions.add("1=1")
            return this
        }
        let placeholders = ArrayList<String>()
        for (v in values) {
            placeholders.add("?")
            parameters.add(v)
        }
        conditions.add("${column} NOT IN (${joinStrings(placeholders, ", ")})")
        return this
    }
    
    // BETWEEN 条件
    public func between(column: String, value1: String, value2: String): ConditionBuilder {
        conditions.add("${column} BETWEEN ? AND ?")
        parameters.add(value1)
        parameters.add(value2)
        return this
    }
    
    // 构建条件字符串
    public func build(): String {
        if (conditions.isEmpty()) {
            return ""
        }
        joinStrings(conditions, " AND ")
    }
    
    // 获取参数
    public func getParameters(): ArrayList<String> {
        parameters
    }
    
    // 清空
    public func clear(): Unit {
        conditions.clear()
        parameters.clear()
    }
    
    // 辅助函数：连接字符串列表
    private func joinStrings(list: ArrayList<String>, separator: String): String {
        if (list.isEmpty()) {
            return ""
        }
        let sb = StringBuilder()
        for (i in 0..list.size) {
            if (i > 0) {
                sb.append(separator)
            }
            sb.append(list[i])
        }
        sb.toString()
    }
}

// ============================================================================
// 子查询构建器
// ============================================================================

/**
 * SubQueryBuilder - 子查询构建器
 * 用于构建嵌套在主查询中的子查询
 */
public class SubQueryBuilder {
    private var selectBuilder: SelectBuilder
    private var alias: String = ""

    public init(alias!: String = "sub") {
        this.selectBuilder = SelectBuilder()
        this.alias = alias
    }

    // 设置子查询别名
    public func setAlias(alias: String): SubQueryBuilder {
        this.alias = alias
        return this
    }

    // 获取内部 SELECT 构建器
    public func getSelectBuilder(): SelectBuilder {
        return selectBuilder
    }

    // 构建子查询 SQL（带别名）
    public func build(): String {
        let sql = selectBuilder.build()
        return "(${sql}) AS ${alias}"
    }

    // 构建子查询 SQL（不带别名，用于 IN 子句）
    public func buildWithoutAlias(): String {
        let sql = selectBuilder.build()
        return "(${sql})"
    }
}

// ============================================================================
// UNION 查询构建器
// ============================================================================

/**
 * UnionBuilder - UNION 查询构建器
 * 用于合并多个 SELECT 查询结果
 */
public class UnionBuilder {
    private var selectBuilders: ArrayList<SelectBuilder> = ArrayList<SelectBuilder>()
    private var isUnionAll: Bool = false
    private var orders: ArrayList<Order> = ArrayList<Order>()
    private var limitValue: Int64 = -1
    private var offsetValue: Int64 = -1

    public init() {}

    // 添加 SELECT 查询
    public func addSelect(builder: SelectBuilder): UnionBuilder {
        selectBuilders.add(builder)
        return this
    }

    // 设置 UNION ALL（保留重复行）
    public func unionAll(): UnionBuilder {
        this.isUnionAll = true
        return this
    }

    // 设置 UNION（去除重复行）
    public func unionDistinct(): UnionBuilder {
        this.isUnionAll = false
        return this
    }

    // ORDER BY
    public func orderBy(property: String, direction!: Direction = Direction.Asc): UnionBuilder {
        orders.add(Order(property: property, direction: direction))
        return this
    }

    // LIMIT
    public func limit(count: Int64): UnionBuilder {
        this.limitValue = count
        return this
    }

    // OFFSET
    public func offset(count: Int64): UnionBuilder {
        this.offsetValue = count
        return this
    }

    // 构建 SQL
    public func build(): String {
        if (selectBuilders.isEmpty()) {
            throw IllegalArgumentException("UNION 查询至少需要一个 SELECT 查询")
        }

        let sb = StringBuilder()
        let unionKeyword = if (isUnionAll) { " UNION ALL " } else { " UNION " }

        for (i in 0..selectBuilders.size) {
            if (i > 0) {
                sb.append(unionKeyword)
            }
            sb.append(selectBuilders[i].build())
        }

        // ORDER BY 子句
        if (!orders.isEmpty()) {
            sb.append(" ORDER BY ")
            for (i in 0..orders.size) {
                if (i > 0) {
                    sb.append(", ")
                }
                let order = orders[i]
                sb.append(order.property)
                sb.append(" ")
                match (order.direction) {
                    case Direction.Asc => sb.append("ASC")
                    case Direction.Desc => sb.append("DESC")
                }
            }
        }

        // LIMIT 和 OFFSET
        if (limitValue >= 0) {
            sb.append(" LIMIT ")
            sb.append(limitValue.toString())
        }
        if (offsetValue >= 0) {
            sb.append(" OFFSET ")
            sb.append(offsetValue.toString())
        }

        sb.toString()
    }

    // 获取所有参数
    public func getParameters(): ArrayList<String> {
        let allParams = ArrayList<String>()
        for (builder in selectBuilders) {
            for (param in builder.getParameters()) {
                allParams.add(param)
            }
        }
        allParams
    }
}

// ============================================================================
// 批量插入构建器
// ============================================================================

/**
 * BatchInsertBuilder - 批量插入构建器
 * 用于构建批量 INSERT 语句
 */
public class BatchInsertBuilder {
    private var tableName: String = ""
    private var insertColumns: ArrayList<String> = ArrayList<String>()
    private var batchValues: ArrayList<ArrayList<String>> = ArrayList<ArrayList<String>>()
    private var parameters: ArrayList<String> = ArrayList<String>()

    public init() {}

    public init(tableName: String) {
        this.tableName = tableName
    }

    // 设置表名
    public func into(table: String): BatchInsertBuilder {
        this.tableName = table
        return this
    }

    // 设置列名
    public func columns(cols: ArrayList<String>): BatchInsertBuilder {
        this.insertColumns = cols
        return this
    }

    // 添加单行数据
    public func addRow(values: ArrayList<String>): BatchInsertBuilder {
        batchValues.add(values)
        for (v in values) {
            parameters.add(v)
        }
        return this
    }

    // 批量添加多行数据
    public func addRows(rows: ArrayList<ArrayList<String>>): BatchInsertBuilder {
        for (row in rows) {
            addRow(row)
        }
        return this
    }

    // 构建 SQL
    public func build(): String {
        if (insertColumns.isEmpty()) {
            throw IllegalArgumentException("批量插入必须指定列名")
        }
        if (batchValues.isEmpty()) {
            throw IllegalArgumentException("批量插入必须至少有一行数据")
        }

        let sb = StringBuilder()

        sb.append("INSERT INTO ")
        sb.append(tableName)
        sb.append(" (")
        sb.append(joinStrings(insertColumns, ", "))
        sb.append(") VALUES ")

        // 构建多行 VALUES
        for (i in 0..batchValues.size) {
            if (i > 0) {
                sb.append(", ")
            }
            sb.append("(")
            let row = batchValues[i]
            let placeholders = ArrayList<String>()
            for (_ in row) {
                placeholders.add("?")
            }
            sb.append(joinStrings(placeholders, ", "))
            sb.append(")")
        }

        sb.toString()
    }

    // 获取参数
    public func getParameters(): ArrayList<String> {
        parameters
    }

    // 获取行数
    public func getRowCount(): Int64 {
        batchValues.size
    }

    private func joinStrings(list: ArrayList<String>, separator: String): String {
        if (list.isEmpty()) {
            return ""
        }
        let sb = StringBuilder()
        for (i in 0..list.size) {
            if (i > 0) {
                sb.append(separator)
            }
            sb.append(list[i])
        }
        sb.toString()
    }
}

// ============================================================================
// 扩展 SelectBuilder 支持子查询
// ============================================================================

/**
 * SelectBuilder 扩展方法
 * 在原有 SelectBuilder 类中添加子查询支持
 */

// 扩展 SelectBuilder 类添加子查询相关方法
public class SelectBuilderExt {
    // 子查询作为表
    public static func fromSubQuery(builder: SelectBuilder, alias: String): String {
        let subSql = builder.build()
        return "(${subSql}) AS ${alias}"
    }

    // 子查询作为列
    public static func columnSubQuery(builder: SelectBuilder, alias: String): String {
        let subSql = builder.build()
        return "(${subSql}) AS ${alias}"
    }

    // 子查询用于 IN 条件
    public static func inSubQuery(column: String, builder: SelectBuilder): String {
        let subSql = builder.build()
        return "${column} IN (${subSql})"
    }

    // 子查询用于 EXISTS 条件
    public static func existsSubQuery(builder: SelectBuilder): String {
        let subSql = builder.build()
        return "EXISTS (${subSql})"
    }

    // 子查询用于 NOT EXISTS 条件
    public static func notExistsSubQuery(builder: SelectBuilder): String {
        let subSql = builder.build()
        return "NOT EXISTS (${subSql})"
    }
}

// ============================================================================
// 扩展 ConditionBuilder 支持子查询
// ============================================================================

/**
 * ConditionBuilder 子查询扩展
 */
public class ConditionBuilderExt {
    // IN 子查询
    public static func inSubQuery(column: String, subBuilder: SelectBuilder): String {
        let subSql = subBuilder.build()
        return "${column} IN (${subSql})"
    }

    // NOT IN 子查询
    public static func notInSubQuery(column: String, subBuilder: SelectBuilder): String {
        let subSql = subBuilder.build()
        return "${column} NOT IN (${subSql})"
    }

    // EXISTS 子查询
    public static func existsSubQuery(subBuilder: SelectBuilder): String {
        let subSql = subBuilder.build()
        return "EXISTS (${subSql})"
    }

    // NOT EXISTS 子查询
    public static func notExistsSubQuery(subBuilder: SelectBuilder): String {
        let subSql = subBuilder.build()
        return "NOT EXISTS (${subSql})"
    }

    // 比较子查询（=, >, <, >=, <=）
    public static func compareSubQuery(column: String, operator_: String, subBuilder: SelectBuilder): String {
        let subSql = subBuilder.build()
        return "${column} ${operator_} (${subSql})"
    }
}

// ============================================================================
// SELECT 查询构建器
// ============================================================================

/**
 * SelectBuilder - SELECT 查询构建器
 */
public class SelectBuilder {
    private var tableName: String = ""
    private var tableAlias: String = ""
    private var selectColumns: ArrayList<String> = ArrayList<String>()
    private var joins: ArrayList<JoinClause> = ArrayList<JoinClause>()
    private var whereClause: String = ""
    private var conditionBuilder: ConditionBuilder = ConditionBuilder()
    private var groupByColumns: ArrayList<String> = ArrayList<String>()
    private var havingCondition: String = ""
    private var orders: ArrayList<Order> = ArrayList<Order>()
    private var limitValue: Int64 = -1
    private var offsetValue: Int64 = -1
    private var isDistinct: Bool = false
    private var isForUpdate: Bool = false
    
    public init() {}
    
    public init(tableName: String) {
        this.tableName = tableName
    }
    
    // 设置表名
    public func from(table: String): SelectBuilder {
        this.tableName = table
        return this
    }
    
    // 设置表别名
    public func alias(alias: String): SelectBuilder {
        this.tableAlias = alias
        return this
    }
    
    // 设置查询字段
    public func select(columns: ArrayList<String>): SelectBuilder {
        this.selectColumns = columns
        return this
    }
    
    // 添加单个字段
    public func column(col: String): SelectBuilder {
        this.selectColumns.add(col)
        return this
    }
    
    // 设置 DISTINCT
    public func distinct(): SelectBuilder {
        this.isDistinct = true
        return this
    }
    
    // WHERE 条件
    public func where_(condition: String): SelectBuilder {
        this.whereClause = condition
        return this
    }
    
    // 使用条件构建器
    public func setWhereCondition(builder: ConditionBuilder): SelectBuilder {
        this.conditionBuilder = builder
        return this
    }
    
    // INNER JOIN
    public func innerJoin(table: String, alias: String, onCondition: String): SelectBuilder {
        joins.add(JoinClause(JoinType.Inner, table, alias, onCondition))
        return this
    }
    
    // LEFT JOIN
    public func leftJoin(table: String, alias: String, onCondition: String): SelectBuilder {
        joins.add(JoinClause(JoinType.Left, table, alias, onCondition))
        return this
    }
    
    // RIGHT JOIN
    public func rightJoin(table: String, alias: String, onCondition: String): SelectBuilder {
        joins.add(JoinClause(JoinType.Right, table, alias, onCondition))
        return this
    }
    
    // GROUP BY
    public func groupBy(columns: ArrayList<String>): SelectBuilder {
        this.groupByColumns = columns
        return this
    }
    
    // HAVING
    public func having(condition: String): SelectBuilder {
        this.havingCondition = condition
        return this
    }
    
    // ORDER BY
    public func orderBy(property: String, direction!: Direction = Direction.Asc): SelectBuilder {
        orders.add(Order(property: property, direction: direction))
        return this
    }
    
    // LIMIT
    public func limit(count: Int64): SelectBuilder {
        this.limitValue = count
        return this
    }
    
    // OFFSET
    public func offset(count: Int64): SelectBuilder {
        this.offsetValue = count
        return this
    }
    
    // FOR UPDATE
    public func setForUpdate(): SelectBuilder {
        this.isForUpdate = true
        return this
    }
    
    // 构建 SQL
    public func build(): String {
        let sb = StringBuilder()
        
        // SELECT 子句
        sb.append("SELECT ")
        if (isDistinct) {
            sb.append("DISTINCT ")
        }
        if (selectColumns.isEmpty()) {
            sb.append("*")
        } else {
            sb.append(joinStrings(selectColumns, ", "))
        }
        
        // FROM 子句
        sb.append(" FROM ")
        sb.append(tableName)
        if (!tableAlias.isEmpty()) {
            sb.append(" AS ")
            sb.append(tableAlias)
        }
        
        // JOIN 子句
        for (join in joins) {
            sb.append(" ")
            sb.append(join.toSql())
        }
        
        // WHERE 子句
        let finalWhere = if (!whereClause.isEmpty()) {
            whereClause
        } else {
            conditionBuilder.build()
        }
        if (!finalWhere.isEmpty()) {
            sb.append(" WHERE ")
            sb.append(finalWhere)
        }
        
        // GROUP BY 子句
        if (!groupByColumns.isEmpty()) {
            sb.append(" GROUP BY ")
            sb.append(joinStrings(groupByColumns, ", "))
        }
        
        // HAVING 子句
        if (!havingCondition.isEmpty()) {
            sb.append(" HAVING ")
            sb.append(havingCondition)
        }
        
        // ORDER BY 子句
        if (!orders.isEmpty()) {
            sb.append(" ORDER BY ")
            for (i in 0..orders.size) {
                if (i > 0) {
                    sb.append(", ")
                }
                let order = orders[i]
                sb.append(order.property)
                sb.append(" ")
                match (order.direction) {
                    case Direction.Asc => sb.append("ASC")
                    case Direction.Desc => sb.append("DESC")
                }
            }
        }
        
        // LIMIT 和 OFFSET
        if (limitValue >= 0) {
            sb.append(" LIMIT ")
            sb.append(limitValue.toString())
        }
        if (offsetValue >= 0) {
            sb.append(" OFFSET ")
            sb.append(offsetValue.toString())
        }
        
        // FOR UPDATE
        if (isForUpdate) {
            sb.append(" FOR UPDATE")
        }
        
        sb.toString()
    }
    
    // 获取参数
    public func getParameters(): ArrayList<String> {
        conditionBuilder.getParameters()
    }
    
    // 辅助函数
    private func joinStrings(list: ArrayList<String>, separator: String): String {
        if (list.isEmpty()) {
            return ""
        }
        let sb = StringBuilder()
        for (i in 0..list.size) {
            if (i > 0) {
                sb.append(separator)
            }
            sb.append(list[i])
        }
        sb.toString()
    }
}

// ============================================================================
// INSERT 构建器
// ============================================================================

/**
 * InsertBuilder - INSERT 语句构建器
 */
public class InsertBuilder {
    private var tableName: String = ""
    private var insertColumns: ArrayList<String> = ArrayList<String>()
    private var insertValues: ArrayList<String> = ArrayList<String>()
    private var parameters: ArrayList<String> = ArrayList<String>()
    
    public init() {}
    
    public init(tableName: String) {
        this.tableName = tableName
    }
    
    // 设置表名
    public func into(table: String): InsertBuilder {
        this.tableName = table
        return this
    }
    
    // 添加列和值
    public func value(column: String, val: String): InsertBuilder {
        insertColumns.add(column)
        insertValues.add("?")
        parameters.add(val)
        return this
    }
    
    // 批量添加列
    public func setColumns(cols: ArrayList<String>): InsertBuilder {
        this.insertColumns = cols
        return this
    }
    
    // 批量添加值
    public func setValues(vals: ArrayList<String>): InsertBuilder {
        for (v in vals) {
            insertValues.add("?")
            parameters.add(v)
        }
        return this
    }
    
    // 构建 SQL
    public func build(): String {
        let sb = StringBuilder()
        
        sb.append("INSERT INTO ")
        sb.append(tableName)
        sb.append(" (")
        sb.append(joinStrings(insertColumns, ", "))
        sb.append(") VALUES (")
        sb.append(joinStrings(insertValues, ", "))
        sb.append(")")
        
        sb.toString()
    }
    
    // 获取参数
    public func getParameters(): ArrayList<String> {
        parameters
    }
    
    private func joinStrings(list: ArrayList<String>, separator: String): String {
        if (list.isEmpty()) {
            return ""
        }
        let sb = StringBuilder()
        for (i in 0..list.size) {
            if (i > 0) {
                sb.append(separator)
            }
            sb.append(list[i])
        }
        sb.toString()
    }
}

// ============================================================================
// UPDATE 构建器
// ============================================================================

/**
 * UpdateBuilder - UPDATE 语句构建器
 */
public class UpdateBuilder {
    private var tableName: String = ""
    private var setClauses: ArrayList<String> = ArrayList<String>()
    private var parameters: ArrayList<String> = ArrayList<String>()
    private var whereClause: String = ""
    private var conditionBuilder: ConditionBuilder = ConditionBuilder()
    
    public init() {}
    
    public init(tableName: String) {
        this.tableName = tableName
    }
    
    // 设置表名
    public func table(name: String): UpdateBuilder {
        this.tableName = name
        return this
    }
    
    // SET 子句
    public func set(column: String, value: String): UpdateBuilder {
        setClauses.add("${column} = ?")
        parameters.add(value)
        return this
    }
    
    // SET 表达式
    public func setExpr(column: String, expr: String): UpdateBuilder {
        setClauses.add("${column} = ${expr}")
        return this
    }
    
    // WHERE 条件
    public func where_(condition: String): UpdateBuilder {
        this.whereClause = condition
        return this
    }
    
    // 使用条件构建器
    public func setWhereCondition(builder: ConditionBuilder): UpdateBuilder {
        this.conditionBuilder = builder
        return this
    }
    
    // 构建 SQL
    public func build(): String {
        let sb = StringBuilder()
        
        sb.append("UPDATE ")
        sb.append(tableName)
        sb.append(" SET ")
        sb.append(joinStrings(setClauses, ", "))
        
        // WHERE 子句
        let finalWhere = if (!whereClause.isEmpty()) {
            whereClause
        } else {
            conditionBuilder.build()
        }
        if (!finalWhere.isEmpty()) {
            sb.append(" WHERE ")
            sb.append(finalWhere)
        }
        
        sb.toString()
    }
    
    // 获取参数
    public func getParameters(): ArrayList<String> {
        let allParams = ArrayList<String>()
        for (p in parameters) {
            allParams.add(p)
        }
        for (p in conditionBuilder.getParameters()) {
            allParams.add(p)
        }
        allParams
    }
    
    private func joinStrings(list: ArrayList<String>, separator: String): String {
        if (list.isEmpty()) {
            return ""
        }
        let sb = StringBuilder()
        for (i in 0..list.size) {
            if (i > 0) {
                sb.append(separator)
            }
            sb.append(list[i])
        }
        sb.toString()
    }
}

// ============================================================================
// DELETE 构建器
// ============================================================================

/**
 * DeleteBuilder - DELETE 语句构建器
 */
public class DeleteBuilder {
    private var tableName: String = ""
    private var whereClause: String = ""
    private var conditionBuilder: ConditionBuilder = ConditionBuilder()
    
    public init() {}
    
    public init(tableName: String) {
        this.tableName = tableName
    }
    
    // 设置表名
    public func from(table: String): DeleteBuilder {
        this.tableName = table
        return this
    }
    
    // WHERE 条件
    public func where_(condition: String): DeleteBuilder {
        this.whereClause = condition
        return this
    }
    
    // 使用条件构建器
    public func setWhereCondition(builder: ConditionBuilder): DeleteBuilder {
        this.conditionBuilder = builder
        return this
    }
    
    // 构建 SQL
    public func build(): String {
        let sb = StringBuilder()
        
        sb.append("DELETE FROM ")
        sb.append(tableName)
        
        // WHERE 子句
        let finalWhere = if (!whereClause.isEmpty()) {
            whereClause
        } else {
            conditionBuilder.build()
        }
        
        // 安全检查：禁止无条件删除
        if (finalWhere.isEmpty()) {
            throw IllegalArgumentException("DELETE 操作必须指定 WHERE 条件，禁止删除表中所有数据")
        }
        
        sb.append(" WHERE ")
        sb.append(finalWhere)
        
        sb.toString()
    }
    
    // 获取参数
    public func getParameters(): ArrayList<String> {
        conditionBuilder.getParameters()
    }
}

// ============================================================================
// SQL 构建器工厂
// ============================================================================

/**
 * SqlBuilder - SQL 构建器工厂
 */
public class SqlBuilder {
    // 创建 SELECT 构建器
    public static func select(columns: ArrayList<String>): SelectBuilder {
        let builder = SelectBuilder()
        builder.select(columns)
        builder
    }
    
    // 创建 SELECT 构建器（指定表）
    public static func selectFrom(table: String): SelectBuilder {
        SelectBuilder(table)
    }
    
    // 创建 INSERT 构建器
    public static func insert(table: String): InsertBuilder {
        InsertBuilder(table)
    }
    
    // 创建 UPDATE 构建器
    public static func update(table: String): UpdateBuilder {
        UpdateBuilder(table)
    }
    
    // 创建 DELETE 构建器
    public static func deleteFrom(table: String): DeleteBuilder {
        DeleteBuilder(table)
    }
    
    // 创建条件构建器
    public static func conditions(): ConditionBuilder {
        ConditionBuilder()
    }
}

// ============================================================================
// 兼容旧版 QueryBuilder
// ============================================================================

/**
 * QueryBuilder - 兼容旧版查询构建器
 */
public class QueryBuilder {
    private var tableName: String = ""
    private var queryColumns: ArrayList<String> = ArrayList<String>()
    private var whereClause: String = ""
    private var orders: ArrayList<Order> = ArrayList<Order>()
    private var limitValue: Int64 = -1
    private var offsetValue: Int64 = -1

    public init(tableName!: String = "") {
        this.tableName = tableName
        this.queryColumns = ArrayList<String>()
        this.orders = ArrayList<Order>()
    }

    public func select(columns: ArrayList<String>): QueryBuilder {
        this.queryColumns = columns
        return this
    }

    public func where_(condition: String): QueryBuilder {
        this.whereClause = condition
        return this
    }

    public func orderBy(property: String, direction!: Direction = Direction.Asc): QueryBuilder {
        orders.add(Order(property: property, direction: direction))
        return this
    }

    public func limit(count: Int64): QueryBuilder {
        this.limitValue = count
        return this
    }

    public func offset(count: Int64): QueryBuilder {
        this.offsetValue = count
        return this
    }

    public func build(): String {
        let sb = StringBuilder()

        sb.append("SELECT ")
        if (queryColumns.isEmpty()) {
            sb.append("*")
        } else {
            for (i in 0..queryColumns.size) {
                if (i > 0) {
                    sb.append(", ")
                }
                sb.append(queryColumns[i])
            }
        }

        sb.append(" FROM ")
        sb.append(tableName)

        if (!whereClause.isEmpty()) {
            sb.append(" WHERE ")
            sb.append(whereClause)
        }

        if (!orders.isEmpty()) {
            sb.append(" ORDER BY ")
            for (i in 0..orders.size) {
                if (i > 0) {
                    sb.append(", ")
                }
                let order = orders[i]
                sb.append(order.property)
                sb.append(" ")
                match (order.direction) {
                    case Direction.Asc => sb.append("ASC")
                    case Direction.Desc => sb.append("DESC")
                }
            }
        }

        if (limitValue >= 0) {
            sb.append(" LIMIT ")
            sb.append(limitValue.toString())
        }
        if (offsetValue >= 0) {
            sb.append(" OFFSET ")
            sb.append(offsetValue.toString())
        }

        sb.toString()
    }
}