package gmysql

import (
    "fmt"
    "log"
    "net/url"
    "os"
    "time"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "gorm.io/gorm/logger"
)

var db *gorm.DB

// New initializes a new database connection.
func New(dsn string) *gorm.DB {
    if dsn == "" {
        // 默认的数据库连接字符串
        dsn = "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local&multiStatements=true"
    }
    db = initDB(dsn)
    return db
}

// initDB initializes and returns a *gorm.DB instance with the given DSN.
func initDB(dsn string) *gorm.DB {
    if dsn == "" {
        panic("dsn must not be empty")
    }
    // 解析 DSN
    parsedDSN, err := url.Parse(dsn)
    if err != nil {
        panic("无效的DSN格式: " + err.Error())
    }
    // 如果用户名和密码存在
    if parsedDSN.User != nil {
        // 获取密码部分
        password, _ := parsedDSN.User.Password()

        // 对密码进行 URL 编码
        encodedPassword := url.QueryEscape(password)

        // 更新连接字符串中的密码
        parsedDSN.User = url.UserPassword(parsedDSN.User.Username(), encodedPassword)
    }

    // 使用编码后的 DSN 生成数据库连接
    mysqldb := mysql.New(mysql.Config{
        DSN:               parsedDSN.String(),
        DefaultStringSize: 256,
    })

    // 打开数据库连接
    db, err := gorm.Open(mysqldb, &gorm.Config{
        Logger: logger.New(
            log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
            logger.Config{
                SlowThreshold: time.Second,   // 慢 SQL 阈值
                LogLevel:      logger.Silent, // Log level
            },
        ),
    })
    if err != nil {
        panic("mysql connect error: " + err.Error())
    }

    // 设置连接池参数
    setupDBConnectionPool(db)

    return db
}

// setupDBConnectionPool sets the connection pool parameters for the database.
func setupDBConnectionPool(db *gorm.DB) {
    rawDb, err := db.DB()
    if err != nil {
        panic("failed to get raw DB connection: " + err.Error())
    }

    rawDb.SetMaxIdleConns(10)
    rawDb.SetMaxOpenConns(200)
    rawDb.SetConnMaxLifetime(3 * time.Minute)
}

// Close closes the database connection.
func Close(db *gorm.DB) {
    if db != nil {
        rawDb, err := db.DB()
        if err != nil {
            log.Printf("failed to get raw DB connection: %v", err)
            return
        }
        if err := rawDb.Close(); err != nil {
            log.Printf("failed to close DB connection: %v", err)
        }
    }
}

func main() {
    db := New("root:CuJia@567@tcp(192.168.4.54:3306)/k8s?charset=utf8mb4&parseTime=True&loc=Local&multiStatements=true&timeout=5s")

    // 原生sql
    // 增加
    result := db.Exec("INSERT INTO users (name, age) VALUES (?, ?)", "John Doe", 30)
    if result.Error != nil {
        log.Fatalf("Insert failed: %v", result.Error)
    } else {
        fmt.Println("Insert successful!")
    }

    // 删除
    result = db.Exec("DELETE FROM users WHERE name = ?", "John Doe")
    if result.Error != nil {
        log.Fatalf("Delete failed: %v", result.Error)
    } else {
        fmt.Println("Delete successful!")
    }

    // 执行原生 SQL 更新操作
    result = db.Exec("UPDATE users SET age = ? WHERE name = ?", 31, "John Doe")
    if result.Error != nil {
        log.Fatalf("Update failed: %v", result.Error)
    } else {
        fmt.Println("Update successful!")

        // 查询操作
        type User struct {
            ID   uint
            Name string
            Age  int
        }
        var users []User
        // 执行原生 SQL 查询并将结果扫描到 users 切片
        err := db.Raw("SELECT id, name, age FROM users WHERE age > ?", 18).Scan(&users).Error
        if err != nil {
            log.Fatalf("Query failed: %v", err)
        }

        for _, user := range users {
            fmt.Printf("User: %+v\n", user)
        }
        Close(db)
    }
}