"""主程序入口"""
import time
import threading
from API.client import APIClient
from API.mix_weight_api import MixWeightAPI
from services.task_service import TaskService
from services.monitoring_service import MonitoringService
from database.access_db import AccessDB
from database.sql_server import SQLServerDB
from tcp.server import TCPServer
from opc.client import OPCClient
from config.settings import (
    ACCESS_DB_PATH, ACCESS_DB_PASSWORD,
    TCP_HOST, TCP_PORT, TCP_CLIENT_HOST, TCP_CLIENT_PORT,
    CHECK_INTERVAL, MAX_AGE_HOURS
)
from utils.helpers import cleanup_old_timestamps




def start_api_service():
    """启动配比重量API服务"""
    api = MixWeightAPI()
    api.run(host='127.0.0.1', port=5001, debug=False, threaded=True)


def main():
    global tcp_server, data_client
    api_thread = threading.Thread(target=start_api_service)
    api_thread.daemon = True
    api_thread.start()
    try:
        # 初始化TCP服务端
        tcp_server = TCPServer(host=TCP_HOST, port=TCP_PORT)
        tcp_server_thread = threading.Thread(target=tcp_server.start)
        tcp_server_thread.daemon = True
        tcp_server_thread.start()

        # 初始化发送数据的OPC客户端
        data_client = OPCClient(url=f'opc.tcp://{TCP_CLIENT_HOST}:{TCP_CLIENT_PORT}')
        data_client.start()

        # 等待服务端启动
        time.sleep(1)

        # 初始化服务
        api_client = APIClient()
        task_service = TaskService(tcp_server)
        monitoring_service = MonitoringService(tcp_server)

        # 步骤1：获取AppID
        app_id = api_client.login()
        if app_id is None:
            print("无法获取AppID，将在稍后重试...")
        else:
            task_service.api_client.app_id = app_id

        # 存储上次获取的所有ArtifactID
        last_artifact_ids = set()
        last_artifact_list = []  # 用于存储上一次的完整artifact_list

        # 启动Access数据库Flag监控线程
        access_monitor_thread = threading.Thread(target=monitoring_service.monitor_access_flag_changes)
        access_monitor_thread.daemon = True
        access_monitor_thread.start()

        while True:
            try:
                # 如果没有有效的app_id，尝试重新登录
                if task_service.api_client.app_id is None:
                    print("尝试重新登录获取AppID...")
                    app_id = api_client.login()
                    if app_id is not None:
                        task_service.api_client.app_id = app_id
                        print("重新登录成功")
                    else:
                        print("重新登录失败，稍后重试...")
                        time.sleep(10)  # 等待10秒再重试
                        continue

                # 获取所有未浇筑信息
                tasks, artifact_list, send_list, half_volume = task_service.process_not_pour_info()

                # 如果API调用失败，等待一段时间再重试
                if tasks is None or artifact_list is None:
                    print("获取未浇筑信息失败，稍后重试...")
                    time.sleep(10)
                    continue

                current_artifact_ids = {task["artifact_id"] for task in tasks}

                # 检查artifact_list是否发生变化
                if artifact_list != last_artifact_list:
                    print(f"检测到artifact_list更新: {artifact_list}")

                    # 处理新出现的任务
                    new_artifact_ids = current_artifact_ids - last_artifact_ids
                    if new_artifact_ids:
                        print(f"检测到 {len(new_artifact_ids)} 个新任务")

                        for task in tasks:
                            if task["artifact_id"] in new_artifact_ids:
                                task_info = api_client.get_task_info(task["beton_task_id"])

                                # 如果获取任务信息失败，跳过该任务
                                if task_info is None:
                                    print(f"无法获取任务信息，跳过任务: {task['artifact_id']}")
                                    continue

                                # 连接Access数据库并获取最大Mark值
                                access_db = AccessDB(ACCESS_DB_PATH, ACCESS_DB_PASSWORD)
                                try:
                                    max_mark = access_db.get_max_mark()
                                finally:
                                    access_db.close()

                                erp_id = int(max_mark) + 1

                                # 连接SQL Server数据库并插入数据
                                sql_db = SQLServerDB()
                                try:
                                    # 检查 block_number 是否为 "补方"
                                    if task["block_number"] == "补方":
                                        print(f"任务 {task['artifact_id']} 的 block_number 为 '补方'，跳过派单")
                                        task_service.insert_into_produce_table(sql_db, task_info, task["beton_volume"],
                                                                               erp_id,task["artifact_id"], half_volume, 0)
                                        continue

                                    print(f"处理新任务: {task['artifact_id']}")

                                    # 获取任务单信息
                                    task_service.insert_into_produce_table(sql_db, task_info, task["beton_volume"],
                                                                           erp_id,task["artifact_id"], half_volume, 1)
                                    with monitoring_service.tasks_lock:
                                        monitoring_service.monitored_tasks.add(erp_id)
                                        monitoring_service.inserted_tasks[erp_id] = task["artifact_id"]
                                        print(f"任务 {erp_id} (ArtifactID: {task['artifact_id']}) 已添加到监控列表")
                                finally:
                                    sql_db.close()

                # 更新上次获取的ArtifactID集合和artifact_list
                last_artifact_ids = current_artifact_ids
                last_artifact_list = artifact_list.copy()

                # 每10分钟清理一次过期的时间戳记录
                cleanup_old_timestamps(task_service.artifact_timestamps, current_artifact_ids, MAX_AGE_HOURS)

                # 每10秒检查一次
                time.sleep(CHECK_INTERVAL)

            except Exception as e:
                print(f"发生错误: {e}")
                time.sleep(2)

    except KeyboardInterrupt:
        print("程序已停止")
        # 停止TCP服务端
        if 'tcp_server' in locals():
            tcp_server.stop()
        # 停止OPC客户端
        if 'data_client' in locals():
            data_client.stop()


if __name__ == "__main__":
    main()