###########################################################################
#
# Copyright (c) 2021-2024 Diality Inc. - All Rights Reserved.
#
# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
#
# @file    test_dg_records.py
#
# @author  (last)      Dara Navaei
# @date    (last)      18-Jan-2023
# @author  (original)  Dara Navaei
# @date    (original)  20-Jul-2021
#
############################################################################
import copy
import pprint
import subprocess
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 dialin.dg.sw_configs import DGSWConfigs
from time import sleep

"""
def process_calibration_record(read=False):
    dg = DG()

    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", 1.0), # fourth order
        struct.pack("<f", 1.0), # third order
        struct.pack("<f", 1.0), # second order
        struct.pack("<f", 1.0), # gain
        struct.pack("<f", 0.0), # offset
        struct.pack("<i", 0), # cal_time
    ]))
    print(val)

     OrderedDict([('ppi',
                            {'cal_time': ['<i', 0],
                             'crc': ['<H', 26600],
                             'fourth_order': ['<f', 0.0],
                             'gain': ['<f', 1.0],
                             'offset': ['<f', 0.0],
                             'second_order': ['<f', 0.0],
                             'third_order': ['<f', 0.0]}),
                           ('ppo',
                            {'cal_time': ['<i', 0],
                             'crc': ['<H', 26600],
                             'fourth_order': ['<f', 0.0],
                             'gain': ['<f', 1.0],
                             'offset': ['<f', 0.0],
                             'second_order': ['<f', 0.0],
                             'third_order': ['<f', 0.0]}),

    val = NVOpsUtils.crc_16(b''.join([
        struct.pack("<f", 1.0),
        struct.pack("<f", 1.0),
        struct.pack("<f", 0),
        struct.pack("<f", 0),
        struct.pack("<i", 0), # calibration time
    ]))
    print(val)
    val = NVOpsUtils.crc_16(b''.join([
        struct.pack("<f", 1.0),
        struct.pack("<f", 0),
        struct.pack("<f", 0),
        struct.pack("<f", 1.0),
        struct.pack("<f", 0),
        struct.pack("<i", 0),  # cal_time
    ]))
    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),  # cal_time
    ]))
    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_sw_config_record():

    dg = DG(log_level="DEBUG")
    if dg.cmd_log_in_to_dg():

        #print(dg.cmd_ui_request_dg_version())
        #dg.sw_configs.cmd_reset_dg_sw_config_record()

        #dg.sw_configs.cmd_get_dg_sw_config_record()

        dg.sw_configs.cmd_set_dg_sw_config_record('/home/fw/DG_NV_Records/2022-01-22-SW-CONFIGS-Record.xlsx')

        """
        observer = Observer("dg_sw_config_record")
        dg.sw_configs.attach(observer)
        while not observer.received:
            sleep(0.2)
        """
        #dg.sw_configs.dg_sw_config_record['sw_configs'][DGSWConfigs.SW_CONFIG_DISABLE_HEATERS_MONITOR.name][1] = 1
        #print(dg.sw_configs.dg_sw_config_record)

        #dg.sw_configs.cmd_set_dg_sw_config_record(dg.sw_configs.dg_sw_config_record)



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.calibration_record.dg_calibration_record)
        """
        dg.calibration_record.dg_calibration_record['flow_sensors']['dialysate_flow_sensor']['offset'][1] = 0.885
        dg.calibration_record.dg_calibration_record['flow_sensors']['dialysate_flow_sensor']["cal_time"][1] = \
            NVOpsUtils.get_current_time_in_epoch()
        dg.calibration_record.dg_calibration_record['flow_sensors']['dialysate_flow_sensor']["crc"][1] = \
            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record['flow_sensors']['dialysate_flow_sensor'])

        
        # Change the value(s) you are planning to change directly to the dictionary
        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"]["fourth_order"][1] = 0.0
        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"]["gain"][1] = 1.0
        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"]["cal_time"][1] = \
            NVOpsUtils.get_current_time_in_epoch()
        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"]["crc"][1] = \
            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppi"])
        
        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppo"]["second_order"][1] = 0.0
        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppo"]["cal_time"][1] = \
            NVOpsUtils.get_current_time_in_epoch()
        dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppo"]["crc"][1] = \
            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record["pressure_sensors"]["ppo"]) 
        """
        
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a1"]["gain"][1] = 0.971227
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a1"]["offset"][1] = -13.7163
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a1"]["cal_time"][1] = \
            NVOpsUtils.get_current_time_in_epoch()
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a1"]["crc"][1] = \
            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a1"])

        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a2"]["gain"][1] = 0.980796
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a2"]["offset"][1] = -34.9747
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a2"]["cal_time"][1] = \
            NVOpsUtils.get_current_time_in_epoch()
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a2"]["crc"][1] = \
            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_a2"])

        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b1"]["gain"][1] = 1.006039
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b1"]["offset"][1] = 26.75222
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b1"]["cal_time"][1] = \
            NVOpsUtils.get_current_time_in_epoch()
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b1"]["crc"][1] = \
            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b1"])

        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b2"]["gain"][1] = 1.01493
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b2"]["offset"][1] = 133.4312
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b2"]["cal_time"][1] = \
            NVOpsUtils.get_current_time_in_epoch()
        dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b2"]["crc"][1] = \
            NVOpsUtils.get_group_record_crc(dg.calibration_record.dg_calibration_record["load_cells"]["load_cell_b2"])

        print(dg.calibration_record.dg_calibration_record)

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

        #print(dg.calibration_record.dg_calibration_record)

        #record_old_formatted = pprint.pformat(dg.calibration_record.dg_calibration_record, indent=4)
        #with open("/home/fw/projects/dialin/tests/peter/dg_cal_record.log", 'w') as f:
        #    f.write(record_old_formatted)

        #subprocess.call("meld /home/fw/projects/dialin/tests/peter/dialin_test_record_old.log"
        #                "     /home/fw/projects/dialin/tests/peter/dialin_test_record_new.log", shell=True)


def test_dg_reset_record():
    dg = DG(log_level="DEBUG")
    if dg.cmd_log_in_to_dg():
        """
        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.calibration_record.dg_calibration_record)

        dg.calibration_record.cmd_reset_dg_calibration_record()
        sleep(0.25)
        print(dg.calibration_record.dg_calibration_record)
        """
        #dg.calibration_record.cmd_reset_dg_calibration_record()
        #sleep(0.25)
        dg.system_record.cmd_reset_dg_system_record()
        #sleep(0.25)
        #print(dg.system_record.dg_system_record)
        #dg.service_record.cmd_reset_dg_service_record()
        #sleep(0.25)
        #print(dg.service_record.dg_service_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)

        dg.system_record.dg_system_record['system_record']['top_level_sn'][1] = 'DG_Device_00000'
        dg.system_record.dg_system_record['system_record']['top_level_pn'][1] = '123'
        dg.system_record.dg_system_record['system_record']['crc'][1] = \
            NVOpsUtils.get_group_record_crc(dg.system_record.dg_system_record['system_record'])

        print(dg.system_record.dg_system_record)
        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_dg_excel_report():
    dg = DG(log_level="DEBUG")
    if dg.cmd_log_in_to_dg():
        dg.calibration_record.cmd_get_dg_calibration_record_report()
        #dg.calibration_record.cmd_set_dg_calibration_excel_to_fw('/home/fw/projects/DG_NV_Records/2022-02-10-DG-Record.xlsx')


if __name__ == "__main__":

    #test_dg_reset_record()
    # test_dg_sw_config_record()
    #test_dg_calibration_record()
    # test_dg_service_record()
    test_dg_system_record()
    # test_dg_scheduled_runs_record()
    #test_dg_excel_report()