import parser
import struct
import time
from datetime import datetime

exp_coeff = [13.1, 10.006, 10.6, -11.0, 13.1, 10.03, 12.0, 199.0, 11.5, 17.1, 110.11, 110.12]
exp_fw_ver = "v0.1.0"
exp_hw_ver = "v0.1.1"
exp_sn = "v0.1.2"
########################################################################################################################
# This function reads the sensor data and settings
# {"poll", cmd_poll},
def cmd_poll(cond1):
    cond1.ser.write(b'poll\n')
    print("Sent command cmd_poll")

    i = 0
    poll = ""
    while i <= 21:
        line = cond1.ser.readline()
        current_line_text = line.decode('utf-8', errors='replace')
        poll += current_line_text
        i += 1
    print(poll)

########################################################################################################################
# This function updates the excitation voltage in the flash.
# {"setvolt", cmd_voltage}
def cmd_voltage(cond1, value):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(f"setvolt {value}\n".encode())
    print("Sent command cmd_voltage")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass

    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function updates the excitation frequency in the flash.
# {"setfreq", cmd_frequency},
def cmd_frequency(cond1, value):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(f"setfreq {value}\n".encode())
    print("Sent command cmd_frequency")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass

    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function updates the setup time in the flash.
# {"setstm", cmd_setuptime},
def cmd_setuptime(cond1, value):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(f"setstm {value}\n".encode())
    print("Sent command cmd_setuptime")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass

    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function updates the hold time in the flash.
# {"sethtm", cmd_holdtime},
def cmd_holdtime(cond1, value):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(f"sethtm {value}\n".encode())
    print("Sent command cmd_holdtime")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass


    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function updates the temperature coefficient in the flash.
# {"setcof", cmd_coefficient},
def cmd_coefficient(cond1, value):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(f"setcof {value}\n".encode())
    print("Sent command cmd_coefficient")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass

    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function updates the cell constant in the flash.
# {"setk", cmd_cellconstant},
def cmd_cellconstant(cond1, value):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(f"setk {value}\n".encode())
    print("Sent command cmd_cellconstant")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass

    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function retrieves raw sensor data in ASCII format.
# {"getraw", cmd_tx_raw_poll},
def cmd_tx_raw_poll(cond1):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(b'getraw\n')
    print("Sent command getraw")

    i = 0
    poll = ""
    while i <= 6:  # decode by number of lines of data messages
        current_line_text = str(cond1.ser.readline().decode())
        poll = poll + current_line_text
        i += 1
    print(poll)

########################################################################################################################
# This function retrieves raw conductivity and temperature values in binary format.
def read_autopoll(cond1, duration_sec=10):
    fmt = "<ff"
    end_time = time.time() + duration_sec
    data_count = 0;

    while time.time() < end_time:
        data = cond1.ser.read(7)
        data_count = data_count + 1
        # print(data)
        parser.parse_autopoll(data)
    print(data_count)

########################################################################################################################
# This function enables the auto polling / publishing feature
# {"b", cmd_start_poll_bin}
def cmd_start_poll_bin(cond1):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(b' b\n')
    print("Sent command cmd_start_poll_bin")

########################################################################################################################
# This function disables the auto polling / publishing feature
# {"e", cmd_stop_poll_bin}
def cmd_stop_poll_bin(cond1):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(b' e\n')
    print("Sent command cmd_stop_poll_bin")

########################################################################################################################
# This function retrieves the values of 12 coefficients in ASCII format
# {"getcal", cmd_tx_cal_data}
def cmd_get_cal_data(cond1):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(b' getcal\n')
    print("Sent command getcal")

    i = 0
    cal = ""
    while i <= 12:  # decode by number of lines of data messages
        current_line_text = str(cond1.ser.readline().decode())
        cal = cal + current_line_text
        i += 1
    print(cal)

########################################################################################################################
# This function updates the value of coefficients in the flash.
# idx : Coeffficent index 1 to 12
# value: New value of the coefficient
# {"setcal", cmd_rx_cal}
def cmd_setcal(cond1, idx, value):
    cond1.ser.reset_input_buffer()
    cmd = f"setcal{idx} {value}\n".encode()
    cond1.ser.write(cmd)
    print(f"Sent command cmd_setcal for index {idx} with value {value}")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass

    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function retrieves version information in ASCII format
# {"getver", cmd_tx_version}
def cmd_get_version(cond1):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(b' getver\n')
    print("Sent command getver")

    i = 0
    ver = ""
    while i <= 3:  # decode by number of lines of data messages
        current_line_text = str(cond1.ser.readline().decode())
        ver = ver + current_line_text
        i += 1
    print(ver)

########################################################################################################################
# This function updates the hardware version number in the flash.
# {"sethw", cmd_set_hardware_ver},
def cmd_set_hardware_ver(cond1, value):
    cmd = f"sethw {value}\n"
    cond1.ser.reset_input_buffer()
    cond1.ser.write(cmd.encode("ascii"))
    print("Sent command cmd_set_hardware_ver")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass

    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function updates the serial number in the flash.
# {"setsn", cmd_set_serial_num},
def cmd_set_serial_num(cond1, value):
    cmd = f"setsn {value}\n"
    cond1.ser.reset_input_buffer()
    cond1.ser.write(cmd.encode("ascii"))
    print("Sent command cmd_set_serial_num")

    # minimal wait until some data arrives
    while cond1.ser.in_waiting == 0:
        pass

    data = cond1.ser.readline()
    print(data)

########################################################################################################################
# This function retrieves calibration data and version information in binary format
# {"U", cmd_tx_cal_ver_bin}
def cmd_get_cal_ver_bin(cond1):
    cond1.ser.reset_input_buffer()
    cond1.ser.write(b' U\n')
    print("Sent command cmd_get_cal_ver_bin")
    data = cond1.ser.read(86)
    print(data)
    # parser.parse_coeff_and_version(data)
    status = parser.verify_coeffs_and_versions(data, exp_coeff, exp_fw_ver,exp_hw_ver,exp_sn,1e-5)
    parser.print_verification_results(status)

########################################################################################################################
# This function prints the current data and time
def printTimestamp():
    current_time = datetime.now()
    print("Current timestamp:", current_time)

########################################################################################################################