# Subject/Title: LDT -4177 Post-Treatment - SW - 02 - TxReview - Q&R - 15: SIT - Software Integration Tests - Squish Qt
#                LDT-4527 Treatment Logs  - SW - 02 - Treatment Logs - Q&R - 15: SIT - Software Integration Tests - Squish Qt
# Functionalities: Testing of Post-Treatment Tx review
#
# Steps:
#    1. Enter prescription in pre treatment and start treatment
#    2. Navigate to main treatment screen 
#    3. Send patient vitals data 
#    4. During the treatment send Data from fw 
#         - Vitals Data
#         - Log Alarm Data
#         - Log Event Data
#         - Log Average Data
#         - send serial number
#    5. Navigate to the Post Treatment review page
#    6. On the Review page check the request in the firmware
#    7. Test the response in the UI page
#    8. Verify tx log was created. Check naming is correct <date>_<time>_<serial number>.txr.p
#         - Date and time in the  tx review logs page
#    9. Open log anbd check contents should match data from fw messages sent earlier 
#         - Patient Information
#         - Treatment Prescription

  
import names
import re
from configuration                  import config, utility, navigation, application_init
from leahi_dialin.ui                import utils
from leahi_dialin.ui.td_messaging   import TD_Messaging
from leahi_dialin.common.td_defs    import TDOpModes,TDTreatmentStates
from leahi_dialin.common.msg_defs   import MsgIds, MsgFieldPositions
from leahi_dialin.protocols         import CAN
from pathlib                        import Path

td_simulator                    = TD_Messaging()
can_interface                   = td_simulator.can_interface

bloodSetAutoEject               = False

# handler for messages from UI to FW
def handle_blood_set_auto_eject_request(message, timestamp=0.0):
    """
    Called when the user requests to firmware from UI
    @return: None
    """
    global bloodSetAutoEject
    bloodSetAutoEject = True
    
def verify_values_tx_review():
    test.startSection("Verify the firmware response values in the End Treatment page")
    td_simulator.td_post_tx_logs_response(  vAccepted                                           = 1,
                                            vRejectionReason                                    = 0,   
                                            vBloodFlowRate                                      = config.blood_flow_prescribed,
                                            vBloodFlowRateActual                                = config.blood_flow_actual,
                                            vDialysateFlowRate                                  = config.dialysis_flow_prescribed,
                                            vDialysateFlowRateActual                            = config.dialysis_flow_actual,
                                            vTreatmentDuration                                  = 0,
                                            vTreatmentDurationActual                            = 0,
                                            vAcidConcentrateType                                = config.acid_concentrate,
                                            vAcidConcentrateTypeActual                          = config.acid_concentrate_actual,
                                            vBicarbonateCartridgeSize                           = 0,
                                            vBicarbonateCartridgeSizeActual                     = 40,
                                            vPotassiumConcentration                             = config.potassium_concentrate,
                                            vPotassiumConcentrationActual                       = config.potassium_concentrate_actual,
                                            vCalciumConcentration                               = config.calcium_concentrate,
                                            vCalciumConcentrationActual                         = config.calcium_concentrate_actual,
                                            vBicarbonateConcentration                           = config.bicarbonate_concentrate ,
                                            vBicarbonateConcentrationActual                     = config.bicarbonate_concentrate_actual,
                                            vSodiumConcentration                                = 0,
                                            vSodiumConcentrationActual                          = 0,
                                            vVitalsInterval                                     = 5,
                                            vVitalsIntervalActual                               = 10,
                                            vDialyzerType                                       = 0,
                                            vTreatmentStartEpoch                                = 9999,
                                            vTreatmentEndEpoch                                  = 9999,
                                            vFluidBolusVolume                                   = 0,
                                            vFluidBolusVolumeActual                             = 0,
                                            vHeparinType                                        = 0,
                                            vHeparinDeliveryDuration                            = 0,
                                            vHeparinDeliveryDurationActual                      = 0,
                                            vTreatmentModality                                  = 0,
                                            vTreatmentModalityActual                            = 0,
                                            vHDFOperatingMode                                   = 0,
                                            vHDFOperatingModeActual                             = 0,
                                            vHepatitisStatus                                    = 0,
                                            vDialysateTemperature                               = config.dialysate_temperature,
                                            vDialysateTemperatureActual                         = config.dialysate_temperature_actual,
                                            vDialysateVolumeUsed                                = config.dialysate_volume,
                                            vHeparinBolusVolume                                 = 13.0,
                                            vHeparinBolusVolumeActual                           = 14.0,
                                            vHeparinDispenseRate                                = 15.0,
                                            vHeparinDispenseRateActual                          = 16.0,
                                            vHeparinDeliveredVolume                             = 17.0,
                                            vUFVolume                                           = 18.0,
                                            vUFVolumeActual                                     = 19.0,
                                            vUFVolumeTarget                                     = 20.0,
                                            vUFRate                                             = 21.0,
                                            vUFRateActual                                       = 22.0,
                                            vUFRateTarget                                       = 0,
                                            vSubstitutionVolume                                 = 0,
                                            vSubstitutionVolumeActual                           = 0,
                                            vSubstitutionVolumeTarget                           = 0,
                                            vSubstitutionRate                                   = 0,
                                            vSubstitutionRateActual                             = 0,
                                            vSubstitutionRateTarget                             = 0,
                                            vIsoUfVolume                                        = 23.0,
                                            vIsoUfVolumeActual                                  = 24.0,
                                            vIsoUfVolumeTarget                                  = 25.0,
                                            vIsoUfRate                                          = 26.0,
                                            vIsoUfRateActual                                    = 27.0,
                                            vIsoUfRateTarget                                    = 28.0,
                                            vWaterSampleTestResult                              = 0)
    blood_flow_prescribed_obj = waitForObject(names.o_PostTreatmentBase_bloodFlowDiaysate_ReviewContainer)
    blood_flow_prescribed_value_obj = utility.findChildByText(blood_flow_prescribed_obj, "Blood Flow Rate")
    blood_flow_prescribed_initial_value = utility.findObjectById(blood_flow_prescribed_value_obj, "_initial")
    test.compare(str(blood_flow_prescribed_initial_value.text),str(config.blood_flow_prescribed), "Blood flow prescribed value should be"+str(config.blood_flow_prescribed))
    blood_flow_prescribed_actual_value = utility.findObjectById(blood_flow_prescribed_value_obj,"_actual")
    test.compare(str(blood_flow_prescribed_actual_value.text),str(config.blood_flow_actual), "Blood flow actual value should be"+ str(config.blood_flow_actual))
    dialysis_flow_value_obj = utility.findChildByText(blood_flow_prescribed_obj, "Dialysis Flow Rate")
    dialysis_flow_value_initial_value = utility.findObjectById(dialysis_flow_value_obj, "_initial")
    test.compare(str(dialysis_flow_value_initial_value.text),str(config.dialysis_flow_prescribed), "Dialysis flow prescribed value should be"+str(config.dialysis_flow_prescribed))
    dialysis_flow_value_actual_value = utility.findObjectById(dialysis_flow_value_obj,"_actual")
    test.compare(str(dialysis_flow_value_actual_value.text),str(config.dialysis_flow_actual), "Dialysis flow actual value should be"+ str(config.dialysis_flow_actual))
    dialyzer_type  = utility.findChildByText(blood_flow_prescribed_obj,"Dialyzer Type")
    test.compare(str(dialyzer_type.text),str(config.dialyzer_type), "Dialyzer type value should be"+ str(config.dialyzer_type))
    dialysate_temp_value_obj = utility.findChildByText(blood_flow_prescribed_obj, "Dialysate Temperature")
    dialysate_temp_initial_value = utility.findObjectById(dialysate_temp_value_obj, "_initial")
    test.compare(str(dialysate_temp_initial_value.text),str(config.dialysate_temperature), "Dialysate temperature value should be"+str(config.dialysate_temperature))
    dialysate_temp_actual_value = utility.findObjectById(dialysate_temp_value_obj,"_actual")
    test.compare(str(dialysate_temp_actual_value.text),str(config.dialysate_temperature_actual), "Dialysate temperature actual value should be"+ str(config.dialysate_temperature_actual))
    dialysate_volume_value_obj = utility.findChildByText(blood_flow_prescribed_obj, "Dialysate Volume Used")
    dialysate_volume_initial_value = utility.findObjectById(dialysate_volume_value_obj, "_initial")
    test.compare(f"{float(str(dialysate_volume_initial_value.text).strip()):.1f}",f"{float(str(config.dialysate_volume)):.1f}","Dialysate volume value should be " + str(config.dialysate_volume))
    mouseWheel(waitForObject(names.o_PostTreatmentBase_ScrollBar), 387, 510, 0, -45, Qt.NoModifier)
    potassium_concentrate_obj = waitForObject(names.o_PostTreatmentBase_concentrateSettings_ReviewContainer)
    potassium_concentrate_value_obj = utility.findChildByText(potassium_concentrate_obj, "Potassium Concentration")
    potassium_concentrate_initial_value = utility.findObjectById(potassium_concentrate_value_obj, "_initial")
    test.compare(str(potassium_concentrate_initial_value.text),str(config.potassium_concentrate), "Potassium concentrate value should be"+str(config.potassium_concentrate))
    potassium_concentrate_actual_value = utility.findObjectById(potassium_concentrate_value_obj,"_actual")
    test.compare(str(potassium_concentrate_actual_value.text),str(config.potassium_concentrate_actual), "Potassium concentrate actual value should be"+ str(config.potassium_concentrate_actual))
    calcium_concentrate_obj = waitForObject(names.o_PostTreatmentBase_concentrateSettings_ReviewContainer)
    calcium_concentrate_value_obj = utility.findChildByText(calcium_concentrate_obj, "Calcium Concentration")
    calcium_concentrate_initial_value = utility.findObjectById(calcium_concentrate_value_obj, "_initial")
    test.compare(str(calcium_concentrate_initial_value.text),str(config.calcium_concentrate), "Calcium concentrate value should be"+str(config.calcium_concentrate))
    calcium_concentrate_actual_value = utility.findObjectById(calcium_concentrate_value_obj,"_actual")
    test.compare(str(calcium_concentrate_actual_value.text),str(config.calcium_concentrate_actual), "Calcium concentrate actual value should be"+ str(config.calcium_concentrate_actual))
    bicarbonate_concentrate_obj = waitForObject(names.o_PostTreatmentBase_concentrateSettings_ReviewContainer)
    bicarbonate_concentrate_value_obj = utility.findChildByText(bicarbonate_concentrate_obj, "Bicarbonate Concentration")
    bicarbonate_concentrate_initial_value = utility.findObjectById(bicarbonate_concentrate_value_obj, "_initial")
    test.compare(str(bicarbonate_concentrate_initial_value.text),str(config.bicarbonate_concentrate), "Bicarbonate concentrate value should be"+str(config.bicarbonate_concentrate))
    bicarbonate_concentrate_actual_value = utility.findObjectById(bicarbonate_concentrate_value_obj,"_actual")
    test.compare(str(bicarbonate_concentrate_actual_value.text),str(config.bicarbonate_concentrate_actual), "Bicarbonate concentrate actual value should be"+ str(config.bicarbonate_concentrate_actual))

    test.endSection()
    
def keyboard_object_map_helper(text):
    """
        Method for setting custom object property's for keyboard keys
        @return: required object property's for keys
    """
    if text is not None:
        names.keyboard_input["text"] = text
        return names.keyboard_input
    else:
        test.log("Invalid ",text," for object.")
        names.o_keyboard_input["text"] = "Q"
    
def verify_valid_vitals_through_keypad(title_name,input_field_obj,expected_value, actual_value):
    """
        Tests verifies valid patient id set through application keyboard setup .
        @return: N/A
    """
    input_field = waitForObject(input_field_obj)
    mouseClick(input_field)
    
    #check the title
    title = waitForObjectExists(utility.setObjectText(text = title_name,obj =names.o_title_Text))
    test.compare(title_name, title.text, "Title text should be -> "+ str(title_name))
    
    for text in expected_value:
            keyboard_value = keyboard_object_map_helper(text)
            utils.waitForGUI(0.2)
            mouseClick(waitForObjectExists(keyboard_value))
            utils.waitForGUI(0.2)
        
    test.compare(actual_value, (input_field.text), "Value should be -> "+ str(actual_value))
    test.log("User successfully authenticated through patient id -> " + expected_value + "using keypad.")
     

def verify_log_file():
    test.startSection("Check the treatment log file")

    SYSTEM_PATH = application_init.configuration_folder_path() + "treatment"
    folder = Path(SYSTEM_PATH)

    files = [f for f in folder.iterdir() if f.is_file()]

    if not files:
        test.fail("No files found in treatment folder")
        test.endSection()
        return

    # Get latest file
    latest_file = max(files, key=lambda f: f.stat().st_mtime)
    test.log(f"Latest File: {latest_file.name}")

    # Example:
    # 20260812_2236_12345.txr
    # 20260812_2236_12345.txr.p
    match = re.match(
        r"(\d{8})_(\d{4})_(\d+)\.txr(?:\.p)?$",
        latest_file.name
    )

    if not match:
        test.fail(f"Invalid filename format: {latest_file.name}")
        test.endSection()
        return

    file_date = (
        f"{match.group(1)[0:4]}/"
        f"{match.group(1)[4:6]}/"
        f"{match.group(1)[6:8]} "
        f"{match.group(2)[0:2]}:"
        f"{match.group(2)[2:4]}"
    )

    # Serial number from filename only
    file_serial = match.group(3)

    test.log(f"Filename DateTime: {file_date}")
    test.log(f"Filename Serial Number: {file_serial}")

    patient_id = None
    treatment_start = None
    treatment_end = None

    try:
        with open(latest_file, "r", encoding="utf-8") as f:
            for line in f:

                parts = [p.strip() for p in line.strip().split(",")]

                if len(parts) < 2:
                    continue

                key = parts[0]
                value = parts[1].strip()

                # Exact match only
                if key == "Patient ID":
                    patient_id = value

                elif key == "Treatment Start DateTime":
                    treatment_start = value

                elif key == "Treatment End DateTime":
                    treatment_end = value

    except Exception as e:
        test.fail(f"Error reading file: {str(e)}")
        test.endSection()
        return

    test.log(f"Patient ID: {patient_id}")
    test.log(f"Treatment Start DateTime: {treatment_start}")
    test.log(f"Treatment End DateTime: {treatment_end}")

    expected_patient_id = "abcd"

    test.compare(
        patient_id,
        expected_patient_id,
        "Patient ID matches expected value"
    )

    test.compare(
        treatment_start,
        file_date,
        "Treatment Start DateTime matches filename datetime"
    )

    test.compare(
        treatment_end,
        file_date,
        "Treatment End DateTime matches filename datetime"
    )

    # Verify serial extracted from filename
    test.verify(
        file_serial is not None and file_serial != "",
        f"Serial number extracted from filename: {file_serial}"
    )

    test.endSection()
     

def main():
    utils.tstStart(__file__)
    test.startSection("Post-Treatment Foundation")

    if can_interface is None:
        test.fail("CAN Interface is not available. Stopping tests.")
        return

    channel_id = CAN.CanChannels.ui_to_td_ch_id
    # Register Blood Set Auto Eject Request
    message_id = MsgIds.MSG_ID_UI_ADJUST_DISPOSABLES_REMOVAL_CONFIRM_REQUEST.value
    can_interface.register_receiving_publication_function(
        channel_id, message_id, handle_blood_set_auto_eject_request
    )

    startApplication(utility.aut("-q"))

    td_simulator.td_operation_mode(TDOpModes.MODE_STAN.value)
    hemodialysis        = waitForObject(names.o_createHDTreatment_TouchRect)
    hemodialysis_btn    = utility.findChildByText(hemodialysis, "Hemodialysis")
    mouseClick(hemodialysis_btn)
    td_simulator.td_Treatment_Parameters_CreateRx(vRejectionReason =0)
    td_simulator.td_operation_mode(TDOpModes.MODE_PRET.value, 0)
    utility.verify_create_treatment_parameters()
    td_simulator.td_operation_mode(TDOpModes.MODE_TREA.value)
    td_simulator.td_tx_state(TDTreatmentStates.TREATMENT_DIALYSIS_STATE.value ,
                    0 ,
                    0 ,
                    0 ,
                    0 ,
                    0 ,
                    0 ,
                    0 ,
                    0 ,
                    0)
    
    parent_obj  = waitForObject(names.o_headerButtonRow_Row)
    headerbar_vitals = utility.findObjectById(parent_obj, "_vitalsButton")
    mouseClick(headerbar_vitals)
    td_simulator.td_pressures_widen_adjustment_response(vRejectionReason=0)
    td_simulator.td_vitals(systolic = 80, 
        diastolic   = 60, 
        heartRate   = 140 )
    td_simulator.td_vitals(systolic = 85, 
        diastolic   = 75, 
        heartRate   = 180 )
    
    mouseClick(headerbar_vitals)
    verify_valid_vitals_through_keypad(config.SYSTOLIC,names.o_bloodPressureSystolic_TextEntry,config.MIN_SYSTOLIC,config.MIN_SYSTOLIC)
    verify_valid_vitals_through_keypad(config.DIASTOLIC,names.o_bloodPressureDiastolic_TextEntry,config.MIN_DIASTOLIC,config.MIN_DIASTOLIC)
    verify_valid_vitals_through_keypad(config.HEARTRATE, names.o_heartRate_TextEntry, config.MIN_HEARTRATE, config.MIN_HEARTRATE)
    mouseClick(waitForObject(names.o_confirm_button))
    td_simulator.td_treatment_log_alarm(alarm_id   = 2, 
                                        parameter1 = 48.0, 
                                        parameter2 = 56.0)
    
    td_simulator.td_treatment_log_event(event_id  = 3, 
                                        old_value = 22.0, 
                                        new_value = 79.0)
    td_simulator.td_treatment_log_average_data( blood_flow_rate         = 60.0,
                                                dialysate_flow_rate     = 80.0,
                                                uf_flow_rate            = 70.0,
                                                arterialPressure        = 120.0,
                                                venousPressure          = 100.0,
                                                tmpPressure             = 90.0,
                                                dialysate_temp          = 40.0)
    
    td_simulator.td_versions(major   = 0,  minor     = 0, micro     = 0,  build= 0,
                             fpga_id = 0,  fpga_major= 0, fpga_minor= 0, fpga_lab= 0,
                             compatibility_rev= 0) 
    
    td_simulator.td_serial(serial  = "54321")
    
    td_simulator.td_operation_mode(TDOpModes.MODE_POST.value)
    post_treatment = utility.get_object_from_names(names.o_PostTreatmentStack_PostTreatmentStack)
    mouseClick(waitForObject(utility.findChildByText(post_treatment, config.CONTINUE), 3000))
    td_simulator.td_patient_disconnect_confirm_response(vAccepted  = 1, 
                                                  vRejectionReason = 0)
    mouseClick(waitForObject(utility.findChildByText(post_treatment, config.CONTINUE), 3000))
    mouseClick(waitForObject(utility.findChildByText(post_treatment, config.AUTO_EJECT), 3000))
    test.verify( waitFor(lambda: bloodSetAutoEject == True, 3000),"Testing UI -> TD message Auto Eject",)
    td_simulator.td_blood_set_auto_eject_response(vAccepted  = 1, 
                                                  vRejectionReason = 0)
    
    
    verify_values_tx_review()
    verify_log_file()
        
    test.endSection()
    utils.tstDone()