#include "RelayController.h"
#include <WiFi.h>
#include <time.h>

// 构造函数
RelayController::RelayController(int pin22, int pin23, int pin4) 
    : _relayPin22(pin22), 
      _relayPin23(pin23),
      _relayPin4(pin4),
      _relay22State(HIGH_Z),
      _relay23State(HIGH_Z),
      _relay4State(HIGH_Z),
      _relay22TimeoutCheck(false),
      _relay22TempHold(false),  // 初始化为未触发
      _relay4LastOnCycle(0),
      _powerOnTime(0),
      _simulatedUnixTime(0)
{}

// 初始化
void RelayController::begin() {
    // 所有继电器初始化为高阻态
    pinMode(_relayPin22, INPUT);
    pinMode(_relayPin23, INPUT);
    pinMode(_relayPin4, INPUT);
    
    _powerOnTime = millis();
    _simulatedUnixTime = 0;
    
    Serial.println("继电器初始化完成，所有继电器默认高阻态");
}

// GPIO22控制方法
void RelayController::setRelay22HighZ() {
    if (_relay22State != HIGH_Z) {
        pinMode(_relayPin22, INPUT);
        _relay22State = HIGH_Z;
        _relay22TimeoutCheck = false;
        _relay22TempHold = false;  // 重置温度保持标记
        Serial.println("GPIO22继电器已设为高阻态");
    }
}

void RelayController::turnOnRelay22(float currentGpio6Temp) {
    if (_relay22State != ON) {
        pinMode(_relayPin22, OUTPUT);
        digitalWrite(_relayPin22, HIGH);
        _relay22State = ON;
        
        _relay22StartTime = millis();
        _gpio6TempAtRelay22On = currentGpio6Temp;
        _relay22TimeoutCheck = true;
        Serial.println("GPIO22继电器已打开（高电平）");
    }
}

// GPIO23控制方法
void RelayController::setRelay23HighZ() {
    if (_relay23State != HIGH_Z) {
        pinMode(_relayPin23, INPUT);
        _relay23State = HIGH_Z;
        Serial.println("GPIO23继电器已设为高阻态");
    }
}

void RelayController::turnOnRelay23() {
    if (_relay23State != ON) {
        pinMode(_relayPin23, OUTPUT);
        digitalWrite(_relayPin23, HIGH);
        _relay23State = ON;
        Serial.println("GPIO23继电器已打开（高电平）");
    }
}

// GPIO4定时继电器控制方法
void RelayController::setRelay4HighZ() {
    if (_relay4State != HIGH_Z) {
        pinMode(_relayPin4, INPUT);
        _relay4State = HIGH_Z;
        Serial.println("GPIO4定时继电器已设为高阻态");
    }
}

void RelayController::turnOnRelay4() {
    if (_relay4State != ON) {
        pinMode(_relayPin4, OUTPUT);
        digitalWrite(_relayPin4, HIGH);
        _relay4State = ON;
        _relay4OnTime = millis();
        Serial.println("GPIO4定时继电器已打开（高电平）");
    }
}

// 主控制逻辑（包含温度滞后控制）
void RelayController::controlByTempConditions(float tempGpio2, float tempGpio3, float tempGpio6,
                                            float diffThreshold, float gpio6High, float gpio6Low,
                                            float highTempOn, float highTempOff) {
    float diff = tempGpio2 - tempGpio3;
    Serial.print("温度差 (GPIO2 - GPIO3): ");
    Serial.print(diff);
    Serial.print(" °C, GPIO6温度: ");
    Serial.print(tempGpio6);
    Serial.println(" °C");
    
    // 新增：高温控制逻辑（带滞后）
    // 当温度高于35℃时打开继电器并标记保持状态
    if (tempGpio6 > highTempOn) {
        turnOnRelay22(tempGpio6);
        _relay22TempHold = true;  // 标记为需要滞后关闭
    }
    // 当温度低于25℃且已触发保持状态时，才关闭继电器
    else if (tempGpio6 < highTempOff && _relay22TempHold) {
        setRelay22HighZ();
        _relay22TempHold = false;  // 重置保持状态
    }
    // 原有温度差控制逻辑（仅在未触发高温保持时生效）
    else if (!_relay22TempHold) {
        // 控制GPIO22：原有条件
        if (diff < -diffThreshold && tempGpio6 > gpio6High) {
            turnOnRelay22(tempGpio6);
        } else {
            setRelay22HighZ();
        }
    }
    
    // GPIO23控制逻辑（保持不变）
    if (diff > diffThreshold && tempGpio6 < gpio6Low) {
        turnOnRelay23();
    } else {
        setRelay23HighZ();
    }
}

// 定时任务处理（保持不变）
void RelayController::handleTimedTasks(float currentGpio6Temp) {
    unsigned long currentTime = millis();
    
    // 1. GPIO22超时检测
    if (_relay22TimeoutCheck && _relay22State == ON) {
        if (currentTime - _relay22StartTime >= 15 * 60 * 1000) {  // 15分钟
            float tempIncrease = currentGpio6Temp - _gpio6TempAtRelay22On;
            
            if (tempIncrease < 5.0) {
                setRelay22HighZ();
                Serial.println("警告：加热没有成功！15分钟内温度未上升5度");
            } else {
                _relay22TimeoutCheck = false;
                Serial.println("加热成功，温度上升达标");
            }
        }
    }
    
    // 2. 定时继电器GPIO4控制
    unsigned long currentCycle = get24hCycleCount();
    int currentHour = getCurrentHour();
    
    if (currentHour == _dailyOnHour && currentCycle != _relay4LastOnCycle) {
        turnOnRelay4();
        _relay4LastOnCycle = currentCycle;
    }
    
    if (_relay4State == ON && (currentTime - _relay4OnTime) >= _onDuration) {
        setRelay4HighZ();
    }
}

// 时间管理方法（保持不变）
void RelayController::updateNtpTime() {
    if (WiFi.status() == WL_CONNECTED) {
        configTime(8 * 3600, 0, "pool.ntp.org", "time.nist.gov");
        time_t now;
        time(&now);
        
        if (now > 1609459200) {
            _simulatedUnixTime = now - ((millis() - _powerOnTime) / 1000);
            Serial.println("NTP时间同步成功，校准模拟时间");
        }
    }
}

unsigned long RelayController::getCurrentUnixTime() {
    return _simulatedUnixTime + ((millis() - _powerOnTime) / 1000);
}

int RelayController::getCurrentHour() {
    unsigned long secondsSincePowerOn = (millis() - _powerOnTime) / 1000;
    return (secondsSincePowerOn / 3600) % 24;
}

unsigned long RelayController::get24hCycleCount() {
    unsigned long secondsSincePowerOn = (millis() - _powerOnTime) / 1000;
    return secondsSincePowerOn / (24 * 3600);
}

unsigned long RelayController::getPowerOnTime() {
    return _powerOnTime;
}

// 获取状态字符串
String RelayController::getRelay22State() {
    return (_relay22State == ON) ? "打开（高电平）" : "高阻态";
}

String RelayController::getRelay23State() {
    return (_relay23State == ON) ? "打开（高电平）" : "高阻态";
}

String RelayController::getRelay4State() {
    return (_relay4State == ON) ? "打开（高电平）" : "高阻态";
}