import json
import asyncio
from models import *
from .connect_manager import ConnectionManager
from .message_handler import *
from mcu.DeviceControl import DeviceControl,checkMcuConnection
from mcu.BlueToothMode import BlueToothMode
from mcu.capture.smart_shooter_class import SmartShooter
import time
from .socket_client import socket_manager
from sqlalchemy.exc import NoResultFound
import os, datetime

conn_manager = ConnectionManager()
active_connections = set()
device_ctrl = DeviceControl(websocket_manager=conn_manager)
blue_tooth = BlueToothMode(websocket_manager=conn_manager)
smart_shooter = SmartShooter(websocket_manager=conn_manager)
from utils.common import message_queue
async def updateDataRecord(PhotoFilename, id):
    await asyncio.sleep(0.01)
    create_time = datetime.datetime.fromtimestamp(os.path.getctime(PhotoFilename))
    data = {"id": id, "image_path": PhotoFilename, "photo_create_time": create_time}
    # record_model = PhotoRecord(**data)
    session = SqlQuery()
    record_model = CRUD(PhotoRecord)
    model = record_model.read(session, conditions={"id": id})
    if model == None:
        print(f"smart shooter 拍照记录更新失败,记录id:{id},不存在")
    else:
        # 走编辑逻辑
        record_model.updateConditions(session, conditions={"id": id}, **data)
        print(f"smart shooter 拍照记录更新成功,记录id:{id}")


@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    # await websocket.accept()
    await conn_manager.connect(websocket)
    active_connections.add(websocket)
    smart_shooter.websocket = websocket
    try:
        # await socket_manager.connect()
        async def handler_messages():
            while True:
                try:
                    byteDats = await websocket.receive()
                    socket_type = byteDats.get("type")
                    if socket_type == "websocket.disconnect":
                        smart_shooter.stop_listen = True
                        device_ctrl.close_connect()
                        device_ctrl.mcu_exit = True
                        device_ctrl.clearMyInstance()
                        diviceList = blue_tooth.devices
                        if len(diviceList) == 0:
                            blue_tooth.bluetooth_exit = True
                            blue_tooth.clearMyInstance()
                            break
                        diviceAddress = list(diviceList.keys())[0]
                        if diviceAddress != "":
                            print(diviceList.get(diviceAddress))
                            diviceName = diviceList[diviceAddress]["name"]
                            blue_tooth.disconnect_device(diviceAddress, diviceName)
                        blue_tooth.bluetooth_exit = True
                        blue_tooth.clearMyInstance()
                        break
                    print("byteDats", byteDats)
                    await handlerSend(
                        conn_manager, json.dumps(byteDats), websocket, smart_shooter
                    )
                except Exception as e:
                    print(e)
                    break
        # async def checkConnMcu():
        #     await checkMcuConnection(device_ctrl)
        # async def connectBlueTooth():
        #     await blue_tooth.main_func()
        async def send_message():
            while True:
                try:
                    message = await message_queue.get()
                    await websocket.send_json(message)
                except Exception as e:
                    print(e)
                    break
        async def MsgCallback(msg):
            msg_id = msg.get("msg_id")
            match msg_id:
                case "PhotoUpdated":
                    PhotoFilename = msg.get("PhotoFilename")
                    PhotoLocation = msg.get("PhotoLocation")
                    PhotoOrigin = msg.get("PhotoOrigin")
                    if (PhotoFilename != "" and PhotoFilename != None) and (
                        PhotoLocation == "Local Disk"
                    ):
                        # temp_photo_name = PhotoFilename
                        # 更新拍照记录
                        print("PhotoFilename", PhotoFilename, PhotoOrigin)
                        if PhotoOrigin != "" and PhotoOrigin != "external":
                            goods_art_no, id = PhotoOrigin.split(",")
                            await updateDataRecord(PhotoFilename, id)
                        data = conn_manager.jsonMessage(
                            code=0,
                            msg=f"照片获取成功",
                            data={"photo_file_name": PhotoFilename},
                            msg_type="smart_shooter_photo_take",
                        )
                        await conn_manager.send_personal_message(data, websocket)
                case "LiveviewUpdated":
                    CameraLiveviewImage = msg.get("CameraLiveviewImage", None)
                    # base64_to_image(CameraLiveviewImage, "liveview.jpg")
                    # print("收到直播画面：CameraLiveviewImage")
                    data = conn_manager.jsonMessage(
                        code=1,
                        msg=f"预览数据发送",
                        data={"smart_shooter_preview": CameraLiveviewImage},
                        msg_type="smart_shooter_enable_preview",
                    )
                    await conn_manager.send_personal_message(data, websocket)
        smart_shooter.callback_listen = MsgCallback
        loop = asyncio.get_event_loop()
        loop.run_in_executor(None, smart_shooter.connect_listen)  # 后台线程启动监听
        await asyncio.gather(handler_messages(), send_message())
    except WebSocketDisconnect:
        # socket_manager.close()
        print("Client disconnected")
    finally:
        active_connections.discard(websocket)
        # if websocket:
        #     await websocket.close()

# @app.on_event("startup")
# async def startup_event():
#     loop = asyncio.get_event_loop()
#     loop.run_in_executor(None, await smart_shooter.connect_listen)
#     print("监听服务已启动")
@app.on_event("shutdown")
async def shutdown_event():
    print("Shutting down...")
    # socket_manager.close()
    # 清理操作
    for connection in list(active_connections):
        try:
            await connection.close()
        except Exception as e:
            print(f"Error closing connection: {e}")