medicafe 0.250818.0__py3-none-any.whl → 0.250819.1__py3-none-any.whl

MediLink/MediLink_837p_encoder_library.py

@@ -147,6 +147,27 @@ if MediLink_837p_utilities:
     prompt_for_insurance_selection = MediLink_837p_utilities.prompt_for_insurance_selection
     build_nm1_segment = MediLink_837p_utilities.build_nm1_segment
 
+# -----------------------------------------------------------------------------
+# Test Mode Utilities
+# -----------------------------------------------------------------------------
+def _is_test_mode(config):
+    """
+    Determine if test mode is enabled. Accepts either the full config
+    (with 'MediLink_Config') or the MediLink subset config.
+    """
+    try:
+        if isinstance(config, dict):
+            # Prefer direct MediLink subset key
+            if config.get('TestMode', False):
+                return True
+            # Fallback: full config structure
+            medi = config.get('MediLink_Config', {})
+            if isinstance(medi, dict) and medi.get('TestMode', False):
+                return True
+    except Exception:
+        pass
+    return False
+
 
 # Constructs the ST segment for transaction set.
 def create_st_segment(transaction_set_control_number):
@@ -162,6 +183,14 @@ def create_bht_segment(parsed_data):
 def create_hl_billing_provider_segment():
     return "HL*1**20*1~"
 
+# Constructs the HL segment for subscriber [hierarchical level (HL*2)]
+def create_hl_subscriber_segment():
+    """
+    Returns the subscriber HL segment. Kept for backward compatibility with
+    MediLink_837p_encoder.py which expects this function.
+    """
+    return ["HL*2*1*22*0~"]
+
 # Constructs the NM1 segment for billing provider and includes address and Tax ID.
 def create_nm1_billing_provider_segment(config, endpoint):
     endpoint_config = config.get('endpoints', {}).get(endpoint.upper(), {})
@@ -169,11 +198,24 @@ def create_nm1_billing_provider_segment(config, endpoint):
     # Billing provider details
     billing_provider_entity_code = endpoint_config.get('billing_provider_entity_code', '85')
     billing_provider_npi_qualifier = endpoint_config.get('billing_provider_npi_qualifier', 'XX')
-    #billing_provider_lastname = endpoint_config.get('billing_provider_lastname', config.get('default_billing_provider_name', 'DEFAULT NAME'))
-    #billing_provider_firstname = endpoint_config.get('billing_provider_firstname', '')
-    billing_provider_lastname = config.get('billing_provider_lastname', config.get('default_billing_provider_name', 'DEFAULT NAME'))
+    # Resolve required values with TestMode-aware enforcement
+    billing_provider_lastname = legacy_require_config_value(
+        [config, endpoint_config],
+        'billing_provider_lastname',
+        config.get('default_billing_provider_name', 'DEFAULT NAME'),
+        '2010AA Billing Provider Last Name',
+        config,
+        endpoint
+    )
     billing_provider_firstname = config.get('billing_provider_firstname', '')
-    billing_provider_npi = endpoint_config.get('billing_provider_npi', config.get('default_billing_provider_npi', 'DEFAULT NPI'))
+    billing_provider_npi = legacy_require_config_value(
+        [endpoint_config, config],
+        'billing_provider_npi',
+        config.get('default_billing_provider_npi', 'DEFAULT NPI'),
+        '2010AA Billing Provider NPI',
+        config,
+        endpoint
+    )
     
     # Determine billing_entity_type_qualifier based on the presence of billing_provider_firstname
     billing_entity_type_qualifier = '1' if billing_provider_firstname else '2' 
@@ -191,27 +233,27 @@ def create_nm1_billing_provider_segment(config, endpoint):
     # Construct address segments
     address_segments = []
     if config.get('billing_provider_address'):
+        addr = legacy_require_config_value([config], 'billing_provider_address', 'NO ADDRESS', '2010AA Billing Address', config, endpoint)
+        city = legacy_require_config_value([config], 'billing_provider_city', 'NO CITY', '2010AA Billing City', config, endpoint)
+        state = legacy_require_config_value([config], 'billing_provider_state', 'NO STATE', '2010AA Billing State', config, endpoint)
+        zip_code = legacy_require_config_value([config], 'billing_provider_zip', 'NO ZIP', '2010AA Billing ZIP', config, endpoint)
         # N3 segment for address line
-        address_segments.append("N3*{}~".format(config.get('billing_provider_address', 'NO ADDRESS')))
+        address_segments.append("N3*{}~".format(addr))
         # N4 segment for City, State, ZIP
-        address_segments.append("N4*{}*{}*{}~".format(
-            config.get('billing_provider_city', 'NO CITY'), 
-            config.get('billing_provider_state', 'NO STATE'), 
-            config.get('billing_provider_zip', 'NO ZIP')
-        ))
+        address_segments.append("N4*{}*{}*{}~".format(city, state, zip_code))
     
     # Assuming Tax ID is part of the same loop, otherwise move REF segment to the correct loop
-    ref_segment = "REF*EI*{}~".format(config.get('billing_provider_tin', 'NO TAX ID'))
+    billing_tin = legacy_require_config_value([config], 'billing_provider_tin', 'NO TAX ID', '2010AA Billing TIN', config, endpoint)
+    ref_segment = "REF*EI*{}~".format(billing_tin)
     
-    # Construct PRV segment if provider taxonomy is needed, are these just for Medicaid??
+    # Construct PRV segment if provider taxonomy is needed
     #prv_segment = ""
     #if config.get('billing_provider_taxonomy'):
     #    prv_segment = "PRV*BI*PXC*{}~".format(config.get('billing_provider_taxonomy'))
     
-    # Combine all the segments in the correct order, I think the PRV goes after the address and/or after ref
     segments = [nm1_segment]
-    #if prv_segment:
-    #    segments.append(prv_segment)
+    # if prv_segment:
+    #     segments.append(prv_segment)
     segments.extend(address_segments)
     segments.append(ref_segment)
     
@@ -223,12 +265,12 @@ def create_service_facility_location_npi_segment(config):
     Constructs segments for the service facility location, including the NM1 segment for identification
     and accompanying N3 and N4 segments for address details.
     """
-    facility_npi = config.get('service_facility_npi', 'DEFAULT FACILITY NPI')
-    facility_name = config.get('service_facility_name', 'DEFAULT FACILITY NAME')
-    address_line_1 = config.get('service_facility_address', 'NO ADDRESS')
-    city = config.get('service_facility_city', 'NO CITY')
-    state = config.get('service_facility_state', 'NO STATE')
-    zip_code = config.get('service_facility_zip', 'NO ZIP')
+    facility_npi = legacy_require_config_value([config], 'service_facility_npi', 'DEFAULT FACILITY NPI', '2310C Service Facility NPI', config)
+    facility_name = legacy_require_config_value([config], 'service_facility_name', 'DEFAULT FACILITY NAME', '2310C Service Facility Name', config)
+    address_line_1 = legacy_require_config_value([config], 'service_facility_address', 'NO ADDRESS', '2310C Service Facility Address', config)
+    city = legacy_require_config_value([config], 'service_facility_city', 'NO CITY', '2310C Service Facility City', config)
+    state = legacy_require_config_value([config], 'service_facility_state', 'NO STATE', '2310C Service Facility State', config)
+    zip_code = legacy_require_config_value([config], 'service_facility_zip', 'NO ZIP', '2310C Service Facility ZIP', config)
 
     # NM1 segment for facility identification
     nm1_segment = "NM1*77*2*{}*****XX*{}~".format(facility_name, facility_npi)
@@ -243,31 +285,25 @@ def create_service_facility_location_npi_segment(config):
 def create_1000A_submitter_name_segment(patient_data, config, endpoint):
     """
     Creates the 1000A submitter name segment, including the PER segment for contact information.
-
-    Args:
-        patient_data (dict): Enriched patient data containing payer information.
-        config (dict): Configuration settings.
-        endpoint (str): Intended Endpoint for resolving submitter information.
-
-    Returns:
-        list: A list containing the NM1 segment for the submitter name and the PER segment for contact information.
     """
     endpoint_config = config.get('endpoints', {}).get(endpoint.upper(), {})
     submitter_id_qualifier = endpoint_config.get('submitter_id_qualifier', '46')  # '46' for ETIN or 'XX' for NPI
-    submitter_name = endpoint_config.get('nm_103_value', 'DEFAULT NAME')  # Default name if not in config
+    
+    # Required submitter name
+    submitter_name = legacy_require_config_value([endpoint_config, config], 'nm_103_value', 'DEFAULT NAME', '1000A Submitter Name', config, endpoint)
     
     # Extract payer_id from patient_data
     payer_id = patient_data.get('payer_id', '')
     
     # Check if payer_id is Florida Blue (00590 or BCBSF) and assign submitter_id accordingly
     if payer_id in ['00590', 'BCBSF']:
-        submitter_id = endpoint_config.get('nm_109_bcbs', 'DEFAULT BCBSF ID')
+        submitter_id = legacy_require_config_value([endpoint_config], 'nm_109_bcbsf', 'DEFAULT BCBSF ID', '1000A Submitter ID (BCBSF)', config, endpoint)
     else:
-        submitter_id = endpoint_config.get('nm_109_value', 'DEFAULT ID')  # Default ID if not specified in endpoint
+        submitter_id = legacy_require_config_value([endpoint_config], 'nm_109_value', 'DEFAULT ID', '1000A Submitter ID', config, endpoint)
     
-    # Submitter contact details
-    contact_name = config.get('submitter_name', 'NONE')
-    contact_telephone_number = config.get('submitter_tel', 'NONE')
+    # Submitter contact details (required)
+    contact_name = legacy_require_config_value([config], 'submitter_name', 'NONE', '1000A Submitter Contact Name', config, endpoint)
+    contact_telephone_number = legacy_require_config_value([config], 'submitter_tel', 'NONE', '1000A Submitter Contact Phone', config, endpoint)
     
     # Get submitter first name to determine entity type qualifier
     submitter_first_name = config.get('submitter_first_name', '')
@@ -290,21 +326,15 @@ def create_1000A_submitter_name_segment(patient_data, config, endpoint):
     
     # Construct PER segment for the submitter's contact information
     per_segment = "PER*IC*{}*TE*{}~".format(contact_name, contact_telephone_number)
-    
     return [nm1_segment, per_segment]
 
 # Constructs the NM1 segment for the receiver (1000B).
 def create_1000B_receiver_name_segment(config, endpoint):
-    # Retrieve endpoint specific configuration
     endpoint_config = config.get('endpoints', {}).get(endpoint.upper(), {})
-
-    # Set the entity identifier code to '40' for receiver and qualifier to '46' for EDI, 
-    # unless specified differently in the endpoint configuration.
     receiver_entity_code = '40'
     receiver_id_qualifier = endpoint_config.get('receiver_id_qualifier', '46')
-    receiver_name = endpoint_config.get('receiver_name', 'DEFAULT RECEIVER NAME')
-    receiver_edi = endpoint_config.get('receiver_edi', 'DEFAULT EDI')
-    
+    receiver_name = legacy_require_config_value([endpoint_config], 'receiver_name', 'DEFAULT RECEIVER NAME', '1000B Receiver Name', config, endpoint)
+    receiver_edi = legacy_require_config_value([endpoint_config], 'receiver_edi', 'DEFAULT EDI', '1000B Receiver EDI', config, endpoint)
     return "NM1*{entity_code}*2*{receiver_name}*****{id_qualifier}*{receiver_edi}~".format(
         entity_code=receiver_entity_code,
         receiver_name=receiver_name,
@@ -312,6 +342,180 @@ def create_1000B_receiver_name_segment(config, endpoint):
         receiver_edi=receiver_edi
     )
 
+def create_nm1_payto_address_segments(config):
+    """
+    Constructs the NM1 segment for the Pay-To Address, N3 for street address, and N4 for city, state, and ZIP.
+    This is used if the Pay-To Address is different from the Billing Provider Address.
+    """
+    payto_provider_name = legacy_require_config_value([config], 'payto_provider_name', 'DEFAULT PAY-TO NAME', '2010AB Pay-To Name', config)
+    payto_address = legacy_require_config_value([config], 'payto_address', 'DEFAULT PAY-TO ADDRESS', '2010AB Pay-To Address', config)
+    payto_city = legacy_require_config_value([config], 'payto_city', 'DEFAULT PAY-TO CITY', '2010AB Pay-To City', config)
+    payto_state = legacy_require_config_value([config], 'payto_state', 'DEFAULT PAY-TO STATE', '2010AB Pay-To State', config)
+    payto_zip = legacy_require_config_value([config], 'payto_zip', 'DEFAULT PAY-TO ZIP', '2010AB Pay-To ZIP', config)
+    
+    nm1_segment = "NM1*87*2*{}~".format(payto_provider_name)
+    n3_segment = "N3*{}~".format(payto_address)
+    n4_segment = "N4*{}*{}*{}~".format(payto_city, payto_state, payto_zip)
+    return [nm1_segment, n3_segment, n4_segment]
+
+# Constructs the N3 and N4 segments for the payer's address.
+def create_payer_address_segments(config):
+    """
+    Constructs the N3 and N4 segments for the payer's address.
+    
+    """
+    payer_address_line_1 = config.get('payer_address_line_1', '')
+    payer_city = config.get('payer_city', '')
+    payer_state = config.get('payer_state', '')
+    payer_zip = config.get('payer_zip', '')
+
+    n3_segment = "N3*{}~".format(payer_address_line_1)
+    n4_segment = "N4*{}*{}*{}~".format(payer_city, payer_state, payer_zip)
+
+    return [n3_segment, n4_segment]
+
+# Constructs the PRV segment for billing provider.
+def create_billing_prv_segment(config, endpoint):
+    if endpoint.lower() == 'optumedi':
+        return "PRV*BI*PXC*{}~".format(config['billing_provider_taxonomy'])
+    return ""
+
+# (2000B Loop) Constructs the SBR segment for subscriber based on parsed data and configuration.
+def create_sbr_segment(config, parsed_data, endpoint):
+    # Determine the payer responsibility sequence number code based on the payer type
+    # If the payer is Medicare, use 'P' (Primary)
+    # If the payer is not Medicare and is primary insurance, use 'P' (Primary)
+    # If the payer is secondary insurance after Medicare, use 'S' (Secondary)
+    # Assume everything is Primary for now.
+    responsibility_code = 'S' if parsed_data.get('claim_type') == 'secondary' else 'P'
+
+    # Insurance Type Code (SBR09)
+    insurance_type_code = insurance_type_selection(parsed_data)
+
+    # Prefer Medicare-specific type codes when determinable and COB helpers are available
+    if COB is not None:
+        try:
+            medicare_type = COB.determine_medicare_payer_type(parsed_data, config)
+            if medicare_type:
+                insurance_type_code = medicare_type  # MB or MA
+        except Exception as e:
+            MediLink_ConfigLoader.log("COB determine_medicare_payer_type error: {}".format(str(e)), level="WARNING")
+
+    # Construct the SBR segment using the determined codes
+    sbr_segment = "SBR*{responsibility_code}*18*******{insurance_type_code}~".format(
+        responsibility_code=responsibility_code,
+        insurance_type_code=insurance_type_code
+    )
+    return sbr_segment
+
+def insurance_type_selection(parsed_data):
+    """
+    Enhanced insurance type selection with optional API integration and safe fallbacks.
+    Maintains exact same signature as existing implementation.
+    
+    TODO (HIGH SBR09) Finish making this function. 
+    This should  eventually integrate into a menu upstream. This menu flow probably needs to be alongside the suggested endpoint flow.
+    For now let's make a menu here and then figure out the automated/API method to getting this per patient as there are no
+    useful historical patterns other than to say that the default should be PPO (12), then CI, then FI as most common options, 
+    followed by the rest. 
+    
+    Present a user-selectable menu of insurance types based on predefined codes.
+    User needs to input the desired 2 character code for that patient or default to PPO.
+    
+    Currently implements a simple text-based selection menu to choose
+    an insurance type for a patient. The default selection is '12' for PPO, but the user
+    can input other codes as per the options listed. This initial implementation uses
+    simple input/output functions for selection and can be replaced in the future by a 
+    more dynamic interface or API-driven selection method.
+    """
+    MediLink_ConfigLoader.log("insurance_type_selection(parsed_data): {}".format(parsed_data), level="DEBUG")
+    
+    # Try enhanced selection with safe fallback
+    if safe_insurance_type_selection:
+        try:
+            return safe_insurance_type_selection(parsed_data, _original_insurance_type_selection_logic)
+        except Exception as e:
+            MediLink_ConfigLoader.log("Error in enhanced insurance selection: {}. Using original logic".format(str(e)), level="ERROR")
+            return _original_insurance_type_selection_logic(parsed_data)
+    else:
+        MediLink_ConfigLoader.log("Enhanced insurance selection not available. Using original logic", level="INFO")
+        return _original_insurance_type_selection_logic(parsed_data)
+
+def _original_insurance_type_selection_logic(parsed_data):
+    """
+    Original insurance type selection logic extracted to preserve exact behavior.
+    This ensures backward compatibility when enhanced features are not available.
+    """
+    # Check if insurance type is already assigned and is valid
+    insurance_type_code = parsed_data.get('insurance_type')
+    if insurance_type_code and len(insurance_type_code) == 2 and insurance_type_code.isalnum():
+        MediLink_ConfigLoader.log("Insurance type already assigned: {}".format(insurance_type_code), level="DEBUG")
+        return insurance_type_code
+    elif insurance_type_code:
+        MediLink_ConfigLoader.log("Invalid insurance type: {}".format(insurance_type_code), level="WARNING")
+    
+    print("\nInsurance Type Validation Error: Select the insurance type for patient {}: ".format(parsed_data['LAST']))
+
+    # Retrieve insurance options with codes and descriptions
+    config, _ = MediLink_ConfigLoader.load_configuration()
+    try:
+        from MediCafe.core_utils import extract_medilink_config
+        medi = extract_medilink_config(config)
+        insurance_options = medi.get('insurance_options', {})
+    except Exception:
+        insurance_options = {}
+
+    # If COB library is available, augment options with Medicare codes (MB/MA/MC)
+    if COB is not None:
+        try:
+            insurance_options = COB.get_enhanced_insurance_options(config)
+        except Exception as e:
+            MediLink_ConfigLoader.log("COB get_enhanced_insurance_options error: {}".format(str(e)), level="WARNING")
+    
+    # TODO (COB ENHANCEMENT): Enhanced insurance options for Medicare support
+    # See MediLink_837p_cob_library.get_enhanced_insurance_options() for Medicare codes:
+    # - MB: Medicare Part B
+    # - MA: Medicare Advantage  
+    # - MC: Medicare Part C
+
+    def prompt_display_insurance_options():
+        # Prompt to display full list
+        display_full_list = input("Do you want to see the full list of insurance options? (yes/no): ").strip().lower()
+
+        # Display full list if user confirms
+        if display_full_list in ['yes', 'y'] and MediLink_Display_Utils:
+            MediLink_Display_Utils.display_insurance_options(insurance_options)
+
+    # Horrible menu
+    prompt_display_insurance_options()
+    
+    # Default selection
+    insurance_type_code = '12'
+
+    # User input for insurance type
+    user_input = input("Enter the 2-character code for the insurance type (or press Enter to default to '12' for PPO): ").strip().upper()
+
+    # Input validation and assignment
+    if user_input:
+        # Basic format validation
+        if len(user_input) > 3 or not user_input.isalnum():
+            print("Invalid format: Insurance codes should be 1-3 alphanumeric characters. Defaulting to PPO.")
+        elif user_input in insurance_options:
+            insurance_type_code = user_input
+            print("Selected: {} - {}".format(user_input, insurance_options[user_input]))
+        else:
+            # User wants to use a code not in options - confirm with them
+            confirm = input("Code '{}' not found in options. Use it anyway? (y/n): ".format(user_input)).strip().lower()
+            if confirm in ['y', 'yes']:
+                insurance_type_code = user_input
+                print("Using code: {}".format(user_input))
+            else:
+                print("Defaulting to PPO (Preferred Provider Organization)")
+    else:
+        print("Using default: PPO (Preferred Provider Organization)")
+
+    return insurance_type_code
+
 def payer_id_to_payer_name(parsed_data, config, endpoint, crosswalk, client):
     """
     Preprocesses payer information from parsed data and enriches parsed_data with the payer name and ID.
@@ -393,6 +597,19 @@ def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parse
         print("If the Payer ID appears correct, you may skip the correction and force-continue with this one.")
         print("\nPlease check the Payer ID in the Crosswalk and the initial \ndata source (e.g., Carol's CSV) as needed.")
         print("If unsure, llamar a Dani for guidance on manual corrections.")
+        
+        # In Test Mode, avoid blocking prompts and proceed with a placeholder name after API failure
+        if _is_test_mode(config):
+            try:
+                if payer_id in crosswalk.get('payer_id', {}):
+                    _nm = crosswalk['payer_id'][payer_id].get('name', 'TEST INSURANCE')
+                    print("TEST MODE: Using crosswalk payer name '{}' after API failure".format(_nm))
+                    return _nm
+            except Exception:
+                pass
+            MediLink_ConfigLoader.log("[TEST MODE] API resolution failed; using placeholder payer name", config, level="WARNING")
+            print("TEST MODE: Using placeholder payer name 'TEST INSURANCE' after API failure")
+            return 'TEST INSURANCE'
     
         # Step 4: Integrate user input logic
         user_decision = input("\nType 'FORCE' to force-continue with the Medisoft name, or press Enter to pause processing and make corrections: ").strip().lower()
@@ -436,7 +653,7 @@ def resolve_payer_name(payer_id, config, primary_endpoint, insurance_name, parse
                         print("User did not confirm the standard insurance name. Manual intervention is required.")
                         MediLink_ConfigLoader.log("User did not confirm the standard insurance name. Manual intervention is required.", config, level="CRITICAL")
                         
-                        # ✅ FIXED: CRITICAL ISSUE - Implemented recovery path instead of exit(1)
+                        #   FIXED: CRITICAL ISSUE - Implemented recovery path instead of exit(1)
                         # The insurance name confirmation is primarily a sanity check to verify the API recognizes the payer ID,
                         # not a critical validation for claim processing. The payer name is not used in the crosswalk or in the
                         # actual claims once they are built. This implementation provides a recovery path instead of halting.
@@ -568,6 +785,10 @@ def map_insurance_name_to_payer_id(insurance_name, config, client, crosswalk):
             
             # Ensure crosswalk is initialized and 'payer_id' key is available
             if 'payer_id' not in crosswalk:
+                if _is_test_mode(config):
+                    MediLink_ConfigLoader.log("[TEST MODE] Crosswalk 'payer_id' missing. Using hardcoded fallback 'TEST01'", config, level="WARNING")
+                    print("TEST MODE: Crosswalk 'payer_id' missing. Using fallback payer ID 'TEST01'")
+                    return 'TEST01'
                 raise ValueError("Crosswalk 'payer_id' not found. Please run MediBot_Preprocessor.py with the --update-crosswalk argument.")
 
         # Load insurance data from MAINS to get insurance ID
@@ -580,31 +801,71 @@ def map_insurance_name_to_payer_id(insurance_name, config, client, crosswalk):
             closest_matches = find_closest_insurance_matches(insurance_name, insurance_to_id)
             
             if closest_matches:
-                # Prompt user to select from closest matches
-                selected_insurance_name = prompt_for_insurance_selection(insurance_name, closest_matches, config)
-                
-                if selected_insurance_name:
-                    # Use the selected insurance name
-                    medisoft_id = insurance_to_id.get(selected_insurance_name)
-                    MediLink_ConfigLoader.log("Using selected insurance name '{}' for original '{}'".format(selected_insurance_name, insurance_name), config, level="INFO")
+                # In Test Mode, auto-select the best match to avoid interaction
+                if _is_test_mode(config):
+                    try:
+                        auto_name = closest_matches[0][0]
+                        medisoft_id = insurance_to_id.get(auto_name)
+                        MediLink_ConfigLoader.log("[TEST MODE] Auto-selected closest insurance match '{}' for original '{}'".format(auto_name, insurance_name), config, level="WARNING")
+                    except Exception:
+                        medisoft_id = None
                 else:
-                    # User chose manual intervention
-                    error_message = "CLAIM SUBMISSION CANCELLED: Insurance name '{}' not found in MAINS and user chose manual intervention.".format(insurance_name)
-                    MediLink_ConfigLoader.log(error_message, config, level="WARNING")
-                    print("\n" + "="*80)
-                    print("CLAIM SUBMISSION CANCELLED: MANUAL INTERVENTION REQUIRED")
-                    print("="*80)
-                    print("\nThe system cannot automatically process this claim because:")
-                    print("- Insurance name '{}' was not found in the MAINS database".format(insurance_name))
-                    print("- Without a valid insurance mapping, the claim cannot be submitted")
-                    print("\nTo proceed with this claim, you need to:")
-                    print("1. Verify the correct insurance company name")
-                    print("2. Ensure the insurance company is in your Medisoft system")
-                    print("3. Restart the claim submission process once the insurance is properly configured")
-                    print("="*80)
-                    raise ValueError(error_message)
+                    # Prompt user to select from closest matches
+                    selected_insurance_name = prompt_for_insurance_selection(insurance_name, closest_matches, config)
+                    
+                    if selected_insurance_name:
+                        # Use the selected insurance name
+                        medisoft_id = insurance_to_id.get(selected_insurance_name)
+                        MediLink_ConfigLoader.log("Using selected insurance name '{}' for original '{}'".format(selected_insurance_name, insurance_name), config, level="INFO")
+                    else:
+                        # Test Mode: fallback to a safe placeholder payer ID and continue
+                        if _is_test_mode(config):
+                            try:
+                                first_key = None
+                                for _k in crosswalk.get('payer_id', {}).keys():
+                                    first_key = _k
+                                    break
+                                if first_key:
+                                    MediLink_ConfigLoader.log("[TEST MODE] Using fallback payer ID '{}' for insurance '{}'".format(first_key, insurance_name), config, level="WARNING")
+                                    print("TEST MODE: Using fallback payer ID '{}' for insurance '{}'".format(first_key, insurance_name))
+                                    return first_key
+                            except Exception:
+                                pass
+                            MediLink_ConfigLoader.log("[TEST MODE] Using hardcoded fallback payer ID 'TEST01' for insurance '{}'".format(insurance_name), config, level="WARNING")
+                            print("TEST MODE: Using hardcoded fallback payer ID 'TEST01' for insurance '{}'".format(insurance_name))
+                            return 'TEST01'
+                        # User chose manual intervention
+                        error_message = "CLAIM SUBMISSION CANCELLED: Insurance name '{}' not found in MAINS and user chose manual intervention.".format(insurance_name)
+                        MediLink_ConfigLoader.log(error_message, config, level="WARNING")
+                        print("\n" + "="*80)
+                        print("CLAIM SUBMISSION CANCELLED: MANUAL INTERVENTION REQUIRED")
+                        print("="*80)
+                        print("\nThe system cannot automatically process this claim because:")
+                        print("- Insurance name '{}' was not found in the MAINS database".format(insurance_name))
+                        print("- Without a valid insurance mapping, the claim cannot be submitted")
+                        print("\nTo proceed with this claim, you need to:")
+                        print("1. Verify the correct insurance company name")
+                        print("2. Ensure the insurance company is in your Medisoft system")
+                        print("3. Restart the claim submission process once the insurance is properly configured")
+                        print("="*80)
+                        raise ValueError(error_message)
             else:
                 # No matches found in MAINS
+                if _is_test_mode(config):
+                    try:
+                        first_key = None
+                        for _k in crosswalk.get('payer_id', {}).keys():
+                            first_key = _k
+                            break
+                        if first_key:
+                            MediLink_ConfigLoader.log("[TEST MODE] No MAINS match. Using fallback payer ID '{}' for '{}'".format(first_key, insurance_name), config, level="WARNING")
+                            print("TEST MODE: No MAINS match. Using fallback payer ID '{}' for '{}'".format(first_key, insurance_name))
+                            return first_key
+                    except Exception:
+                        pass
+                    MediLink_ConfigLoader.log("[TEST MODE] No MAINS match. Using hardcoded fallback payer ID 'TEST01' for '{}'".format(insurance_name), config, level="WARNING")
+                    print("TEST MODE: No MAINS match. Using hardcoded fallback payer ID 'TEST01' for '{}'".format(insurance_name))
+                    return 'TEST01'
                 error_message = "CLAIM SUBMISSION FAILED: Cannot find Medisoft ID for insurance name: '{}'. No similar matches found in MAINS database.".format(insurance_name)
                 MediLink_ConfigLoader.log(error_message, config, level="ERROR")
                 print("\n" + "="*80)
@@ -641,10 +902,25 @@ def map_insurance_name_to_payer_id(insurance_name, config, client, crosswalk):
 
         # Handle the case where no payer ID is found
         if payer_id is None:
-            error_message = "No payer ID found for Medisoft ID: {}.".format(medisoft_id)
-            MediLink_ConfigLoader.log(error_message, config, level="ERROR")
-            print(error_message)
-            payer_id = handle_missing_payer_id(insurance_name, config, crosswalk, client)
+            if _is_test_mode(config):
+                try:
+                    first_key = None
+                    for _k in crosswalk.get('payer_id', {}).keys():
+                        first_key = _k
+                        break
+                    if first_key:
+                        MediLink_ConfigLoader.log("[TEST MODE] No payer ID found for Medisoft ID {}. Using fallback '{}'".format(medisoft_id, first_key), config, level="WARNING")
+                        payer_id = first_key
+                    else:
+                        MediLink_ConfigLoader.log("[TEST MODE] No payer ID found for Medisoft ID {}. Using hardcoded 'TEST01'".format(medisoft_id), config, level="WARNING")
+                        payer_id = 'TEST01'
+                except Exception:
+                    payer_id = 'TEST01'
+            else:
+                error_message = "No payer ID found for Medisoft ID: {}.".format(medisoft_id)
+                MediLink_ConfigLoader.log(error_message, config, level="ERROR")
+                print(error_message)
+                payer_id = handle_missing_payer_id(insurance_name, config, crosswalk, client)
 
         if payer_id is None:
             raise ValueError("Payer ID cannot be None after all checks.")
@@ -661,195 +937,6 @@ def map_insurance_name_to_payer_id(insurance_name, config, client, crosswalk):
             MediLink_ConfigLoader.log(error_message, config, level="ERROR")
             raise e
 
-def create_nm1_payto_address_segments(config):
-    """
-    Constructs the NM1 segment for the Pay-To Address, N3 for street address, and N4 for city, state, and ZIP.
-    This is used if the Pay-To Address is different from the Billing Provider Address.
-    """
-    payto_provider_name = config.get('payto_provider_name', 'DEFAULT PAY-TO NAME')
-    payto_address = config.get('payto_address', 'DEFAULT PAY-TO ADDRESS')
-    payto_city = config.get('payto_city', 'DEFAULT PAY-TO CITY')
-    payto_state = config.get('payto_state', 'DEFAULT PAY-TO STATE')
-    payto_zip = config.get('payto_zip', 'DEFAULT PAY-TO ZIP')
-
-    nm1_segment = "NM1*87*2*{}~".format(payto_provider_name)  # '87' indicates Pay-To Provider
-    n3_segment = "N3*{}~".format(payto_address)
-    n4_segment = "N4*{}*{}*{}~".format(payto_city, payto_state, payto_zip)
-
-    return [nm1_segment, n3_segment, n4_segment]
-
-def create_payer_address_segments(config):
-    """
-    Constructs the N3 and N4 segments for the payer's address.
-    
-    """
-    payer_address_line_1 = config.get('payer_address_line_1', '')
-    payer_city = config.get('payer_city', '')
-    payer_state = config.get('payer_state', '')
-    payer_zip = config.get('payer_zip', '')
-
-    n3_segment = "N3*{}~".format(payer_address_line_1)
-    n4_segment = "N4*{}*{}*{}~".format(payer_city, payer_state, payer_zip)
-
-    return [n3_segment, n4_segment]
-
-# Constructs the PRV segment for billing provider.
-def create_billing_prv_segment(config, endpoint):
-    if endpoint.lower() == 'optumedi':
-        return "PRV*BI*PXC*{}~".format(config['billing_provider_taxonomy'])
-    return ""
-
-# Constructs the HL segment for subscriber [hierarchical level (HL*2)]
-def create_hl_subscriber_segment():
-    return ["HL*2*1*22*0~"]
-
-# (2000B Loop) Constructs the SBR segment for subscriber based on parsed data and configuration.
-def create_sbr_segment(config, parsed_data, endpoint):
-    # Determine the payer responsibility sequence number code based on the payer type
-    # If the payer is Medicare, use 'P' (Primary)
-    # If the payer is not Medicare and is primary insurance, use 'P' (Primary)
-    # If the payer is secondary insurance after Medicare, use 'S' (Secondary)
-    # Assume everything is Primary for now.
-    responsibility_code = 'S' if parsed_data.get('claim_type') == 'secondary' else 'P'
-
-    # Insurance Type Code (SBR09)
-    insurance_type_code = insurance_type_selection(parsed_data)
-
-    # Prefer Medicare-specific type codes when determinable and COB helpers are available
-    if COB is not None:
-        try:
-            medicare_type = COB.determine_medicare_payer_type(parsed_data, config)
-            if medicare_type:
-                insurance_type_code = medicare_type  # MB or MA
-        except Exception as e:
-            MediLink_ConfigLoader.log("COB determine_medicare_payer_type error: {}".format(str(e)), level="WARNING")
-
-    # Construct the SBR segment using the determined codes
-    sbr_segment = "SBR*{responsibility_code}*18*******{insurance_type_code}~".format(
-        responsibility_code=responsibility_code,
-        insurance_type_code=insurance_type_code
-    )
-    return sbr_segment
-
-def insurance_type_selection(parsed_data):
-    """
-    Enhanced insurance type selection with optional API integration and safe fallbacks.
-    Maintains exact same signature as existing implementation.
-    
-    TODO (HIGH SBR09) Finish making this function. 
-    This should  eventually integrate into a menu upstream. This menu flow probably needs to be alongside the suggested endpoint flow.
-    For now let's make a menu here and then figure out the automated/API method to getting this per patient as there are no
-    useful historical patterns other than to say that the default should be PPO (12), then CI, then FI as most common options, 
-    followed by the rest. 
-    
-    Present a user-selectable menu of insurance types based on predefined codes.
-    User needs to input the desired 2 character code for that patient or default to PPO.
-    
-    Currently implements a simple text-based selection menu to choose
-    an insurance type for a patient. The default selection is '12' for PPO, but the user
-    can input other codes as per the options listed. This initial implementation uses
-    simple input/output functions for selection and can be replaced in the future by a 
-    more dynamic interface or API-driven selection method.
-
-    Future Enhancements:
-    - Automate selection via an API that fetches patient data directly and auto-assigns the insurance type.
-    - Error handling to manage incorrect inputs and retry mechanisms.
-    
-    Parameters:
-    - parsed_data (dict): Contains patient's last name under key 'LAST'.
-    
-    Returns:
-    - str: The insurance type code selected by the user.
-    
-    """
-    MediLink_ConfigLoader.log("insurance_type_selection(parsed_data): {}".format(parsed_data), level="DEBUG")
-    
-    # Try enhanced selection with safe fallback
-    if safe_insurance_type_selection:
-        try:
-            return safe_insurance_type_selection(parsed_data, _original_insurance_type_selection_logic)
-        except Exception as e:
-            MediLink_ConfigLoader.log("Error in enhanced insurance selection: {}. Using original logic".format(str(e)), level="ERROR")
-            return _original_insurance_type_selection_logic(parsed_data)
-    else:
-        MediLink_ConfigLoader.log("Enhanced insurance selection not available. Using original logic", level="INFO")
-        return _original_insurance_type_selection_logic(parsed_data)
-
-def _original_insurance_type_selection_logic(parsed_data):
-    """
-    Original insurance type selection logic extracted to preserve exact behavior.
-    This ensures backward compatibility when enhanced features are not available.
-    """
-    # Check if insurance type is already assigned and is valid
-    insurance_type_code = parsed_data.get('insurance_type')
-    if insurance_type_code and len(insurance_type_code) == 2 and insurance_type_code.isalnum():
-        MediLink_ConfigLoader.log("Insurance type already assigned: {}".format(insurance_type_code), level="DEBUG")
-        return insurance_type_code
-    elif insurance_type_code:
-        MediLink_ConfigLoader.log("Invalid insurance type: {}".format(insurance_type_code), level="WARNING")
-    
-    print("\nInsurance Type Validation Error: Select the insurance type for patient {}: ".format(parsed_data['LAST']))
-
-    # Retrieve insurance options with codes and descriptions
-    config, _ = MediLink_ConfigLoader.load_configuration()
-    try:
-        from MediCafe.core_utils import extract_medilink_config
-        medi = extract_medilink_config(config)
-        insurance_options = medi.get('insurance_options', {})
-    except Exception:
-        insurance_options = {}
-
-    # If COB library is available, augment options with Medicare codes (MB/MA/MC)
-    if COB is not None:
-        try:
-            insurance_options = COB.get_enhanced_insurance_options(config)
-        except Exception as e:
-            MediLink_ConfigLoader.log("COB get_enhanced_insurance_options error: {}".format(str(e)), level="WARNING")
-    
-    # TODO (COB ENHANCEMENT): Enhanced insurance options for Medicare support
-    # See MediLink_837p_cob_library.get_enhanced_insurance_options() for Medicare codes:
-    # - MB: Medicare Part B
-    # - MA: Medicare Advantage  
-    # - MC: Medicare Part C
-
-    def prompt_display_insurance_options():
-        # Prompt to display full list
-        display_full_list = input("Do you want to see the full list of insurance options? (yes/no): ").strip().lower()
-
-        # Display full list if user confirms
-        if display_full_list in ['yes', 'y'] and MediLink_Display_Utils:
-            MediLink_Display_Utils.display_insurance_options(insurance_options)
-
-    # Horrible menu
-    prompt_display_insurance_options()
-    
-    # Default selection
-    insurance_type_code = '12'
-
-    # User input for insurance type
-    user_input = input("Enter the 2-character code for the insurance type (or press Enter to default to '12' for PPO): ").strip().upper()
-
-    # Input validation and assignment
-    if user_input:
-        # Basic format validation
-        if len(user_input) > 3 or not user_input.isalnum():
-            print("Invalid format: Insurance codes should be 1-3 alphanumeric characters. Defaulting to PPO.")
-        elif user_input in insurance_options:
-            insurance_type_code = user_input
-            print("Selected: {} - {}".format(user_input, insurance_options[user_input]))
-        else:
-            # User wants to use a code not in options - confirm with them
-            confirm = input("Code '{}' not found in options. Use it anyway? (y/n): ".format(user_input)).strip().lower()
-            if confirm in ['y', 'yes']:
-                insurance_type_code = user_input
-                print("Using code: {}".format(user_input))
-            else:
-                print("Defaulting to PPO (Preferred Provider Organization)")
-    else:
-        print("Using default: PPO (Preferred Provider Organization)")
-
-    return insurance_type_code
-
 # Constructs the NM1 segment for subscriber based on parsed data and configuration.
 def create_nm1_subscriber_segment(config, parsed_data, endpoint):
     if endpoint.lower() == 'optumedi':
@@ -1145,6 +1232,25 @@ def create_interchange_header(config, endpoint, isa13):
     gs_receiver_code = endpoint_config.get('gs_03_value', config.get('receiverEdi', ''))
     isa15_value = endpoint_config.get('isa_15_value', isa15)
 
+    # Log warnings for empty sender/receiver codes (fallback detection)
+    config_warnings = []
+    if not isa_sender_id or isa_sender_id.strip() == '':
+        config_warnings.append("ISA06 Sender ID is empty - using fallback configuration")
+    if not gs_sender_code or gs_sender_code.strip() == '':
+        config_warnings.append("GS02 Sender Code is empty - using fallback configuration")
+    if not isa_receiver_id or isa_receiver_id.strip() == '':
+        config_warnings.append("ISA08 Receiver ID is empty - using fallback configuration")
+    if not gs_receiver_code or gs_receiver_code.strip() == '':
+        config_warnings.append("GS03 Receiver Code is empty - using fallback configuration")
+
+    if config_warnings:
+        warning_msg = "CONFIG FALLBACK DETECTED for endpoint {}: {}".format(endpoint, '; '.join(config_warnings))
+        MediLink_ConfigLoader.log(warning_msg, config, level="WARNING")
+        # Also log to console for immediate visibility during header creation
+        print("WARNING: Configuration fallbacks detected during 837P header creation:")
+        for warning in config_warnings:
+            print("   - {}".format(warning))
+
     # ISA Segment
     isa_segment = "ISA*00*{}*00*{}*{}*{}*{}*{}*{}*{}*^*00501*{}*0*{}*:~".format(
         isa02, isa04, isa05, isa_sender_id.ljust(15), isa07_value, isa_receiver_id.ljust(15),
@@ -1229,56 +1335,68 @@ def validate_claim_data_for_837p(parsed_data, config, crosswalk):
     diagnosis_code = next((key for key, value in crosswalk.get('diagnosis_to_medisoft', {}).items() if value == medisoft_code), None)
     
     if not diagnosis_code:
-        # Log the error condition with detailed context
-        error_message = "Diagnosis code is empty for chart number: {}. Please verify. Medisoft code is {}".format(chart_number, medisoft_code)
-        MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
-        
-        print("\n{}".format("="*80))
-        print("CRITICAL: Missing diagnosis code mapping for patient {}".format(chart_number))
-        print("{}".format("="*80))
-        print("Medisoft code: '{}'".format(medisoft_code))
-        print("Patient: {}, {}".format(parsed_data.get('LAST', 'Unknown'), parsed_data.get('FIRST', 'Unknown')))
-        print("Service Date: {}".format(parsed_data.get('DATE', 'Unknown')))
-        print("\nThis diagnosis code needs to be added to the crosswalk.json file.")
-        print("\nCurrent diagnosis_to_medisoft mapping format:")
-        
-        # Show example entries from the crosswalk
-        diagnosis_examples = list(crosswalk.get('diagnosis_to_medisoft', {}).items())[:3]
-        for full_code, medisoft_short in diagnosis_examples:
-            print("  '{}': '{}'".format(full_code, medisoft_short))
-        
-        print("\nPlease enter the complete ICD-10 diagnosis code (e.g., H25.10):")
-        diagnosis_code = input("> ").strip()
-        
-        if not diagnosis_code:
-            raise ValueError("Cannot proceed without diagnosis code for patient {}".format(chart_number))
-        
-        # Update the crosswalk dictionary with the new pairing of diagnosis_code and medisoft_code
-        crosswalk['diagnosis_to_medisoft'][diagnosis_code] = medisoft_code
-        MediLink_ConfigLoader.log("Updated crosswalk with new diagnosis code: {}, for Medisoft code {}".format(diagnosis_code, medisoft_code), config, level="INFO")
-        print("\n[SUCCESS] Added '{}' -> '{}' to crosswalk".format(diagnosis_code, medisoft_code))
-        
-        # Fix: Automatically persist the crosswalk changes
-        try:
-            # Import the existing save function from MediBot_Crosswalk_Utils
-            from MediBot.MediBot_Crosswalk_Utils import save_crosswalk
-            if save_crosswalk(None, config, crosswalk, skip_api_operations=True):
-                print("Crosswalk changes saved successfully.")
-                MediLink_ConfigLoader.log("Diagnosis code mapping persisted to crosswalk file", config, level="INFO")
-            else:
-                print("Warning: Failed to save crosswalk changes - they may be lost on restart.")
-                MediLink_ConfigLoader.log("Failed to persist diagnosis code mapping", config, level="WARNING")
-        except ImportError:
-            print("Warning: Could not import save_crosswalk function - changes not persisted.")
-            MediLink_ConfigLoader.log("Could not import save_crosswalk for diagnosis persistence", config, level="ERROR")
-        except Exception as e:
-            print("Warning: Error saving crosswalk changes: {}".format(e))
-            MediLink_ConfigLoader.log("Error persisting diagnosis code mapping: {}".format(e), config, level="ERROR")
+        if _is_test_mode(config):
+            # Use a safe placeholder ICD-10 code and update mapping in-memory only
+            placeholder_icd = 'R69'  # Unknown and unspecified causes of morbidity
+            try:
+                if 'diagnosis_to_medisoft' not in crosswalk or not isinstance(crosswalk.get('diagnosis_to_medisoft'), dict):
+                    crosswalk['diagnosis_to_medisoft'] = {}
+            except Exception:
+                pass
+            crosswalk['diagnosis_to_medisoft'][placeholder_icd] = medisoft_code or 'R69'
+            MediLink_ConfigLoader.log("[TEST MODE] Using placeholder ICD '{}' and updating in-memory mapping".format(placeholder_icd), config, level="WARNING")
+            print("TEST MODE: Using placeholder ICD '{}' for chart '{}' (in-memory only)".format(placeholder_icd, chart_number))
+        else:
+            # Log the error condition with detailed context and prompt user
+            error_message = "Diagnosis code is empty for chart number: {}. Please verify. Medisoft code is {}".format(chart_number, medisoft_code)
+            MediLink_ConfigLoader.log(error_message, config, level="CRITICAL")
+            
+            print("\n{}".format("="*80))
+            print("CRITICAL: Missing diagnosis code mapping for patient {}".format(chart_number))
+            print("{}".format("="*80))
+            print("Medisoft code: '{}'".format(medisoft_code))
+            print("Patient: {}, {}".format(parsed_data.get('LAST', 'Unknown'), parsed_data.get('FIRST', 'Unknown')))
+            print("Service Date: {}".format(parsed_data.get('DATE', 'Unknown')))
+            print("\nThis diagnosis code needs to be added to the crosswalk.json file.")
+            print("\nCurrent diagnosis_to_medisoft mapping format:")
+            
+            # Show example entries from the crosswalk
+            diagnosis_examples = list(crosswalk.get('diagnosis_to_medisoft', {}).items())[:3]
+            for full_code, medisoft_short in diagnosis_examples:
+                print("  '{}': '{}'".format(full_code, medisoft_short))
+            
+            print("\nPlease enter the complete ICD-10 diagnosis code (e.g., H25.10):")
+            diagnosis_code = input("> ").strip()
+            
+            if not diagnosis_code:
+                raise ValueError("Cannot proceed without diagnosis code for patient {}".format(chart_number))
+            
+            # Update the crosswalk dictionary with the new pairing of diagnosis_code and medisoft_code
+            crosswalk['diagnosis_to_medisoft'][diagnosis_code] = medisoft_code
+            MediLink_ConfigLoader.log("Updated crosswalk with new diagnosis code: {}, for Medisoft code {}".format(diagnosis_code, medisoft_code), config, level="INFO")
+            print("\n[SUCCESS] Added '{}' -> '{}' to crosswalk".format(diagnosis_code, medisoft_code))
+            
+            # Fix: Automatically persist the crosswalk changes
+            try:
+                # Import the existing save function from MediBot_Crosswalk_Utils
+                from MediBot.MediBot_Crosswalk_Utils import save_crosswalk
+                if save_crosswalk(None, config, crosswalk, skip_api_operations=True):
+                    print("Crosswalk changes saved successfully.")
+                    MediLink_ConfigLoader.log("Diagnosis code mapping persisted to crosswalk file", config, level="INFO")
+                else:
+                    print("Warning: Failed to save crosswalk changes - they may be lost on restart.")
+                    MediLink_ConfigLoader.log("Failed to persist diagnosis code mapping", config, level="WARNING")
+            except ImportError:
+                print("Warning: Could not import save_crosswalk function - changes not persisted.")
+                MediLink_ConfigLoader.log("Could not import save_crosswalk for diagnosis persistence", config, level="ERROR")
+            except Exception as e:
+                print("Warning: Error saving crosswalk changes: {}".format(e))
+                MediLink_ConfigLoader.log("Error persisting diagnosis code mapping: {}".format(e), config, level="ERROR")
         
         # TODO (HIGH PRIORITY - Crosswalk Data Persistence and Validation):
-        # ✅ FIXED: Diagnosis codes are now automatically persisted to file
-        # ✅ FIXED: Manual save requirement has been removed
-        # ✅ FIXED: Error handling and logging added for file save failures
+        #   FIXED: Diagnosis codes are now automatically persisted to file
+        #   FIXED: Manual save requirement has been removed
+        #   FIXED: Error handling and logging added for file save failures
         #
         # REMAINING WORKFLOW ISSUES:
         # 1. Validation still happens during encoding (too late in the process) - FUTURE ENHANCEMENT
@@ -1303,17 +1421,163 @@ def validate_claim_data_for_837p(parsed_data, config, crosswalk):
         # 3. Add crosswalk versioning and change tracking
         # 4. Implement crosswalk sharing across multiple users/systems
         #
-        # ✅ IMPLEMENTED:
-        # 1. ✅ Found existing crosswalk persistence function: save_crosswalk()
-        # 2. ✅ Added call here: save_crosswalk(None, config, crosswalk, skip_api_operations=True)
-        # 3. ✅ Removed manual save message
-        # 4. ✅ Added error handling for file save failures
-        # 5. ✅ Added logging for successful crosswalk updates
+        #   IMPLEMENTED:
+        # 1.   Found existing crosswalk persistence function: save_crosswalk()
+        # 2.   Added call here: save_crosswalk(None, config, crosswalk, skip_api_operations=True)
+        # 3.   Removed manual save message
+        # 4.   Added error handling for file save failures
+        # 5.   Added logging for successful crosswalk updates
         #
-        # ✅ TESTING COMPLETED:
-        # - ✅ Crosswalk changes persist across application restarts
-        # - ✅ Error handling tested for file save failures
-        # - ✅ Logging verified for successful crosswalk updates 
+        #   TESTING COMPLETED:
+        # -   Crosswalk changes persist across application restarts
+        # -   Error handling tested for file save failures
+        # - Logging verified for successful crosswalk updates 
 
     # Always return the validated (or minimally normalized) data structure
-    return validated_data
+    return validated_data
+
+
+def validate_config_sender_codes(config, endpoint):
+    """
+    Validates sender/receiver identification codes in configuration before claim submission.
+    
+    This function specifically checks for missing or empty sender and receiver 
+    identification codes that are critical for valid 837P interchange headers.
+    This is separate from claim data validation and focuses on configuration issues.
+    
+    IMPORTANT: This function validates the config that has already been loaded by the
+    centralized MediCafe config loader. It does NOT reload configuration from disk.
+    
+    Compatible with: Python 3.4.4, Windows XP SP3, ASCII-only output
+    
+    Parameters:
+    - config: Configuration dictionary (already loaded by centralized loader)
+    - endpoint: Endpoint name being processed
+    
+    Returns:
+        list: List of critical configuration issues that would prevent successful submission
+    """
+    issues = []
+    
+    # Extract MediLink config safely
+    medi_config = {}
+    if isinstance(config, dict):
+        medi_config = config.get('MediLink_Config', {})
+        if not isinstance(medi_config, dict):
+            medi_config = config  # Fallback to root config
+    
+    # Check if we're using default fallback config by examining key characteristics
+    # The centralized loader provides a default config when JSON files are missing
+    default_characteristics = [
+        medi_config.get('local_storage_path') == '.',
+        medi_config.get('receiptsRoot') == './receipts',
+        not medi_config.get('submitterId', '').strip(),
+        not medi_config.get('submitterEdi', '').strip()
+    ]
+    
+    # If most default characteristics match, likely using fallback config
+    if sum(default_characteristics) >= 3:
+        issues.append("Using default fallback configuration - JSON config file may be missing or inaccessible")
+    
+    # Check critical sender identification
+    submitter_id = medi_config.get('submitterId', '').strip() if isinstance(medi_config.get('submitterId'), str) else ''
+    submitter_edi = medi_config.get('submitterEdi', '').strip() if isinstance(medi_config.get('submitterEdi'), str) else ''
+    
+    if not submitter_id:
+        issues.append("submitterId is empty - ISA06 sender ID field will be blank")
+    if not submitter_edi:
+        issues.append("submitterEdi is empty - GS02 sender code field will be blank")
+    
+    # Check endpoint-specific overrides
+    endpoints_config = medi_config.get('endpoints', {})
+    if isinstance(endpoints_config, dict):
+        endpoint_config = endpoints_config.get(endpoint, {})
+        if isinstance(endpoint_config, dict):
+            isa_06 = endpoint_config.get('isa_06_value', '').strip() if isinstance(endpoint_config.get('isa_06_value'), str) else ''
+            gs_02 = endpoint_config.get('gs_02_value', '').strip() if isinstance(endpoint_config.get('gs_02_value'), str) else ''
+            
+            if not isa_06 and not submitter_id:
+                issues.append("No ISA06 sender ID configured for endpoint '{}'".format(endpoint))
+            if not gs_02 and not submitter_edi:
+                issues.append("No GS02 sender code configured for endpoint '{}'".format(endpoint))
+    else:
+        # No endpoints configuration found
+        if not submitter_id:
+            issues.append("No endpoints configuration found and submitterId is empty")
+        if not submitter_edi:
+            issues.append("No endpoints configuration found and submitterEdi is empty")
+    
+    # Check receiver identification
+    receiver_id = medi_config.get('receiverId', '').strip() if isinstance(medi_config.get('receiverId'), str) else ''
+    receiver_edi = medi_config.get('receiverEdi', '').strip() if isinstance(medi_config.get('receiverEdi'), str) else ''
+    
+    if not receiver_id:
+        issues.append("receiverId is empty - ISA08 receiver ID field will be blank")
+    if not receiver_edi:
+        issues.append("receiverEdi is empty - GS03 receiver code field will be blank")
+    
+    return issues
+
+# Helper: resolve config value with TestMode-only defaults enforcement
+# Defaults/placeholders are allowed ONLY in TestMode; otherwise we raise to avoid malformed 837p
+DEFAULT_PLACEHOLDER_VALUES = set([
+    'DEFAULT NAME', 'DEFAULT ID', 'DEFAULT BCBSF ID', 'DEFAULT RECEIVER NAME',
+    'DEFAULT EDI', 'DEFAULT NPI', 'DEFAULT FACILITY NAME', 'DEFAULT FACILITY NPI',
+    'DEFAULT PAY-TO NAME', 'DEFAULT PAY-TO ADDRESS', 'DEFAULT PAY-TO CITY',
+    'DEFAULT PAY-TO STATE', 'DEFAULT PAY-TO ZIP', 'NO ADDRESS', 'NO CITY',
+    'NO STATE', 'NO ZIP', 'NO TAX ID', 'NONE'
+])
+
+def _get_value_from_sources(source_dicts, key):
+    for d in source_dicts:
+        try:
+            if isinstance(d, dict) and key in d:
+                val = d.get(key)
+                if val not in [None, '']:
+                    return val
+        except Exception:
+            pass
+    return None
+
+def legacy_require_config_value(source_dicts, key, default_value, context_label, config, endpoint=None, allow_default_in_test=True):
+    """
+    Fetch a configuration value from one or more dicts.
+    - If found and equals a known placeholder, allow only in TestMode.
+    - If missing, allow default only in TestMode (when allow_default_in_test is True).
+    - Otherwise raise ValueError to prevent generating malformed 837p.
+    
+    TODO Eventually we should get this functionality into configloader in MediCafe so that we can use it in other places.
+    """
+    value = _get_value_from_sources(source_dicts, key)
+    # Found a value
+    if value not in [None, '']:
+        if isinstance(value, str) and value in DEFAULT_PLACEHOLDER_VALUES:
+            if _is_test_mode(config):
+                try:
+                    MediLink_ConfigLoader.log("TEST MODE: Placeholder used for {} -> {}".format(key, value), level="WARNING")
+                except Exception:
+                    pass
+                print("TEST MODE: Using placeholder '{}' for {} ({})".format(value, key, context_label))
+                return value
+            else:
+                msg = "Missing real value for '{}' in {}. Found placeholder '{}'. Endpoint: {}".format(key, context_label, value, (endpoint or ''))
+                try:
+                    MediLink_ConfigLoader.log(msg, level="CRITICAL")
+                except Exception:
+                    pass
+                raise ValueError(msg)
+        return value
+    # Missing value entirely
+    if allow_default_in_test and _is_test_mode(config):
+        try:
+            MediLink_ConfigLoader.log("TEST MODE: Default used for {} -> {}".format(key, default_value), level="WARNING")
+        except Exception:
+            pass
+        print("TEST MODE: Using default '{}' for {} ({})".format(default_value, key, context_label))
+        return default_value
+    msg = "Required configuration '{}' missing for {}. Endpoint: {}".format(key, context_label, (endpoint or ''))
+    try:
+        MediLink_ConfigLoader.log(msg, level="CRITICAL")
+    except Exception:
+        pass
+    raise ValueError(msg)