import socket
import time
from machine import reset, Pin, Timer  # 添加 Timer
import _thread
import gc
import network

import system
import shared_vars
from ConfigManager import ConfigManager

gc.enable()

# 初始化配置管理器
config_manager = ConfigManager()

# 看门狗变量
watchdog_last_reset = time.time()

def reset_watchdog():
    """重置看门狗计时"""
    global watchdog_last_reset
    watchdog_last_reset = time.time()

def watchdog_thread():
    """看门狗线程，超过 1 分钟未重置则重启设备"""
    global watchdog_last_reset
    while True:
        if time.time() - watchdog_last_reset > 60:  # 超过 1 分钟
            print("看门狗超时，设备即将重启...")
            reset()
        time.sleep(1)

# 启动看门狗线程
_thread.start_new_thread(watchdog_thread, ())

def connect_to_stored_wifi():
    """
    尝试连接存储的 WiFi 列表，如果全部失败，则连接默认 WiFi
    """
    # 获取存储的 WiFi 列表
    wifi_list = config_manager.get("wifi.list", [])
    print("尝试连接存储的 WiFi 列表:", wifi_list)

    wlan = None
    for wifi in wifi_list:
        ssid = wifi.get("ssid")
        password = wifi.get("password")
        if not ssid or password is None:  # 只检查 SSID 是否有效
            continue

        print(f"尝试连接 WiFi: {ssid}")
        try:
            wlan = network.WLAN(network.STA_IF)
            wlan.active(False)
            wlan.active(True)
            wlan.connect(ssid, password)

            # 设置超时时间为 10 秒
            start_time = time.time()
            while not wlan.isconnected():
                if time.time() - start_time > 10:  # 超时 10 秒
                    print(f"连接 WiFi {ssid} 超时，尝试下一个")
                    break
                time.sleep(1)

            if wlan.isconnected():
                print(f"成功连接到 WiFi: {ssid}")
                
                # 将成功连接的 WiFi 移到列表最前面
                wifi_list.remove(wifi)
                wifi_list.insert(0, wifi)
                config_manager.set("wifi.list", wifi_list)
                reset_watchdog()  # 重置看门狗
                return wlan
        except Exception as e:
            print(f"连接 WiFi {ssid} 失败: {e}")
    wlan.active(False)
    # 如果所有存储的 WiFi 都连接失败，则连接默认 WiFi
    print("所有存储的 WiFi 都连接失败，尝试连接默认 WiFi")
    wlan = system.connect_wifi(shared_vars.WIFI_SSID, shared_vars.WIFI_PASSWORD)
    reset_watchdog()  # 重置看门狗
    return wlan

# 启动接收数据的线程
_thread.start_new_thread(system.websocket_receive_thread, ())

def ws_client():
    try:
        # 尝试连接 WiFi
        sta_if = connect_to_stored_wifi()
        print(f"连接到 WebSocket 服务器 {shared_vars.WS_HOST}:{shared_vars.WS_PORT}...")
        shared_vars.WS_SOCK = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        shared_vars.WS_SOCK.connect((shared_vars.WS_HOST, shared_vars.WS_PORT))
        print("连接成功")
        # 进行 WebSocket 握手
        system.websocket_handshake()
        while True:
            time.sleep(30)
            system.send_text(shared_vars.WS_SOCK, '{"action":"sys.ping"}')
            reset_watchdog()  # 重置看门狗
        
    except OSError as e:
        print(f"连接异常: {str(e)}")
        if 'sta_if' in locals():
            sta_if.active(False)
        time.sleep(5)
        reset()
    except Exception as e:
        print(f"发生错误:", e)
        shared_vars.WS_SOCK.close()
        time.sleep(5)
        reset()

if __name__ == "__main__":
    # 运行主函数
    ws_client()
else:
    # 作为模块导入时的处理逻辑
    pass