from celery import Task, shared_task

import os
import sys
import pickle
import time
import sqlite3
from peewee import *

sys.path.append('../../../')
sys.path.append('../')

from protocol.ModBus.tcpslave_example import TCPSlave
from protocol.Celery.MBTCPSlave import app

from utils.DBModels.BaseModel import *
from utils.DBModels.ProjectBaseModel import *

from utils.DBModels.ClientModels import ClientDB
from utils.DBModels.ProtocolModel import ModBusVar

from model.ProjectModel.VarManage import ModbusVarManage
from model.ProjectModel.ProjectManage import ProjectManage


class ModBusTCPSTask(Task):
    _TCPSlave = None
    _cursor = None
    _dbPath = None
    _setting = None
    _offset = None
    _influxDB = None
    _conn = None
    def __init__(self):
        super(ModBusTCPSTask, self).__init__()

    @property
    def dbPath(self):
        if self._dbPath is None:
            dbPath = os.path.join('../../../', 'db', 'client.db')
            self.clientDB = SqliteDatabase(dbPath)
            self.client_proxy = client_proxy
            self.client_proxy.initialize(self.clientDB)
            self.clientDB.connect()
            self.name = ClientDB.getByName().value
            self._dbPath = os.path.join('../../../project', self.name, 'db', 'project.db')
        return self._dbPath

    @property
    def tcpSlave(self):
        if self._TCPSlave is None:
            address =  self.setting[0]
            port =  self.setting[1]
            self._TCPSlave = TCPSlave(address = address, port = port)
        return self._TCPSlave

    @property
    def offset(self):
        if self._offset is None:
            offset = self.setting[2]
            self._offset = offset
        return self._offset

    @property
    def conn(self):
        if self._conn is None:
            self._conn = sqlite3.connect(self.dbPath)
        return self._conn

    @property
    def cursor(self):
        if self._cursor is None:
            self._cursor = self.conn.cursor()
        return self._cursor

    @property
    def setting(self):
        if self._setting is None:
            self.cursor.execute("select * from TCPSetting")
            allCon = self.cursor.fetchall()

            address = str(allCon[0][1])
            port = int(allCon[0][2])
            offset = int(allCon[0][-1])
            self._setting = [address, port, offset]
        return self._setting

    @property
    def influxDB(self):
        if self._influxDB is None:
            self._influxDB = ProjectManage.recordingHistory(self.name, self.cursor)
            self.conn.commit()
        return self._influxDB


@app.task(bind = True, priority = 5)
def readValues(self): # 读取变量
    # [var.id, var.varName, var.description, var.varType, var.slaveID, var.address, var.min, var.max]
    # varName = CharField()
    # varType = IntegerField()
    # createTime = CharField()
    # description = CharField()
    # address = CharField()
    # slaveID = CharField()
    # min = CharField()
    # max = CharField()
    # allVar = self.allVar
    self.cursor.execute("select * from ModBusVar")
    allVar = self.cursor.fetchall()
    varDict = {}
    if not allVar:
        return
    else:
        # print(allVar)
        for varMes in allVar:
            name = str(varMes[1])
            varType = str(varMes[2])
            slaveId = int(varMes[6])
            address = int(varMes[5]) - self.offset
            order = varMes[-1]
            try:
                self.tcpSlave.server.get_slave(slaveId)
            except:
                self.tcpSlave.addSlave(slaveId)
            # print(varType)
            if varType == '4':
                # varDict[name] = RTUModbus.readHoldingRegisters(slaveId = slaveId, startAddress = address, varNums = 1)
                curValue = self.tcpSlave.readValue(slaveId, '4', address, order = order)
            elif varType == '3':
                curValue = self.tcpSlave.readValue(slaveId, '3', address, order = order)
                # curValue = RTUModbus.readInputRegisters(slaveId = slaveId, startAddress = address, varNums = 1)
            elif varType == '0':
                curValue = self.tcpSlave.readValue(slaveId, '0', address, order = order)
                # curValue = RTUModbus.readCoils(slaveId = slaveId, startAddress = address, varNums = 1)
            elif varType == '1':
                curValue = self.tcpSlave.readValue(slaveId, '1', address, order = order)
            if curValue != 'error':
                self.influxDB.writeFun(str(name), curValue)
            varDict[name] = curValue
            try:
                value = app.backend.get(name).decode('utf-8')
                address2 = float(value.split(',')[0])
                if '.' in value:
                    value = float(value.split(',')[1])
                else:
                    value = int(value.split(',')[1])
                if address == address2:
                    self.tcpSlave.setValue(slaveId, varType, address, value, order = order)
                    app.backend.set(name, '')
            except Exception as e:
                print(e)
                # varDict[name] = RTUModbus.readInputCoils(slaveId = slaveId, startAddress = address, varNums = 1)

    app.backend.set('ModBus', str(self.request.id))
    # print(RTUModbus.readInputRegisters(slaveId = 2, startAddress =  0, varNums = 10))

    # print(RTUModbus.readCoils(slaveId = 3, startAddress = 0, varNums = 10))

    # print(RTUModbus.readInputCoils(slaveId = 4, startAddress = 0, varNums = 10))
    # print(varDict)
    return varDict


@shared_task(bind = True, priority = 1)
def setValue(self, name, varType, slaveID, address, value): # 写入变量
    # print(id(self.tcpSlave))
    slaveID = int(slaveID)
    address = int(address) - self.offset
    # self.tcpSlave.setValue(slaveId, varType, address, value)
    app.backend.set(name, str(address) + ',' + str(value))
    # if varType == '1':
    #     RTUModbus.writeSingleRegister(slaveId = slaveID, address = address, outputValue = value)
    # elif varType == '3':
    #     RTUModbus.writeSingleCoil(slaveId = slaveID, address = address, outputValue = value)
    # else:
    #     return '错误的变量类型'
    return 'success'