#!/opt/homebrew/bin/python3
# -*- coding:utf-8 -*-
import json
import uuid
from PyQt6 import *
from PyQt6.QtCore import *
from logs import log
from typing import Union
from models import Instruction, Session


class InstructionManager(QObject):
    typeChange = pyqtSignal(QVariant)
    attrChange = pyqtSignal(str)
    updateData = pyqtSignal(str, str)
    createData = pyqtSignal(str, str)
    __supportedType = {
        "general" : {
            "name" : "通用指令",
            "qmlPath" : "./General.qml",
            "digestAttr" : "data"
        }, 
        "cosl" : {
            "name" : "COSL_16位通用指令",
            "qmlPath" : "./Cosl.qml",
            "digestAttr" : "cmd"
        },
        "scpi" : {
            "name" : "SCPI指令",
            "qmlPath" : "./Scpi.qml",
            "digestAttr" : "data"
        },
        "http" : {
            "name" : "HTTP指令",
            "qmlPath" : "./Http.qml",
            "digestAttr" : "url"
        }
        # "scpi" : "SCPI指令",
        # "modbus_rtu" : "MODBUS RTU",
        # "modbus_ascii" : "MODBUS ASCII",
        # "modbus_tcp" : "MODBUS TCP",
        # "at" : "AT指令",
    }

    def __init__(self, parent=None):
        super().__init__()

    @pyqtSlot(str,str,str, QVariant, result=str)
    def create(self, dev_model_id, name, type, attr):
        if not isinstance(attr, dict):  
            attr = attr.toVariant()
        if not attr.__contains__("remark"):
            attr["remark"] = ""
        digetsAttr = InstructionManager.__supportedType[type]["digestAttr"]
        if not attr.__contains__(digetsAttr):
            attr[digetsAttr] = ""  
        data = {
            "id": str(uuid.uuid4()),
            "dev_model_id": dev_model_id,
            "name": name,
            "type": type,
            "attr": json.dumps(attr)
        }    
        ok, res = Session.addByClass(Instruction, data)
        if ok:
            return str(res["id"])
        return ""
    
    @pyqtSlot(QVariant, result=str)
    def create_from_json(self, params):
        if not isinstance(params, dict):  
            params = params.toVariant()
        data = {
            "id": params["id"],
            "dev_model_id": params["dev_model_id"],
            "name": params["name"],
            "type": params["type"],
            "attr": json.dumps(params["attr"])
        }    
        ok, res = Session.addByClass(Instruction, data)
        if ok:
            return str(res["id"])
        return ""

    @pyqtSlot(QVariant, result=str)
    def create_from_git_json(self, params):
        if not isinstance(params, dict):  
            params = params.toVariant()
        data = {
            "id": params["id"],
            "dev_model_id": params["dev_model_id"],
            "name": params["name"],
            "type": params["type"],
            "attr": json.dumps(params["attr"])
        }    
        ok, res = Session.addByClassFromGit(Instruction, data)
        if ok:
            return str(res["id"])
        return ""    
    
    @pyqtSlot(str, result=str)
    def createCopy(self, id):
        ok,res = Session.queryById(Instruction, id)
        if ok:
            res["name"] = res["name"] + "_副本"
            res["attr"] = json.loads(res["attr"])
            dev_model_id = res["dev_model_id"]
            return self.create(dev_model_id, res["name"], res["type"], res["attr"])
    
    @pyqtSlot(str,str, result=str)
    def createCrossCopy(self, id, dev_model_id = ''):
        ok,res = Session.queryById(Instruction, id)
        if ok:
            res["name"] = res["name"] + "_副本"
            res["attr"] = json.loads(res["attr"])
            if dev_model_id == '':
                dev_model_id = res["dev_model_id"]
            return self.create(dev_model_id, res["name"], res["type"], res["attr"])
    

    @pyqtSlot(str, result=str)
    def copy(self, id, copy_dev_model_id):
        ok,res = Session.queryById(Instruction, id)
        if ok:
            res["dev_model_id"] = copy_dev_model_id
            res["attr"] = json.loads(res["attr"])
            return self.create(res["dev_model_id"], res["name"], res["type"], res["attr"])
    
    @pyqtSlot(str, result=bool)
    def copyDevModel(self, dev_model_id, new_dev_model_id):
        instructionLst = self.getDevmodelInstructions(dev_model_id)
        for instruction in instructionLst:
            self.copy(instruction["id"], new_dev_model_id)
        return True
   
    @pyqtSlot(str, QVariant, result=bool)
    def update(self, id, param = None):
        if not isinstance(param, dict):  
            param = param.toVariant()
        data = {}
        if "name" in param:
            data["name"] = param["name"]
        if "attr" in param:
            data["attr"] = json.dumps(param["attr"])
        ok,res = Session.updateById(Instruction, id, data)
        return ok
    
    @pyqtSlot(str, result=bool)
    @pyqtSlot(list, result=bool)  
    def delete(self, id):
        if isinstance(id, str): 
            ok,res = Session.deleteById(Instruction, id)
            return ok
        else:
            ok,res = Session.deleteByIds(Instruction, id)
            return ok
    
    @pyqtSlot(str, result=QVariant)
    @pyqtSlot(list, result=list)
    def getInfo(self, id: Union[str, list]):
        if isinstance(id, list) : 
            ok,res = Session.queryByIds(Instruction, id)
            if ok:
                for data in res:
                    if "attr" in data:
                        data["attr_str"] = data["attr"] or ""
                        data["attr"] = data["attr"] and json.loads(data["attr"]) or {}
                return res
            else:
                return []
        else:
            if id == "all":
                ok,res = Session.queryByAll(Instruction)
                if ok:
                    for data in res:
                        if "attr" in data:
                            data["attr"] = data["attr"] and json.loads(data["attr"]) or {}
                    return res
            else:
                ok,res = Session.queryById(Instruction, id)
                if ok:
                    if "attr" in res:
                        res["attr_str"] = res["attr"] or ""
                        res["attr"] = res["attr"] and json.loads(res["attr"]) or {}
                    return res
                else:
                    return None

    
    # 获取所有属于设备模型的指令
    @pyqtSlot(str, result=QVariant)
    def getDevmodelInstructions(self, dev_model_id):
        ok, res = Session.queryByDevModelId(Instruction, dev_model_id)
        if ok:
            for data in res:
                if "attr" in data:
                    data["attr_str"] = data["attr"] or ""
                    data["attr"] = data["attr"] and json.loads(data["attr"]) or {}
            return res
        else:
            return []
        
    # 获取所有属于设备模型的指令
    @pyqtSlot(str, result=QVariant)
    def getOriginalDevmodelInstructions(self, dev_model_id):
        ok, res = Session.queryByDevModelId(Instruction, dev_model_id)
        if ok:
            for data in res:
                if "attr" in data:
                    data["attr"] = data["attr"] and json.loads(data["attr"]) or {}
            return res
        else:
            return []

    @pyqtSlot(result=QVariant)
    def getSupportedType(self):
        return InstructionManager.__supportedType

instructionManager = InstructionManager()