#ifndef QFAULTTOLERANCE_H
#define QFAULTTOLERANCE_H

#include <QObject>
#include <QTimer>
#include <QElapsedTimer>
#include <QDateTime>
#include <QMutex>
#include <QMap>
#include <QList>
#include "BZStruct.h"

// 连接状态
enum class ConnectionState {
    Disconnected,
    Connecting,
    Connected,
    Degraded,
    Failed
};

// 心跳配置
struct HeartbeatConfig {
    int intervalMs = 30000;          // 心跳间隔（毫秒）
    int timeoutMs = 60000;           // 心跳超时时间
    int maxMissedHeartbeats = 3;     // 最大丢失心跳数
    bool enabled = true;
};

// 重连配置
struct ReconnectConfig {
    int initialDelayMs = 1000;       // 初始重连延迟
    int maxDelayMs = 60000;          // 最大重连延迟
    int maxAttempts = 10;            // 最大重连尝试次数
    bool exponentialBackoff = true;  // 是否使用指数退避
    bool enabled = true;
};

// 故障转移配置
struct FailoverConfig {
    QList<QString> backupServers;    // 备用服务器列表
    int switchTimeoutMs = 5000;      // 切换超时时间
    bool autoSwitch = true;          // 自动切换
    bool enableLoadBalancing = false; // 启用负载均衡
};

// 连接统计
struct ConnectionStats {
    ConnectionState state = ConnectionState::Disconnected;
    int totalConnections = 0;
    int successfulConnections = 0;
    int failedConnections = 0;
    int totalReconnects = 0;
    qint64 totalUptimeMs = 0;
    qint64 currentUptimeMs = 0;
    QDateTime lastConnectionTime;
    QDateTime lastDisconnectionTime;
    
    void updateState(ConnectionState newState) {
        state = newState;
        if (newState == ConnectionState::Connected) {
            lastConnectionTime = QDateTime::currentDateTime();
            totalConnections++;
            successfulConnections++;
        } else if (newState == ConnectionState::Failed) {
            lastDisconnectionTime = QDateTime::currentDateTime();
            failedConnections++;
        }
    }
};

class QFaultTolerance : public QObject
{
    Q_OBJECT
public:
    static QFaultTolerance* instance();
    
    // 配置管理
    void setHeartbeatConfig(const HeartbeatConfig& config);
    void setReconnectConfig(const ReconnectConfig& config);
    void setFailoverConfig(const FailoverConfig& config);
    
    HeartbeatConfig getHeartbeatConfig() const;
    ReconnectConfig getReconnectConfig() const;
    FailoverConfig getFailoverConfig() const;
    
    // 连接管理
    void registerConnection(const QString& connectionId, const QString& serverAddress);
    void unregisterConnection(const QString& connectionId);
    void updateConnectionState(const QString& connectionId, ConnectionState state);
    ConnectionState getConnectionState(const QString& connectionId) const;
    
    // 心跳管理
    void startHeartbeat(const QString& connectionId);
    void stopHeartbeat(const QString& connectionId);
    void heartbeatReceived(const QString& connectionId);
    
    // 重连管理
    void initiateReconnect(const QString& connectionId);
    void cancelReconnect(const QString& connectionId);
    
    // 故障转移
    void initiateFailover(const QString& failedConnectionId);
    QString getNextServer(const QString& connectionId) const;
    
    // 状态查询
    ConnectionStats getConnectionStats(const QString& connectionId) const;
    QMap<QString, ConnectionStats> getAllConnectionStats() const;
    bool isSystemHealthy() const;
    
    // 系统控制
    void enableFaultTolerance(bool enabled);
    void resetStatistics();

signals:
    void connectionStateChanged(const QString& connectionId, ConnectionState state);
    void heartbeatTimeout(const QString& connectionId);
    void reconnectAttempt(const QString& connectionId, int attempt, int delayMs);
    void reconnectSuccess(const QString& connectionId);
    void reconnectFailed(const QString& connectionId);
    void failoverInitiated(const QString& fromConnectionId, const QString& toServer);
    void systemHealthChanged(bool healthy);

private:
    explicit QFaultTolerance(QObject *parent = nullptr);
    ~QFaultTolerance();
    
    void checkHeartbeats();
    void attemptReconnect(const QString& connectionId);
    void updateSystemHealth();
    
    // 连接信息
    struct ConnectionInfo {
        QString serverAddress;
        ConnectionState state = ConnectionState::Disconnected;
        ConnectionStats stats;
        HeartbeatConfig heartbeatConfig;
        ReconnectConfig reconnectConfig;
        
        // 心跳相关
        QElapsedTimer lastHeartbeatTimer;
        int missedHeartbeats = 0;
        bool heartbeatEnabled = false;
        
        // 重连相关
        int reconnectAttempts = 0;
        int currentReconnectDelay = 0;
        QTimer* reconnectTimer = nullptr;
        
        ConnectionInfo() = default;
        ConnectionInfo(const QString& server) : serverAddress(server) {}
    };
    
    mutable QMutex m_mutex;
    QMap<QString, ConnectionInfo> m_connections;
    
    // 配置
    HeartbeatConfig m_heartbeatConfig;
    ReconnectConfig m_reconnectConfig;
    FailoverConfig m_failoverConfig;
    bool m_faultToleranceEnabled = true;
    
    // 定时器
    QTimer* m_heartbeatCheckTimer;
    QTimer* m_healthCheckTimer;
    
    // 系统状态
    bool m_systemHealthy = true;
};

#endif // QFAULTTOLERANCE_H