objects

var (
	ContextCanceled         = &Error{Message: "context canceled"}
	ContextDeadlineExceeded = &Error{Message: "context deadline exceeded"}
)

var (
	FLOAT_ZERO     = &Float{Value: 0.0}
	FLOAT_ONE      = &Float{Value: 1.0}
	FLOAT_NEG_ONE  = &Float{Value: -1.0}
	FLOAT_TWO      = &Float{Value: 2.0}
	FLOAT_HALF     = &Float{Value: 0.5}
	FLOAT_TEN      = &Float{Value: 10.0}
	FLOAT_HUNDRED  = &Float{Value: 100.0}
	FLOAT_THOUSAND = &Float{Value: 1000.0}
	FLOAT_PI       = &Float{Value: 3.14159265358979323846}
	FLOAT_E        = &Float{Value: 2.71828182845904523536}
)

var (
	TRUE  = &Bool{Value: true}
	FALSE = &Bool{Value: false}
)

var (
	STRING_EMPTY   = &String{Value: ""}
	STRING_TRUE    = &String{Value: "true"}
	STRING_FALSE   = &String{Value: "false"}
	STRING_NULL    = &String{Value: "null"}
	STRING_INT     = &String{Value: "INT"}
	STRING_FLOAT   = &String{Value: "FLOAT"}
	STRING_BOOL    = &String{Value: "BOOL"}
	STRING_STRING  = &String{Value: "STRING"}
	STRING_ARRAY   = &String{Value: "ARRAY"}
	STRING_MAP     = &String{Value: "MAP"}
	STRING_FUNC    = &String{Value: "FUNCTION"}
	STRING_BUILTIN = &String{Value: "BUILTIN"}
	STRING_ERROR   = &String{Value: "ERROR"}
	STRING_NIL     = &String{Value: "nil"}
	STRING_ZERO    = &String{Value: "0"}
	STRING_ONE     = &String{Value: "1"}
	STRING_SPACE   = &String{Value: " "}
	STRING_NEWLINE = &String{Value: "\n"}
)

var (
	BYTES_EMPTY = &Bytes{Value: []byte{}}
)

var BuiltinDbClose = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) != 1 {
			return newError("wrong number of arguments for dbClose. got=%d, want=1", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("argument to 'dbClose' must be DB, got %s", args[0].Type())
		}

		if err := db.Close(); err != nil {
			return newError("failed to close database: %v", err)
		}

		return NULL
	},
}

var BuiltinDbConnect = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbConnect. got=%d, want=2", len(args))
		}

		driver, ok := args[0].(*String)
		if !ok {
			return newError("first argument to 'dbConnect' must be STRING (driver), got %s", args[0].Type())
		}

		connStr, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbConnect' must be STRING (connection string), got %s", args[1].Type())
		}

		driverName := driver.Value

		switch driverName {
		case "sqlite3":
			driverName = "sqlite"
		case "pg", "postgresql":
			driverName = "postgres"
		case "sqlserver", "mssqlserver":
			driverName = "mssql"
		}

		db, err := sql.Open(driverName, connStr.Value)
		if err != nil {
			return newError("failed to open database: %v", err)
		}

		if err := db.Ping(); err != nil {
			db.Close()
			return newError("failed to connect to database: %v", err)
		}

		return NewDB(db, driverName, connStr.Value)
	},
}

var BuiltinDbExec = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbExec. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbExec' must be DB, got %s", args[0].Type())
		}

		sqlStmt, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbExec' must be STRING, got %s", args[1].Type())
		}

		execArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			execArgs[i] = objectToGoValue(arg)
		}

		result, err := db.Value.Exec(sqlStmt.Value, execArgs...)
		if err != nil {
			return newError("exec failed: %v", err)
		}

		lastID, _ := result.LastInsertId()
		rowsAffected, _ := result.RowsAffected()

		return NewArray([]Object{
			NewInt(lastID),
			NewInt(rowsAffected),
		})
	},
}

var BuiltinDbQuery = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQuery. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQuery' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQuery' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		columns, err := rows.Columns()
		if err != nil {
			return newError("failed to get columns: %v", err)
		}

		var result []Object

		for rows.Next() {
			values := make([]interface{}, len(columns))
			valuePtrs := make([]interface{}, len(columns))
			for i := range values {
				valuePtrs[i] = &values[i]
			}

			if err := rows.Scan(valuePtrs...); err != nil {
				return newError("scan failed: %v", err)
			}

			pairs := make(map[HashKey]MapPair)
			for i, col := range columns {
				key := NewString(col)
				pairs[key.HashKey()] = MapPair{
					Key:   key,
					Value: NewString(dbValueToString(values[i])),
				}
			}
			result = append(result, NewMap(pairs))
		}

		if err := rows.Err(); err != nil {
			return newError("rows error: %v", err)
		}

		return NewArray(result)
	},
}

var BuiltinDbQueryArrayTyped = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryArrayTyped. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryArrayTyped' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryArrayTyped' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		columns, err := rows.Columns()
		if err != nil {
			return newError("failed to get columns: %v", err)
		}

		var result []Object

		for rows.Next() {
			values := make([]interface{}, len(columns))
			valuePtrs := make([]interface{}, len(columns))
			for i := range values {
				valuePtrs[i] = &values[i]
			}

			if err := rows.Scan(valuePtrs...); err != nil {
				return newError("scan failed: %v", err)
			}

			rowArray := make([]Object, len(columns))
			for i, val := range values {
				rowArray[i] = dbValueToObjectPreserveType(val)
			}
			result = append(result, NewArray(rowArray))
		}

		if err := rows.Err(); err != nil {
			return newError("rows error: %v", err)
		}

		return NewArray(result)
	},
}

var BuiltinDbQueryCount = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryCount. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryCount' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryCount' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return NewInt(-1)
		}
		defer rows.Close()

		if !rows.Next() {
			return NewInt(-1)
		}

		var count int = -1
		if err := rows.Scan(&count); err != nil {
			return NewInt(-1)
		}

		return NewInt(int64(count))
	},
}

var BuiltinDbQueryFloat = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryFloat. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryFloat' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryFloat' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		if !rows.Next() {
			return &Float{Value: 0}
		}

		var val float64
		if err := rows.Scan(&val); err != nil {
			return newError("scan failed: %v", err)
		}

		return &Float{Value: val}
	},
}

var BuiltinDbQueryMap = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 3 {
			return newError("wrong number of arguments for dbQueryMap. got=%d, want>=3", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryMap' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryMap' must be STRING, got %s", args[1].Type())
		}

		keyCol, ok := args[2].(*String)
		if !ok {
			return newError("third argument to 'dbQueryMap' must be STRING (key column), got %s", args[2].Type())
		}

		queryArgs := make([]interface{}, len(args)-3)
		for i, arg := range args[3:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		columns, err := rows.Columns()
		if err != nil {
			return newError("failed to get columns: %v", err)
		}

		keyColIdx := -1
		for i, col := range columns {
			if col == keyCol.Value {
				keyColIdx = i
				break
			}
		}
		if keyColIdx < 0 {
			return newError("key column '%s' not found in result", keyCol.Value)
		}

		result := make(map[HashKey]MapPair)

		for rows.Next() {
			values := make([]interface{}, len(columns))
			valuePtrs := make([]interface{}, len(columns))
			for i := range values {
				valuePtrs[i] = &values[i]
			}

			if err := rows.Scan(valuePtrs...); err != nil {
				return newError("scan failed: %v", err)
			}

			pairs := make(map[HashKey]MapPair)
			for i, col := range columns {
				key := NewString(col)
				pairs[key.HashKey()] = MapPair{
					Key:   key,
					Value: NewString(dbValueToString(values[i])),
				}
			}

			keyValue := NewString(dbValueToString(values[keyColIdx]))
			result[keyValue.HashKey()] = MapPair{
				Key:   keyValue,
				Value: NewMap(pairs),
			}
		}

		if err := rows.Err(); err != nil {
			return newError("rows error: %v", err)
		}

		return NewMap(result)
	},
}

var BuiltinDbQueryMapArray = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 3 {
			return newError("wrong number of arguments for dbQueryMapArray. got=%d, want>=3", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryMapArray' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryMapArray' must be STRING, got %s", args[1].Type())
		}

		keyCol, ok := args[2].(*String)
		if !ok {
			return newError("third argument to 'dbQueryMapArray' must be STRING (key column), got %s", args[2].Type())
		}

		queryArgs := make([]interface{}, len(args)-3)
		for i, arg := range args[3:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		columns, err := rows.Columns()
		if err != nil {
			return newError("failed to get columns: %v", err)
		}

		keyColIdx := -1
		for i, col := range columns {
			if col == keyCol.Value {
				keyColIdx = i
				break
			}
		}
		if keyColIdx < 0 {
			return newError("key column '%s' not found in result", keyCol.Value)
		}

		tempResult := make(map[string][]Object)

		for rows.Next() {
			values := make([]interface{}, len(columns))
			valuePtrs := make([]interface{}, len(columns))
			for i := range values {
				valuePtrs[i] = &values[i]
			}

			if err := rows.Scan(valuePtrs...); err != nil {
				return newError("scan failed: %v", err)
			}

			pairs := make(map[HashKey]MapPair)
			for i, col := range columns {
				key := NewString(col)
				pairs[key.HashKey()] = MapPair{
					Key:   key,
					Value: NewString(dbValueToString(values[i])),
				}
			}

			keyValue := dbValueToString(values[keyColIdx])
			tempResult[keyValue] = append(tempResult[keyValue], NewMap(pairs))
		}

		if err := rows.Err(); err != nil {
			return newError("rows error: %v", err)
		}

		result := make(map[HashKey]MapPair)
		for keyStr, arr := range tempResult {
			keyObj := NewString(keyStr)
			result[keyObj.HashKey()] = MapPair{
				Key:   keyObj,
				Value: NewArray(arr),
			}
		}

		return NewMap(result)
	},
}

var BuiltinDbQueryOrdered = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryOrdered. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryOrdered' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryOrdered' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		columns, err := rows.Columns()
		if err != nil {
			return newError("failed to get columns: %v", err)
		}

		var result []Object

		for rows.Next() {
			values := make([]interface{}, len(columns))
			valuePtrs := make([]interface{}, len(columns))
			for i := range values {
				valuePtrs[i] = &values[i]
			}

			if err := rows.Scan(valuePtrs...); err != nil {
				return newError("scan failed: %v", err)
			}

			om := NewOrderedMap()
			for i, col := range columns {
				om.Set(NewString(col), NewString(dbValueToString(values[i])))
			}
			result = append(result, om)
		}

		if err := rows.Err(); err != nil {
			return newError("rows error: %v", err)
		}

		return NewArray(result)
	},
}

var BuiltinDbQueryRecs = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryRecs. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryRecs' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryRecs' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		columns, err := rows.Columns()
		if err != nil {
			return newError("failed to get columns: %v", err)
		}

		var result []Object

		headerRow := make([]Object, len(columns))
		for i, col := range columns {
			headerRow[i] = NewString(col)
		}
		result = append(result, NewArray(headerRow))

		for rows.Next() {
			values := make([]interface{}, len(columns))
			valuePtrs := make([]interface{}, len(columns))
			for i := range values {
				valuePtrs[i] = &values[i]
			}

			if err := rows.Scan(valuePtrs...); err != nil {
				return newError("scan failed: %v", err)
			}

			rowArray := make([]Object, len(columns))
			for i, val := range values {
				rowArray[i] = NewString(dbValueToString(val))
			}
			result = append(result, NewArray(rowArray))
		}

		if err := rows.Err(); err != nil {
			return newError("rows error: %v", err)
		}

		return NewArray(result)
	},
}

var BuiltinDbQueryRowTyped = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryRowTyped. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryRowTyped' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryRowTyped' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		if !rows.Next() {
			return NULL
		}

		columns, err := rows.Columns()
		if err != nil {
			return newError("failed to get columns: %v", err)
		}

		values := make([]interface{}, len(columns))
		valuePtrs := make([]interface{}, len(columns))
		for i := range values {
			valuePtrs[i] = &values[i]
		}

		if err := rows.Scan(valuePtrs...); err != nil {
			return newError("scan failed: %v", err)
		}

		pairs := make(map[HashKey]MapPair)
		for i, col := range columns {
			key := NewString(col)
			pairs[key.HashKey()] = MapPair{
				Key:   key,
				Value: dbValueToObjectPreserveType(values[i]),
			}
		}

		return NewMap(pairs)
	},
}

var BuiltinDbQueryString = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryString. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryString' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryString' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		if !rows.Next() {
			return NewString("")
		}

		var val string
		if err := rows.Scan(&val); err != nil {
			return newError("scan failed: %v", err)
		}

		return NewString(val)
	},
}

var BuiltinDbQueryTyped = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryTyped. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryTyped' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryTyped' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		columns, err := rows.Columns()
		if err != nil {
			return newError("failed to get columns: %v", err)
		}

		var result []Object

		for rows.Next() {
			values := make([]interface{}, len(columns))
			valuePtrs := make([]interface{}, len(columns))
			for i := range values {
				valuePtrs[i] = &values[i]
			}

			if err := rows.Scan(valuePtrs...); err != nil {
				return newError("scan failed: %v", err)
			}

			pairs := make(map[HashKey]MapPair)
			for i, col := range columns {
				key := NewString(col)
				pairs[key.HashKey()] = MapPair{
					Key:   key,
					Value: dbValueToObjectPreserveType(values[i]),
				}
			}
			result = append(result, NewMap(pairs))
		}

		if err := rows.Err(); err != nil {
			return newError("rows error: %v", err)
		}

		return NewArray(result)
	},
}

var BuiltinDbQueryValueTyped = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 2 {
			return newError("wrong number of arguments for dbQueryValueTyped. got=%d, want>=2", len(args))
		}

		db, ok := args[0].(*DB)
		if !ok {
			return newError("first argument to 'dbQueryValueTyped' must be DB, got %s", args[0].Type())
		}

		query, ok := args[1].(*String)
		if !ok {
			return newError("second argument to 'dbQueryValueTyped' must be STRING, got %s", args[1].Type())
		}

		queryArgs := make([]interface{}, len(args)-2)
		for i, arg := range args[2:] {
			queryArgs[i] = objectToGoValue(arg)
		}

		rows, err := db.Value.Query(query.Value, queryArgs...)
		if err != nil {
			return newError("query failed: %v", err)
		}
		defer rows.Close()

		if !rows.Next() {
			return NULL
		}

		var value interface{}
		if err := rows.Scan(&value); err != nil {
			return newError("scan failed: %v", err)
		}

		return dbValueToObjectPreserveType(value)
	},
}

var BuiltinFormatSQLValue = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) != 1 {
			return newError("wrong number of arguments for formatSQLValue. got=%d, want=1", len(args))
		}

		str, ok := args[0].(*String)
		if !ok {
			return newError("argument to 'formatSQLValue' must be STRING, got %s", args[0].Type())
		}

		result := strings.Replace(str.Value, "\r", "\\r", -1)
		result = strings.Replace(result, "\n", "\\n", -1)
		result = strings.Replace(result, "'", "''", -1)

		return NewString(result)
	},
}

var BuiltinSystemCmd = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 1 {
			return newError("wrong number of arguments for systemCmd. got=%d, want>=1", len(args))
		}

		cmdStr, ok := args[0].(*String)
		if !ok {
			return newError("first argument to 'systemCmd' must be STRING, got %s", args[0].Type())
		}

		// Build command arguments
		var cmdArgs []string
		for i := 1; i < len(args); i++ {
			if arg, ok := args[i].(*String); ok {
				cmdArgs = append(cmdArgs, arg.Value)
			} else {
				return newError("argument %d to 'systemCmd' must be STRING, got %s", i+1, args[i].Type())
			}
		}

		// Execute command
		var cmd *exec.Cmd
		if runtime.GOOS == "windows" {

			if len(cmdArgs) > 0 {
				cmd = exec.Command(cmdStr.Value, cmdArgs...)
			} else {
				cmd = exec.Command("cmd", "/c", cmdStr.Value)
			}
		} else {

			if len(cmdArgs) > 0 {
				cmd = exec.Command(cmdStr.Value, cmdArgs...)
			} else {
				cmd = exec.Command("sh", "-c", cmdStr.Value)
			}
		}

		// Capture output
		var stdout, stderr bytes.Buffer
		cmd.Stdout = &stdout
		cmd.Stderr = &stderr
		cmd.Stdin = nil

		err := cmd.Run()
		output := stdout.String() + stderr.String()

		result := NewOrderedMap()
		result.Set(NewString("output"), NewString(output))

		if err != nil {
			if exitErr, ok := err.(*exec.ExitError); ok {
				result.Set(NewString("success"), FALSE)
				result.Set(NewString("exitCode"), NewInt(int64(exitErr.ExitCode())))
				result.Set(NewString("error"), NewString(err.Error()))
			} else {
				result.Set(NewString("success"), FALSE)
				result.Set(NewString("exitCode"), NewInt(-1))
				result.Set(NewString("error"), NewString(err.Error()))
			}
		} else {
			result.Set(NewString("success"), TRUE)
			result.Set(NewString("exitCode"), NewInt(0))
			result.Set(NewString("error"), NewString(""))
		}

		return result
	},
}

var BuiltinSystemCmdDetached = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 1 {
			return newError("wrong number of arguments for systemCmdDetached. got=%d, want>=1", len(args))
		}

		cmdStr, ok := args[0].(*String)
		if !ok {
			return newError("first argument to 'systemCmdDetached' must be STRING, got %s", args[0].Type())
		}

		// Build command arguments
		var cmdArgs []string
		for i := 1; i < len(args); i++ {
			if arg, ok := args[i].(*String); ok {
				cmdArgs = append(cmdArgs, arg.Value)
			} else {
				return newError("argument %d to 'systemCmdDetached' must be STRING, got %s", i+1, args[i].Type())
			}
		}

		// Create command
		var cmd *exec.Cmd
		if runtime.GOOS == "windows" {
			if len(cmdArgs) > 0 {
				cmd = exec.Command(cmdStr.Value, cmdArgs...)
			} else {
				cmd = exec.Command("cmd", "/c", cmdStr.Value)
			}
		} else {
			if len(cmdArgs) > 0 {
				cmd = exec.Command(cmdStr.Value, cmdArgs...)
			} else {
				cmd = exec.Command("sh", "-c", cmdStr.Value)
			}
		}

		cmd.Stdin = nil
		cmd.Stdout = nil
		cmd.Stderr = nil

		setDetachedAttr(cmd)

		err := cmd.Start()

		result := NewOrderedMap()
		if err != nil {
			result.Set(NewString("success"), FALSE)
			result.Set(NewString("pid"), NewInt(0))
			result.Set(NewString("error"), NewString(err.Error()))
			return result
		}

		pid := 0
		if cmd.Process != nil {
			pid = cmd.Process.Pid
		}

		cmd.Process.Release()

		result.Set(NewString("success"), TRUE)
		result.Set(NewString("pid"), NewInt(int64(pid)))
		result.Set(NewString("error"), NewString(""))

		return result
	},
}

var BuiltinSystemStart = &Builtin{
	Fn: func(args ...Object) Object {
		if len(args) < 1 {
			return newError("wrong number of arguments for systemStart. got=%d, want>=1", len(args))
		}

		pathStr, ok := args[0].(*String)
		if !ok {
			return newError("first argument to 'systemStart' must be STRING, got %s", args[0].Type())
		}

		path := pathStr.Value

		// Optional working directory
		var workingDir string
		if len(args) >= 2 {
			if wd, ok := args[1].(*String); ok {
				workingDir = wd.Value
			}
		}

		var err error

		switch runtime.GOOS {
		case "windows":

			cmd := exec.Command("cmd", "/c", path)
			if workingDir != "" {
				cmd.Dir = workingDir
			}
			cmd.Stdout = nil
			cmd.Stderr = nil

			setDetachedAttr(cmd)

			err := cmd.Start()
			if err != nil {
				result := NewOrderedMap()
				result.Set(NewString("success"), FALSE)
				result.Set(NewString("error"), NewString(err.Error()))
				return result
			}

			if cmd.Process != nil {
				cmd.Process.Release()
			}
			result := NewOrderedMap()
			result.Set(NewString("success"), TRUE)
			result.Set(NewString("error"), NewString(""))
			return result

		case "darwin":

			cmd := exec.Command("open", path)
			if workingDir != "" {
				cmd.Dir = workingDir
			}
			cmd.Stdout = nil
			cmd.Stderr = nil
			err = cmd.Run()

		case "linux":

			cmd := exec.Command("xdg-open", path)
			if workingDir != "" {
				cmd.Dir = workingDir
			}
			cmd.Stdout = nil
			cmd.Stderr = nil
			err = cmd.Run()

		default:
			err = fmt.Errorf("unsupported platform: %s", runtime.GOOS)
		}

		result := NewOrderedMap()
		if err != nil {
			result.Set(NewString("success"), FALSE)
			result.Set(NewString("error"), NewString(err.Error()))
		} else {
			result.Set(NewString("success"), TRUE)
			result.Set(NewString("error"), NewString(""))
		}

		return result
	},
}

var Builtins = map[string]*Builtin{}/* 206 elements not displayed */

var (
	CHARS_EMPTY = &Chars{Value: []rune{}}
)

var EMPTY_ARRAY = &Array{Elements: emptyElements}

var FileUploadBuiltins = map[string]*Builtin{

	"getFileUploads": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for getFileUploads. got=%d, want=1", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("argument to 'getFileUploads' must be HTTP_REQ, got %s", args[0].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			if err := req.Value.ParseMultipartForm(32 << 20); err != nil {

				if strings.Contains(err.Error(), "multipart") {
					return NewMap(make(map[HashKey]MapPair))
				}
				return newError("failed to parse multipart form: %v", err)
			}

			pairs := make(map[HashKey]MapPair)
			for key, fileHeaders := range req.Value.MultipartForm.File {
				k := NewString(key)
				uploads := make([]Object, len(fileHeaders))
				for i, fh := range fileHeaders {
					uploads[i] = NewFileUpload(fh)
				}
				pairs[k.HashKey()] = MapPair{Key: k, Value: NewArray(uploads)}
			}

			return NewMap(pairs)
		},
	},

	"getFileUpload": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for getFileUpload. got=%d, want=2", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("first argument to 'getFileUpload' must be HTTP_REQ, got %s", args[0].Type())
			}

			fieldName, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'getFileUpload' must be STRING, got %s", args[1].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			if err := req.Value.ParseMultipartForm(32 << 20); err != nil {
				return NULL
			}

			file, header, err := req.Value.FormFile(fieldName.Value)
			if err != nil {
				return NULL
			}
			file.Close()

			return NewFileUpload(header)
		},
	},

	"saveFile": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for saveFile. got=%d, want=2", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("first argument to 'saveFile' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			path, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'saveFile' must be STRING, got %s", args[1].Type())
			}

			savedPath, err := file.Save(path.Value)
			if err != nil {
				return NewFileUploadResult(false, err.Error(), "", file.Header.Filename, 0)
			}

			return NewFileUploadResult(true, "File saved successfully", savedPath, file.Header.Filename, file.Header.Size)
		},
	},

	"saveFileToDir": {
		Fn: func(args ...Object) Object {
			if len(args) < 2 || len(args) > 3 {
				return newError("wrong number of arguments for saveFileToDir. got=%d, want=2 or 3", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("first argument to 'saveFileToDir' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			dirPath, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'saveFileToDir' must be STRING, got %s", args[1].Type())
			}

			autoRename := false
			if len(args) == 3 {
				ar, ok := args[2].(*Bool)
				if !ok {
					return newError("third argument to 'saveFileToDir' must be BOOL, got %s", args[2].Type())
				}
				autoRename = ar.Value
			}

			savedPath, err := file.SaveToDir(dirPath.Value, autoRename)
			if err != nil {
				return NewFileUploadResult(false, err.Error(), "", file.Header.Filename, 0)
			}

			return NewFileUploadResult(true, "File saved successfully", savedPath, file.Header.Filename, file.Header.Size)
		},
	},

	"readFile": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for readFile. got=%d, want=1", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("argument to 'readFile' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			content, err := file.ReadAsString()
			if err != nil {
				return newError("failed to read file: %v", err)
			}

			return NewString(content)
		},
	},

	"readFileBytes": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for readFileBytes. got=%d, want=1", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("argument to 'readFileBytes' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			data, err := file.ReadAll()
			if err != nil {
				return newError("failed to read file: %v", err)
			}

			return NewBytesBufferFromBytes(data)
		},
	},

	"fileHashSHA256": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for fileHashSHA256. got=%d, want=1", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("argument to 'fileHashSHA256' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			hash, err := file.HashSHA256()
			if err != nil {
				return newError("failed to calculate hash: %v", err)
			}

			return NewString(hash)
		},
	},

	"isFileUpload": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for isFileUpload. got=%d, want=1", len(args))
			}
			_, ok := args[0].(*FileUpload)
			return &Bool{Value: ok}
		},
	},

	"isFileUploadResult": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for isFileUploadResult. got=%d, want=1", len(args))
			}
			_, ok := args[0].(*FileUploadResult)
			return &Bool{Value: ok}
		},
	},

	"parseMultipartForm": {
		Fn: func(args ...Object) Object {
			if len(args) < 1 || len(args) > 2 {
				return newError("wrong number of arguments for parseMultipartForm. got=%d, want=1 or 2", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("first argument to 'parseMultipartForm' must be HTTP_REQ, got %s", args[0].Type())
			}

			maxMemory := int64(32 << 20)
			if len(args) == 2 {
				m, ok := args[1].(*Int)
				if !ok {
					return newError("second argument to 'parseMultipartForm' must be INT, got %s", args[1].Type())
				}
				maxMemory = m.Value
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			formValues, files, err := ParseMultipartForm(req.Value, maxMemory)
			if err != nil {
				return newError("failed to parse multipart form: %v", err)
			}

			resultPairs := make(map[HashKey]MapPair)

			valuesPairs := make(map[HashKey]MapPair)
			for key, vals := range formValues {
				k := NewString(key)
				var v Object
				if len(vals) == 1 {
					v = NewString(vals[0])
				} else {
					elements := make([]Object, len(vals))
					for i, val := range vals {
						elements[i] = NewString(val)
					}
					v = NewArray(elements)
				}
				valuesPairs[k.HashKey()] = MapPair{Key: k, Value: v}
			}
			resultPairs[NewString("values").HashKey()] = MapPair{
				Key:   NewString("values"),
				Value: NewMap(valuesPairs),
			}

			filesPairs := make(map[HashKey]MapPair)
			for key, uploads := range files {
				k := NewString(key)
				elements := make([]Object, len(uploads))
				for i, upload := range uploads {
					elements[i] = upload
				}
				filesPairs[k.HashKey()] = MapPair{Key: k, Value: NewArray(elements)}
			}
			resultPairs[NewString("files").HashKey()] = MapPair{
				Key:   NewString("files"),
				Value: NewMap(filesPairs),
			}

			return NewMap(resultPairs)
		},
	},

	"safePath": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for safePath. got=%d, want=2", len(args))
			}

			baseDir, ok := args[0].(*String)
			if !ok {
				return newError("first argument to 'safePath' must be STRING, got %s", args[0].Type())
			}

			filename, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'safePath' must be STRING, got %s", args[1].Type())
			}

			safe, err := SafePath(baseDir.Value, filename.Value)
			if err != nil {
				return newError("unsafe path: %v", err)
			}

			return NewString(safe)
		},
	},

	"validateFile": {
		Fn: func(args ...Object) Object {
			if len(args) < 2 {
				return newError("wrong number of arguments for validateFile. got=%d, want at least 2", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("first argument to 'validateFile' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			maxSize, ok := args[1].(*Int)
			if !ok {
				return newError("second argument to 'validateFile' must be INT, got %s", args[1].Type())
			}

			if maxSize.Value > 0 && file.Header.Size > maxSize.Value {
				return &Bool{Value: false}
			}

			if len(args) > 2 {
				ext := strings.ToLower(filepath.Ext(file.Header.Filename))
				allowed := false
				for i := 2; i < len(args); i++ {
					allowedExt, ok := args[i].(*String)
					if !ok {
						continue
					}
					checkExt := strings.ToLower(allowedExt.Value)
					if !strings.HasPrefix(checkExt, ".") {
						checkExt = "." + checkExt
					}
					if checkExt == ext {
						allowed = true
						break
					}
				}
				if !allowed {
					return &Bool{Value: false}
				}
			}

			return &Bool{Value: true}
		},
	},

	"getFileExtension": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for getFileExtension. got=%d, want=1", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("argument to 'getFileExtension' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			return NewString(filepath.Ext(file.Header.Filename))
		},
	},

	"getFileName": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for getFileName. got=%d, want=1", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("argument to 'getFileName' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			name := strings.TrimSuffix(file.Header.Filename, filepath.Ext(file.Header.Filename))
			return NewString(name)
		},
	},

	"getFileSize": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for getFileSize. got=%d, want=1", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("argument to 'getFileSize' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			return NewInt(file.Header.Size)
		},
	},

	"getFileContentType": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for getFileContentType. got=%d, want=1", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("argument to 'getFileContentType' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			return NewString(file.Header.Header.Get("Content-Type"))
		},
	},

	"openFileUpload": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for openFileUpload. got=%d, want=1", len(args))
			}

			file, ok := args[0].(*FileUpload)
			if !ok {
				return newError("argument to 'openFileUpload' must be FILE_UPLOAD, got %s", args[0].Type())
			}

			f, err := file.Header.Open()
			if err != nil {
				return newError("failed to open file: %v", err)
			}
			defer f.Close()

			data, err := io.ReadAll(f)
			if err != nil {
				return newError("failed to read file: %v", err)
			}

			return NewBytesBufferFromBytes(data)
		},
	},

	"saveUploadedFile": {
		Fn: func(args ...Object) Object {
			if len(args) < 3 || len(args) > 4 {
				return newError("wrong number of arguments for saveUploadedFile. got=%d, want=3 or 4", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("first argument to 'saveUploadedFile' must be HTTP_REQ, got %s", args[0].Type())
			}

			fieldName, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'saveUploadedFile' must be STRING, got %s", args[1].Type())
			}

			dirPath, ok := args[2].(*String)
			if !ok {
				return newError("third argument to 'saveUploadedFile' must be STRING, got %s", args[2].Type())
			}

			if req.Value == nil {
				return NewFileUploadResult(false, "http request is nil", "", "", 0)
			}

			maxSize := int64(10 * 1024 * 1024)
			autoRename := true
			var allowedExtensions []string

			if len(args) == 4 {
				opts, ok := args[3].(*Map)
				if !ok {
					return newError("fourth argument to 'saveUploadedFile' must be MAP, got %s", args[3].Type())
				}

				for _, pair := range opts.Pairs {
					keyStr, ok := pair.Key.(*String)
					if !ok {
						continue
					}

					switch keyStr.Value {
					case "maxSize":
						if v, ok := pair.Value.(*Int); ok {
							maxSize = v.Value
						}
					case "autoRename":
						if v, ok := pair.Value.(*Bool); ok {
							autoRename = v.Value
						}
					case "allowedExtensions":
						if arr, ok := pair.Value.(*Array); ok {
							for _, elem := range arr.Elements {
								if s, ok := elem.(*String); ok {
									allowedExtensions = append(allowedExtensions, s.Value)
								}
							}
						}
					}
				}
			}

			if err := req.Value.ParseMultipartForm(maxSize); err != nil {
				return NewFileUploadResult(false, fmt.Sprintf("failed to parse form: %v", err), "", "", 0)
			}

			file, header, err := req.Value.FormFile(fieldName.Value)
			if err != nil {
				return NewFileUploadResult(false, fmt.Sprintf("file not found: %v", err), "", "", 0)
			}
			file.Close()

			upload := NewFileUpload(header)

			if header.Size > maxSize {
				return NewFileUploadResult(false, fmt.Sprintf("file size %d exceeds maximum %d", header.Size, maxSize), "", header.Filename, header.Size)
			}

			if len(allowedExtensions) > 0 {
				ext := strings.ToLower(filepath.Ext(header.Filename))
				allowed := false
				for _, ae := range allowedExtensions {
					checkExt := strings.ToLower(ae)
					if !strings.HasPrefix(checkExt, ".") {
						checkExt = "." + checkExt
					}
					if checkExt == ext {
						allowed = true
						break
					}
				}
				if !allowed {
					return NewFileUploadResult(false, fmt.Sprintf("file extension %s is not allowed", ext), "", header.Filename, header.Size)
				}
			}

			savedPath, err := upload.SaveToDir(dirPath.Value, autoRename)
			if err != nil {
				return NewFileUploadResult(false, err.Error(), "", header.Filename, header.Size)
			}

			return NewFileUploadResult(true, "File saved successfully", savedPath, header.Filename, header.Size)
		},
	},
}

var HttpBuiltins = map[string]*Builtin{

	"writeResp": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for writeResp. got=%d, want=2", len(args))
			}

			resp, ok := args[0].(*HttpResp)
			if !ok {
				return newError("first argument to 'writeResp' must be HTTP_RESP, got %s", args[0].Type())
			}

			var content string
			switch c := args[1].(type) {
			case *String:
				content = c.Value
			default:
				content = c.Inspect()
			}

			if resp.Value == nil {
				return newError("http response is nil")
			}

			_, err := resp.Value.Write([]byte(content))
			if err != nil {
				return newError("write response failed: %v", err)
			}
			resp.SetWritten()

			return NULL
		},
	},

	"setRespHeader": {
		Fn: func(args ...Object) Object {
			if len(args) != 3 {
				return newError("wrong number of arguments for setRespHeader. got=%d, want=3", len(args))
			}

			resp, ok := args[0].(*HttpResp)
			if !ok {
				return newError("first argument to 'setRespHeader' must be HTTP_RESP, got %s", args[0].Type())
			}

			key, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'setRespHeader' must be STRING, got %s", args[1].Type())
			}

			value, ok := args[2].(*String)
			if !ok {
				return newError("third argument to 'setRespHeader' must be STRING, got %s", args[2].Type())
			}

			if resp.Value == nil {
				return newError("http response is nil")
			}

			resp.Value.Header().Set(key.Value, value.Value)
			return NULL
		},
	},

	"addRespHeader": {
		Fn: func(args ...Object) Object {
			if len(args) != 3 {
				return newError("wrong number of arguments for addRespHeader. got=%d, want=3", len(args))
			}

			resp, ok := args[0].(*HttpResp)
			if !ok {
				return newError("first argument to 'addRespHeader' must be HTTP_RESP, got %s", args[0].Type())
			}

			key, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'addRespHeader' must be STRING, got %s", args[1].Type())
			}

			value, ok := args[2].(*String)
			if !ok {
				return newError("third argument to 'addRespHeader' must be STRING, got %s", args[2].Type())
			}

			if resp.Value == nil {
				return newError("http response is nil")
			}

			resp.Value.Header().Add(key.Value, value.Value)
			return NULL
		},
	},

	"getReqHeader": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for getReqHeader. got=%d, want=2", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("first argument to 'getReqHeader' must be HTTP_REQ, got %s", args[0].Type())
			}

			key, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'getReqHeader' must be STRING, got %s", args[1].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			value := req.Value.Header.Get(key.Value)
			return NewString(value)
		},
	},

	"getReqHeaders": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for getReqHeaders. got=%d, want=1", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("argument to 'getReqHeaders' must be HTTP_REQ, got %s", args[0].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			return req.getHeaders()
		},
	},

	"setCookie": {
		Fn: func(args ...Object) Object {
			if len(args) < 3 || len(args) > 4 {
				return newError("wrong number of arguments for setCookie. got=%d, want=3 or 4", len(args))
			}

			resp, ok := args[0].(*HttpResp)
			if !ok {
				return newError("first argument to 'setCookie' must be HTTP_RESP, got %s", args[0].Type())
			}

			name, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'setCookie' must be STRING, got %s", args[1].Type())
			}

			value, ok := args[2].(*String)
			if !ok {
				return newError("third argument to 'setCookie' must be STRING, got %s", args[2].Type())
			}

			if resp.Value == nil {
				return newError("http response is nil")
			}

			cookie := &http.Cookie{
				Name:  name.Value,
				Value: value.Value,
			}

			if len(args) == 4 {
				opts, ok := args[3].(*Map)
				if !ok {
					return newError("fourth argument to 'setCookie' must be MAP, got %s", args[3].Type())
				}

				for _, pair := range opts.Pairs {
					keyStr, ok := pair.Key.(*String)
					if !ok {
						continue
					}

					switch keyStr.Value {
					case "path":
						if v, ok := pair.Value.(*String); ok {
							cookie.Path = v.Value
						}
					case "domain":
						if v, ok := pair.Value.(*String); ok {
							cookie.Domain = v.Value
						}
					case "maxAge":
						if v, ok := pair.Value.(*Int); ok {
							cookie.MaxAge = int(v.Value)
						}
					case "secure":
						if v, ok := pair.Value.(*Bool); ok {
							cookie.Secure = v.Value
						}
					case "httpOnly":
						if v, ok := pair.Value.(*Bool); ok {
							cookie.HttpOnly = v.Value
						}
					case "sameSite":
						if v, ok := pair.Value.(*Int); ok {
							cookie.SameSite = http.SameSite(v.Value)
						}
					case "expires":
						if v, ok := pair.Value.(*String); ok {
							t, err := time.Parse(time.RFC3339, v.Value)
							if err == nil {
								cookie.Expires = t
							}
						}
					}
				}
			}

			http.SetCookie(resp.Value, cookie)
			return NULL
		},
	},

	"getCookie": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for getCookie. got=%d, want=2", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("first argument to 'getCookie' must be HTTP_REQ, got %s", args[0].Type())
			}

			name, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'getCookie' must be STRING, got %s", args[1].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			cookie, err := req.Value.Cookie(name.Value)
			if err != nil {
				return NULL
			}

			return NewString(cookie.Value)
		},
	},

	"getCookies": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for getCookies. got=%d, want=1", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("argument to 'getCookies' must be HTTP_REQ, got %s", args[0].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			pairs := make(map[HashKey]MapPair)
			for _, cookie := range req.Value.Cookies() {
				k := NewString(cookie.Name)
				pairs[k.HashKey()] = MapPair{Key: k, Value: NewString(cookie.Value)}
			}

			return NewMap(pairs)
		},
	},

	"parseForm": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for parseForm. got=%d, want=1", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("argument to 'parseForm' must be HTTP_REQ, got %s", args[0].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			if err := req.Value.ParseForm(); err != nil {
				return newError("parse form failed: %v", err)
			}

			pairs := make(map[HashKey]MapPair)

			for key, values := range req.Value.URL.Query() {
				k := NewString(key)
				var v Object
				if len(values) == 1 {
					v = NewString(values[0])
				} else {
					elements := make([]Object, len(values))
					for i, val := range values {
						elements[i] = NewString(val)
					}
					v = NewArray(elements)
				}
				pairs[k.HashKey()] = MapPair{Key: k, Value: v}
			}

			for key, values := range req.Value.PostForm {
				k := NewString(key)

				if existing, ok := pairs[k.HashKey()]; ok {
					if arr, ok := existing.Value.(*Array); ok {
						elements := arr.Elements
						for _, val := range values {
							elements = append(elements, NewString(val))
						}
						pairs[k.HashKey()] = MapPair{Key: k, Value: NewArray(elements)}
					} else {
						elements := []Object{existing.Value}
						for _, val := range values {
							elements = append(elements, NewString(val))
						}
						pairs[k.HashKey()] = MapPair{Key: k, Value: NewArray(elements)}
					}
				} else {
					var v Object
					if len(values) == 1 {
						v = NewString(values[0])
					} else {
						elements := make([]Object, len(values))
						for i, val := range values {
							elements[i] = NewString(val)
						}
						v = NewArray(elements)
					}
					pairs[k.HashKey()] = MapPair{Key: k, Value: v}
				}
			}

			return NewMap(pairs)
		},
	},

	"status": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for status. got=%d, want=2", len(args))
			}

			resp, ok := args[0].(*HttpResp)
			if !ok {
				return newError("first argument to 'status' must be HTTP_RESP, got %s", args[0].Type())
			}

			code, ok := args[1].(*Int)
			if !ok {
				return newError("second argument to 'status' must be INT, got %s", args[1].Type())
			}

			if resp.Value == nil {
				return newError("http response is nil")
			}

			resp.Value.WriteHeader(int(code.Value))
			return NULL
		},
	},

	"redirect": {
		Fn: func(args ...Object) Object {
			if len(args) < 2 || len(args) > 3 {
				return newError("wrong number of arguments for redirect. got=%d, want=2 or 3", len(args))
			}

			resp, ok := args[0].(*HttpResp)
			if !ok {
				return newError("first argument to 'redirect' must be HTTP_RESP, got %s", args[0].Type())
			}

			url, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'redirect' must be STRING, got %s", args[1].Type())
			}

			code := 302
			if len(args) == 3 {
				c, ok := args[2].(*Int)
				if !ok {
					return newError("third argument to 'redirect' must be INT, got %s", args[2].Type())
				}
				code = int(c.Value)
			}

			if resp.Value == nil {
				return newError("http response is nil")
			}

			http.Redirect(resp.Value, &http.Request{}, url.Value, code)
			resp.SetWritten()
			return NULL
		},
	},

	"serveFile": {
		Fn: func(args ...Object) Object {
			if len(args) != 3 {
				return newError("wrong number of arguments for serveFile. got=%d, want=3", len(args))
			}

			resp, ok := args[0].(*HttpResp)
			if !ok {
				return newError("first argument to 'serveFile' must be HTTP_RESP, got %s", args[0].Type())
			}

			req, ok := args[1].(*HttpReq)
			if !ok {
				return newError("second argument to 'serveFile' must be HTTP_REQ, got %s", args[1].Type())
			}

			path, ok := args[2].(*String)
			if !ok {
				return newError("third argument to 'serveFile' must be STRING, got %s", args[2].Type())
			}

			if resp.Value == nil || req.Value == nil {
				return newError("http response or request is nil")
			}

			http.ServeFile(resp.Value, req.Value, path.Value)
			resp.SetWritten()
			return NULL
		},
	},

	"setContentType": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for setContentType. got=%d, want=2", len(args))
			}

			resp, ok := args[0].(*HttpResp)
			if !ok {
				return newError("first argument to 'setContentType' must be HTTP_RESP, got %s", args[0].Type())
			}

			mimeType, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'setContentType' must be STRING, got %s", args[1].Type())
			}

			if resp.Value == nil {
				return newError("http response is nil")
			}

			resp.Value.Header().Set("Content-Type", mimeType.Value)
			return NULL
		},
	},

	"queryParam": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for queryParam. got=%d, want=2", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("first argument to 'queryParam' must be HTTP_REQ, got %s", args[0].Type())
			}

			name, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'queryParam' must be STRING, got %s", args[1].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			value := req.Value.URL.Query().Get(name.Value)
			return NewString(value)
		},
	},

	"queryParams": {
		Fn: func(args ...Object) Object {
			if len(args) != 1 {
				return newError("wrong number of arguments for queryParams. got=%d, want=1", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("argument to 'queryParams' must be HTTP_REQ, got %s", args[0].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			pairs := make(map[HashKey]MapPair)
			for key, values := range req.Value.URL.Query() {
				k := NewString(key)
				var v Object
				if len(values) == 1 {
					v = NewString(values[0])
				} else {
					elements := make([]Object, len(values))
					for i, val := range values {
						elements[i] = NewString(val)
					}
					v = NewArray(elements)
				}
				pairs[k.HashKey()] = MapPair{Key: k, Value: v}
			}

			return NewMap(pairs)
		},
	},

	"formValue": {
		Fn: func(args ...Object) Object {
			if len(args) != 2 {
				return newError("wrong number of arguments for formValue. got=%d, want=2", len(args))
			}

			req, ok := args[0].(*HttpReq)
			if !ok {
				return newError("first argument to 'formValue' must be HTTP_REQ, got %s", args[0].Type())
			}

			name, ok := args[1].(*String)
			if !ok {
				return newError("second argument to 'formValue' must be STRING, got %s", args[1].Type())
			}

			if req.Value == nil {
				return newError("http request is nil")
			}

			value := req.Value.FormValue(name.Value)
			return NewString(value)
		},
	},
}

var NULL = &Null{}

var TypeMethods = map[ObjectType]map[string]*Builtin{
	IntType:           intMethods,
	FloatType:         floatMethods,
	BigIntType:        bigIntMethods,
	BigFloatType:      bigFloatMethods,
	StringType:        stringMethods,
	CharsType:         charsMethods,
	ArrayType:         arrayMethods,
	MapType:           mapMethods,
	BoolType:          boolMethods,
	NullType:          nullMethods,
	StringBuilderType: stringBuilderMethods,
	BytesType:         bytesMethods,
	BytesBufferType:   bytesBufferMethods,
	WebSocketType:     webSocketMethods,

	MutexType:     mutexMethods,
	RWMutexType:   rwMutexMethods,
	WaitGroupType: waitGroupMethods,
	AtomicIntType: atomicIntMethods,
	TubeType:      tubeMethods,
	OnceType:      onceMethods,
	CondType:      condMethods,
	ContextType:   contextMethods,

	FileUploadType:       fileUploadMethods,
	FileUploadResultType: fileUploadResultMethods,

	FileType:     fileMethods,
	FileInfoType: fileInfoMethods,

	ReaderType:  readerMethods,
	WriterType:  writerMethods,
	ScannerType: scannerMethods,

	OrderedMapType: orderedMapMethods,

	QueueType: queueMethods,
	SetType:   setMethods,

	XLSXType: xlsxMethods,

	PPTXDocumentType:  pptxDocumentMethods,
	PPTXSlideType:     pptxSlideMethods,
	PPTXTextFrameType: pptxTextFrameMethods,
	PPTXTextRunType:   pptxTextRunMethods,
	PPTXShapeType:     pptxShapeMethods,
	PPTXTableType:     pptxTableMethods,
	PPTXChartType:     pptxChartMethods,
	PPTXImageType:     pptxImageMethods,

	XMLDocumentType: xmlDocumentMethods,
	XMLNodeType:     xmlNodeMethods,

	SocketAddrType: socketAddrMethods,
	TcpServerType:  tcpServerMethods,
	TcpClientType:  tcpClientMethods,
	UdpSocketType:  udpSocketMethods,

	LineEditorType: lineEditorMethods,

	SSHClientType: sshClientMethods,

	FtpClientType:  ftpClientMethods,
	FtpServerType:  ftpServerMethods,
	SftpClientType: sftpClientMethods,
	SftpServerType: sftpServerMethods,

	HTMLDocumentType: htmlDocumentMethods,
	HTMLElementType:  htmlElementMethods,

	TomlDocumentType: tomlDocumentMethods,

	TimeType: timeMethods,
}