// 檢查數(shù)據(jù)庫(kù)基礎(chǔ)狀態(tài)
func checkBasicStatus(db *sql.DB) BasicStatus {
    var status BasicStatus
    
    // 獲取運(yùn)行時(shí)間
    err := db.QueryRow("SHOW STATUS LIKE 'Uptime'").Scan(&status.UptimeKey, &status.UptimeValue)
    if err != nil {
        log.Printf("獲取運(yùn)行時(shí)間失敗: %v", err)
    }
    
    // 獲取版本和字符集
    err = db.QueryRow("SELECT version(), @@character_set_server").Scan(&status.Version, &status.Charset)
    if err != nil {
        log.Printf("獲取版本信息失敗: %v", err)
    }
    
    return status
}

// 檢查性能指標(biāo)
func checkPerformanceMetrics(db *sql.DB) PerformanceMetrics {
    var metrics PerformanceMetrics
    
    // 檢查慢查詢
    err := db.QueryRow("SELECT COUNT(*) FROM mysql.slow_log WHERE start_time > NOW() - INTERVAL 1 HOUR").
        Scan(&metrics.SlowQueryCount)
    if err != nil {
        log.Printf("檢查慢查詢失敗: %v", err)
    }
    
    // 檢查臨時(shí)表使用情況
    err = db.QueryRow("SHOW STATUS LIKE 'Created_tmp%'").Scan(&metrics.TmpTableStatus)
    if err != nil {
        log.Printf("檢查臨時(shí)表失敗: %v", err)
    }
    
    return metrics
}

// 健康檢查管理器
type HealthChecker struct {
    db         *sql.DB
    config     Config
    results    map[string]interface{}
    reportFile string
}

// 初始化健康檢查器
func NewHealthChecker(dsn, reportFile string) (*HealthChecker, error) {
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        return nil, fmt.Errorf("數(shù)據(jù)庫(kù)連接失敗: %v", err)
    }
    
    return &HealthChecker{
        db:         db,
        reportFile: reportFile,
        results:    make(map[string]interface{}),
    }, nil
}

// 檢查存儲(chǔ)空間使用情況
func (hc *HealthChecker) CheckStorage() error {
    fmt.Println("\n?? 存儲(chǔ)空間檢查")
    fmt.Println("--------------------------------------------------")
    
    // 查詢數(shù)據(jù)庫(kù)大小
    query := `
        SELECT table_schema, 
               ROUND(SUM(data_length + index_length) / 1024 / 1024, 2) as size_mb,
               COUNT(*) as table_count
        FROM information_schema.TABLES 
        GROUP BY table_schema
        ORDER BY size_mb DESC`
    
    rows, err := hc.db.Query(query)
    if err != nil {
        return fmt.Errorf("查詢數(shù)據(jù)庫(kù)大小失敗: %v", err)
    }
    defer rows.Close()
    
    var totalSize float64
    var dbSizes []DatabaseSize
    
    for rows.Next() {
        var dbName string
        var sizeMB float64
        var tableCount int
        
        err := rows.Scan(&dbName, &sizeMB, &tableCount)
        if err != nil {
            log.Printf("掃描數(shù)據(jù)庫(kù)大小結(jié)果失敗: %v", err)
            continue
        }
        
        totalSize += sizeMB
        dbSizes = append(dbSizes, DatabaseSize{
            Name:       dbName,
            SizeMB:     sizeMB,
            TableCount: tableCount,
        })
        
        fmt.Printf("  %s: %.2f MB (%d張表)\n", dbName, sizeMB, tableCount)
    }
    
    hc.results["database_sizes"] = dbSizes
    hc.results["total_size"] = totalSize
    
    fmt.Printf("  總數(shù)據(jù)庫(kù)大小: %.2f MB\n", totalSize)
    
    return nil
}

// 檢查性能相關(guān)指標(biāo)
func (hc *HealthChecker) CheckPerformance() error {
    fmt.Println("\n?? 性能指標(biāo)檢查")
    fmt.Println("--------------------------------------------------")
    
    // 檢查緩沖池命中率
    hitRateQuery := `
        SELECT ROUND(
            (1 - 
            (SELECT VARIABLE_VALUE FROM information_schema.GLOBAL_STATUS 
             WHERE VARIABLE_NAME = 'Innodb_buffer_pool_reads') / 
            (SELECT VARIABLE_VALUE FROM information_schema.GLOBAL_STATUS 
             WHERE VARIABLE_NAME = 'Innodb_buffer_pool_read_requests')
            ) * 100, 2
        ) as hit_rate`
    
    var hitRate float64
    err := hc.db.QueryRow(hitRateQuery).Scan(&hitRate)
    if err != nil {
        return fmt.Errorf("查詢緩沖池命中率失敗: %v", err)
    }
    
    status := "正常"
    if hitRate < 95 {
        status = "警告"
    }
    
    fmt.Printf("  InnoDB緩沖池命中率: %.2f%% [%s]\n", hitRate, status)
    hc.results["buffer_pool_hit_rate"] = hitRate
    
    // 檢查慢查詢
    var slowQueryCount int
    err = hc.db.QueryRow("SELECT COUNT(*) FROM mysql.slow_log WHERE start_time > DATE_SUB(NOW(), INTERVAL 1 HOUR)").
        Scan(&slowQueryCount)
    if err != nil {
        // 可能是慢查詢表不存在，記錄但不中斷檢查
        log.Printf("檢查慢查詢失敗: %v", err)
    } else {
        fmt.Printf("  近1小時(shí)慢查詢數(shù)量: %d\n", slowQueryCount)
        hc.results["slow_queries_last_hour"] = slowQueryCount
    }
    
    return nil
}

// 生成健康檢查報(bào)告
func (hc *HealthChecker) GenerateReport() error {
    file, err := os.Create(hc.reportFile)
    if err != nil {
        return fmt.Errorf("創(chuàng)建報(bào)告文件失敗: %v", err)
    }
    defer file.Close()
    
    // 寫入報(bào)告頭部
    hc.writeReportHeader(file)
    
    // 寫入各項(xiàng)檢查結(jié)果
    hc.writeBasicStatus(file)
    hc.writeStorageInfo(file)
    hc.writePerformanceInfo(file)
    hc.writeSecurityInfo(file)
    
    fmt.Printf("健康檢查報(bào)告已生成: %s\n", hc.reportFile)
    return nil
}

// 寫入存儲(chǔ)空間信息到報(bào)告
func (hc *HealthChecker) writeStorageInfo(file *os.File) {
    fmt.Fprintln(file, "\n## 存儲(chǔ)空間檢查結(jié)果")
    
    if totalSize, ok := hc.results["total_size"].(float64); ok {
        fmt.Fprintf(file, "總數(shù)據(jù)庫(kù)大小: %.2f MB\n", totalSize)
    }
    
    if dbSizes, ok := hc.results["database_sizes"].([]DatabaseSize); ok {
        for _, db := range dbSizes {
            fmt.Fprintf(file, "%s: %.2f MB (%d張表)\n", db.Name, db.SizeMB, db.TableCount)
        }
    }
}

// 檢查主從復(fù)制狀態(tài)
func (hc *HealthChecker) CheckReplication() error {
    if !hc.config.CheckReplication {
        return nil
    }
    
    fmt.Println("\n?? 復(fù)制狀態(tài)檢查")
    fmt.Println("--------------------------------------------------")
    
    var (
        slaveIORunning  string
        slaveSQLRunning string
        secondsBehind   sql.NullInt64
    )
    
    err := hc.db.QueryRow(`
        SELECT Slave_IO_Running, Slave_SQL_Running, Seconds_Behind_Master 
        FROM information_schema.PROCESSLIST 
        WHERE COMMAND = 'Binlog Dump'`).
        Scan(&slaveIORunning, &slaveSQLRunning, &secondsBehind)
    
    if err == sql.ErrNoRows {
        fmt.Println("  未配置主從復(fù)制")
        return nil
    }
    
    if err != nil {
        return fmt.Errorf("檢查復(fù)制狀態(tài)失敗: %v", err)
    }
    
    status := "正常"
    if slaveIORunning != "Yes" || slaveSQLRunning != "Yes" {
        status = "異常"
    }
    
    fmt.Printf("  I/O線程狀態(tài): %s, SQL線程狀態(tài): %s, 延遲: %v秒 [%s]\n",
        slaveIORunning, slaveSQLRunning, secondsBehind.Int64, status)
    
    hc.results["replication_status"] = map[string]interface{}{
        "io_running": slaveIORunning,
        "sql_running": slaveSQLRunning,
        "seconds_behind": secondsBehind,
    }
    
    return nil
}

// 檢查備份狀態(tài)
func (hc *HealthChecker) CheckBackup() error {
    fmt.Println("\n?? 備份狀態(tài)檢查")
    fmt.Println("--------------------------------------------------")
    
    // 檢查最近備份時(shí)間
    var lastBackupTime string
    err := hc.db.QueryRow(`
        SELECT MAX(create_time) 
        FROM information_schema.TABLES 
        WHERE table_schema = 'backup' AND table_name LIKE '%backup%'`).
        Scan(&lastBackupTime)
    
    if err != nil && err != sql.ErrNoRows {
        log.Printf("檢查備份時(shí)間失敗: %v", err)
    } else if lastBackupTime != "" {
        fmt.Printf("  最近備份時(shí)間: %s\n", lastBackupTime)
        hc.results["last_backup_time"] = lastBackupTime
    } else {
        fmt.Println("  未找到備份記錄")
        hc.results["last_backup_time"] = "無(wú)記錄"
    }
    
    return nil
}