import sys
import struct

from dialin import HD, AbstractObserver

sys.path.append("../")
from dialin.dg.dialysate_generator import DG
from dialin.utils.nv_ops_utils import NVOpsUtils
from time import sleep


def process_calibration_record(read=False):

    cal = dg.calibration_record
    print(cal.tmp_record)

    try:
        if read:
            cal.cmd_request_dg_calibration_record()
            while True:
                sleep(0.5)
                if cal.cal_data != 0:
                    if cal.is_reading_record_done():
                        break
        else:
            cal.cmd_set_dg_calibration_record()

        print(cal.tmp_record)

    except KeyboardInterrupt:
        pass


def process_system_record(read=False):

    sys = dg.system_record
    print(sys.dg_system_record)

    try:
        if read:
            sys.get_dg_system_record()
            while True:
                sleep(0.5)
                if sys.is_reading_record_done():
                    if sys.is_reading_record_done():
                        break
        else:
            sys.set_dg_system_record()

        print(sys.dg_system_record)

    except KeyboardInterrupt:
        pass


def process_service_record(read=False):

    sys = dg.service_record
    print(sys.dg_service_record)

    try:
        if read:
            sys.cmd_request_dg_service_record()
            while True:
                sleep(0.5)
                if sys.is_reading_record_done():
                    if sys.is_reading_record_done():
                        break
        else:
            sys.set_dg_service_record()

        print(sys.dg_service_record)

    except KeyboardInterrupt:
        pass

def test_crc():
    val = NVOpsUtils.crc_16(b''.join([
        struct.pack("<f", 0.0),
        struct.pack("<f", 0.0),
        struct.pack("<f", 0.0),
        struct.pack("<f", 1.0),
        struct.pack("<f", 0.0),
        struct.pack("<i", 0),
    ]))
    print(val)
    val = NVOpsUtils.crc_16(b''.join([
        struct.pack("<f", float("nan")),
        struct.pack("<f", float("nan")),
        struct.pack("<f", float("nan")),
        struct.pack("<f", float("nan")),
        struct.pack("<f", float("nan")),
        struct.pack("<i", -1),
    ]))
    print(val)


class Observer(AbstractObserver):
    def __init__(self, prop):
        self.received = False
        self.prop = prop

    def update(self, message):
        print("Message: {0}".format(message))
        self.received = message.get(self.prop, False)

def test_dg_calibration_record():
    dg = DG(log_level="DEBUG")
    if dg.cmd_log_in_to_dg():
        print(dg.cmd_ui_request_dg_version())
        dg.calibration_record.cmd_request_dg_calibration_record()
        observer = Observer("dg_calibration_record")
        dg.calibration_record.attach(observer)
        while not observer.received:
            sleep(0.2)

        print(dg.dg_version)
        print(dg.fpga_version)

        dg.calibration_record.cmd_set_dg_calibration_record(dg.calibration_record.dg_calibration_record)


def test_dg_service_record():
    dg = DG(log_level="DEBUG")
    if dg.cmd_log_in_to_dg():
        dg.cmd_ui_request_dg_version()
        dg.service_record.cmd_request_dg_service_record()
        observer = Observer("dg_service_record")
        dg.service_record.attach(observer)
        while not observer.received:
            sleep(0.2)

        print(dg.dg_version)
        print(dg.fpga_version)

        dg.service_record.cmd_set_dg_service_record(dg.service_record.dg_service_record)


def test_dg_system_record():
    dg = DG(log_level="DEBUG")
    if dg.cmd_log_in_to_dg():
        dg.cmd_ui_request_dg_version()
        dg.system_record.cmd_request_dg_system_record()
        observer = Observer("dg_system_record")
        dg.system_record.attach(observer)
        while not observer.received:
            sleep(0.2)

        print(dg.dg_version)
        print(dg.fpga_version)

        dg.system_record.cmd_set_dg_system_record(dg.system_record.dg_system_record)


def test_dg_scheduled_runs_record():
    dg = DG(log_level="DEBUG")
    if dg.cmd_log_in_to_dg():
        dg.scheduled_runs_record.cmd_request_dg_scheduled_runs_record()
        observer = Observer("dg_scheduled_runs_record")
        dg.scheduled_runs_record.attach(observer)
        while not observer.received:
            sleep(0.2)

        dg.scheduled_runs_record.cmd_set_dg_scheduled_runs_record(dg.scheduled_runs_record.dg_scheduled_runs_record)


def test_hd_calibration_record():
    hd = HD(log_level="DEBUG")
    if hd.cmd_log_in_to_hd(resend=False):
        observer = Observer("hd_calibration_record")
        hd.calibration_record.attach(observer)
        hd.calibration_record.cmd_request_hd_calibration_record()
        while not observer.received:
            sleep(0.2)

        hd.calibration_record.cmd_set_hd_calibration_record(hd.calibration_record.hd_calibration_record)


def test_hd_service_record():
    hd = HD(log_level="DEBUG")
    if hd.cmd_log_in_to_hd(resend=False):
        observer = Observer("hd_service_record")
        hd.service_record.attach(observer)
        hd.service_record.cmd_request_hd_service_record()
        while not observer.received:
            sleep(0.2)

        hd.service_record.cmd_set_hd_service_record(hd.service_record.hd_service_record)


def test_hd_system_record():
    hd = HD(log_level="DEBUG")
    if hd.cmd_log_in_to_hd(resend=False):
        hd.ui.cmd_ui_request_hd_version()
        observer = Observer("hd_system_record")
        hd.system_record.attach(observer)
        hd.system_record.cmd_request_hd_system_record()
        while not observer.received:
            sleep(0.2)

        print(hd.ui.hd_version)
        print(hd.ui.fpga_version)

        hd.system_record.cmd_set_hd_system_record(hd.system_record.hd_system_record)


if __name__ == "__main__":
    test_dg_calibration_record()
    # test_dg_service_record()
    # test_dg_system_record()
    # test_dg_scheduled_runs_record()

    # test_hd_calibration_record()
    # test_hd_service_record()
    # test_hd_system_record()