app.py

from typing import List, Match
from molmass import Formula

import streamlit as st
import time
import logging
import fitz  # PyMuPDF
import io
import re

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')



def remove_specific_lines_from_string(input_string):
    pattern = re.compile(r'^\s*(S)?\d+\s*$')
    lines = input_string.split('\n')
    filtered_lines = [line for line in lines if not pattern.match(line)]
    return '\n'.join(filtered_lines)

def check_conditions(cleaned_results):
    for row in cleaned_results:
        # Check if the 8th column (index 7) is empty or contains "-0.0001" or "+0.0001"
        if row[7] not in ("", "-0.0001", "+0.0001","Electron mass error"):
            return False
        # Check if the 7th column (index 6) as a float is less than 10
        try:
            if float(row[6]) >= 10:
                return False
        except ValueError:
            # If conversion to float fails, return False
            return False
    return True

def fix_floats(text):
    """
    Searches a string for floats in the form "xxxx.xxx" and changes them to "xxxx.xxx0".

    Args:
        text (str): The input text to search and modify.

    Returns:
        str: The modified text with floats in the form "xxxx.xxx0".
    """
    # Define a regular expression pattern to match floats with 3 decimal places
    pattern = r'\b\d+\.\d{3}\b'

    # Use the re.sub() function to replace matches with the modified float
    modified_text = re.sub(pattern, lambda match: match.group() + '0', text)

    return modified_text


def remove_sublists_with_missing_element1_positions_swapped(cleaned_results):
    """
    Removes sublists where element 1 is missing (''), if there exists another sublist
    where elements at positions 2, 3, and 4 are the same (positions 3 and 4 may be swapped)
    and element 1 is present.
    """
    # Create a set to hold indices of sublists to remove
    indices_to_remove = set()
    # Build a dictionary to map keys (elements 2, and positions 3 & 4 as a frozenset) to indices
    element_presence = {}

    # First pass: Collect sublists where element 1 is present
    for idx, sublist in enumerate(cleaned_results):
        if len(sublist) < 4:
            continue  # Skip if sublist doesn't have enough elements
        # Create a frozenset of positions 3 and 4 to handle swapping
        positions_3_4_set = frozenset([sublist[2], sublist[3]])
        key = (sublist[1], positions_3_4_set)  # Element at position 2 and set of positions 3 and 4
        if sublist[0] != '':
            # Element 1 is present, store the index
            if key not in element_presence:
                element_presence[key] = []
            element_presence[key].append(idx)

    # Second pass: Identify sublists to remove
    for idx, sublist in enumerate(cleaned_results):
        if len(sublist) < 4:
            continue  # Skip if sublist doesn't have enough elements
        if sublist[0] == '':
            # Element 1 is missing
            positions_3_4_set = frozenset([sublist[2], sublist[3]])
            key = (sublist[1], positions_3_4_set)
            if key in element_presence:
                # There is at least one sublist where elements 2, 3, 4 (with positions 3 and 4 swapped) are the same and element 1 is present
                indices_to_remove.add(idx)

    # Remove sublists at the collected indices
    cleaned_results = [sublist for idx, sublist in enumerate(cleaned_results) if idx not in indices_to_remove]
    return cleaned_results



def remove_spaces_in_formula(text):
    """
    Removes all spaces within chemical formulas in the input text.

    The function identifies chemical formulas based on sequences of element symbols
    (one or two letters, starting with an uppercase letter), possibly separated by numbers
    and spaces, and removes any spaces within those sequences.

    Args:
      text: The input string containing chemical formulas.

    Returns:
      The processed string with spaces removed from within chemical formulas.
    """

    # Step 1: Protect floats by surrounding them with '#'
    text = re.sub(r'(\d+\.\d+)', r'#\1#', text)

    # Regular expression pattern to match chemical formulas
    element = r'[A-Z][a-z]?'
    number = r'\d+'
    # Pattern matches sequences starting with an element symbol, followed by
    # elements or numbers, possibly with spaces in between
    pattern = r'(' + element + r'(?:\s*(?:' + element + r'|' + number + r'))+)'

    # Function to remove spaces within the matched chemical formula
    def remove_spaces(match):
        return match.group(0).replace(' ', '')

    # Replace matches in the text with spaces removed within chemical formulas
    return re.sub(pattern, remove_spaces, text)


def remove_page_numbers(text):
    """
    Remove lines that appear to be page numbers from a text string.

    Matches:
    - Single integers (e.g., "12")
    - Integers with dashes (e.g., "- 12 -", "-13-")
    - Integers with p/P/s/S prefix (e.g., "P12", "s23")
    - Integers with p/P/s/S prefix and dashes (e.g., "S-12", "p -13")

    Args:
        text (str): Input text containing page numbers

    Returns:
        str: Text with page number lines removed
    """
    # Split text into lines
    lines = text.split('\n')

    # Regular expression patterns for page numbers
    patterns = [
        r'^\s*\d+\s*$',                  # Single integers: "12"
        r'^\s*-\s*\d+\s*-\s*$',          # Dashed integers: "- 12 -"
        r'^\s*-\d+-\s*$',                # Compact dashed integers: "-13-"
        r'^\s*[psPS]\s*-?\s*\d+\s*(?:\n|$)',    # p/P/s/S prefixed: "P12", "s23", "S-12"
    ]

    # Combine patterns
    combined_pattern = '|'.join(f'({pattern})' for pattern in patterns)

    # Filter out lines matching the patterns
    cleaned_lines = [line for line in lines if not re.match(combined_pattern, line)]

    # Rejoin the remaining lines
    return '\n'.join(cleaned_lines)


def is_float(value):
    try:
        float(value)
        return True
    except ValueError:
        return False

def protect_floats(text: str) -> str:

    # Match floats with 3+ digits before decimal and 4+ after
    pattern = r'(\d{3,}\.\d{4,})'

    def add_spaces(match: re.Match) -> str:
        """Add spaces around the matched float if needed."""
        float_num = match.group(1)
        start, end = match.span(1)

        # Get characters before and after the float
        char_before = text[start - 1] if start > 0 else ''
        char_after = text[end] if end < len(text) else ''

        # Only add space if the adjacent characters aren't already spaces
        prefix = '' if char_before.isspace() else ' '
        suffix = '' if char_after.isspace() else ' '

        return f'{prefix}{float_num}{suffix}'

    return re.sub(pattern, add_spaces, text)

def replace_comma_with_decimal(text: str) -> str:
    # Match numbers with comma decimals that:
    # \b     - Start at a word boundary
    # \d+    - Have one or more digits before the comma
    # ,      - Have a comma
    # \d+    - Have one or more digits after the comma
    # \b     - End at a word boundary
    pattern = r'\b(\d+,\d+)\b'

    def comma_to_decimal(match: Match[str]) -> str:
        """Convert comma to decimal point in matched number."""
        return match.group(0).replace(',', '.')

    return re.sub(pattern, comma_to_decimal, text)

def adjust_space_around_decimal(text):

    if not isinstance(text, str):
        raise TypeError("Input must be a string")

    # Step 1: Remove unwanted spaces around decimal points
    # Handles cases like "23. 4562" → "23.4562"
    text = re.sub(r'(\d+)\s*\.\s*(\d+)', r'\1.\2', text)

    # Step 2: Add space between decimal numbers and following text
    # Handles cases like "2.4beta" → "2.4 beta"
    text = re.sub(r'(\d+\.\d+)([A-Za-z])', r'\1 \2', text)

    # Step 3: Handle special cases where no space is needed
    # For file extensions like ".txt", ".pdf"
    text = re.sub(r'(\s\d+)\s+(\.[A-Za-z]+\b)', r'\1\2', text)

    return text

def decrease_element_count(molecular_formula: str, element_to_decrease: str) -> str:
    """
    Decreases the count of a specific element in a molecular formula by 1.

    Args:
        molecular_formula: The input molecular formula (e.g., 'C6H12O2')
        element_to_decrease: The element whose count should be decreased (e.g., 'C')

    Returns:
        Modified molecular formula with decreased element count

    Example:
        >>> decrease_element_count('C6H12O2', 'C')
        'C5H12O2'
    """
    pattern = fr'({element_to_decrease})(?![a-z])\d*'

    def replace_element(match: re.Match) -> str:
        element_count = match.group()
        element = re.match(r'([A-Z][a-z]*)', element_count).group()

        if count_match := re.search(r'\d+', element_count):
            current_count = int(count_match.group())
            return (f"{element}{current_count - 1}" if current_count > 2
                    else element)  # Remove count when it's 2
        return element

    return re.sub(pattern, replace_element, molecular_formula)


def have_swapped_adjacent_digits(float1: float, float2: float) -> bool:
    # Convert floats to strings
    str1, str2 = str(float1), str(float2)

    # Remove last two digits for comparison
    str1 = str1[:-2]
    str2 = str2[:-2]

    # Remove decimal points for comparison
    str1_no_dot = str1.replace('.', '')
    str2_no_dot = str2.replace('.', '')

    # Check lengths
    if len(str1_no_dot) != len(str2_no_dot) or len(str1_no_dot) < 2:
        return False

    # Find positions that differ
    diff_positions = [i for i in range(len(str1_no_dot))
                      if str1_no_dot[i] != str2_no_dot[i]]

    # Must have exactly 2 differences for a single swap
    if len(diff_positions) != 2:
        return False

    # The positions must be adjacent
    if diff_positions[1] - diff_positions[0] != 1:
        return False

    # Check if it's actually a swap
    pos1, pos2 = diff_positions
    return (str1_no_dot[pos1] == str2_no_dot[pos2] and
            str1_no_dot[pos2] == str2_no_dot[pos1])



def differ_in_single_digit_except_last_two(float1: float, float2: float) -> bool:
    """
    Checks if two floating-point numbers differ by exactly one digit, excluding the last two digits.
    Handles trailing zeros and decimal points in the comparison.

    Args:
        float1: First floating-point number
        float2: Second floating-point number

    Returns:
        True if numbers differ by exactly one digit (excluding last two), False otherwise

    Examples:
        >>> differ_in_single_digit_except_last_two(123.45, 153.45)
        True
        >>> differ_in_single_digit_except_last_two(123.45, 153.46)
        False
        >>> differ_in_single_digit_except_last_two(123.450, 153.45)
        True
    """
    # Convert to strings and normalize by removing trailing zeros and decimal points
    str1 = str(float1).rstrip('0').rstrip('.')
    str2 = str(float2).rstrip('0').rstrip('.')

    # Quick validation checks
    if len(str1) != len(str2) or len(str1) < 3:  # Need at least 3 digits for comparison
        return False

    # Extract main part and last two digits
    main1, last_two1 = str1[:-2], str1[-2:]
    main2, last_two2 = str2[:-2], str2[-2:]

    # Last two digits must match
    if last_two1 != last_two2:
        return False

    # Count differing digits in main part
    return sum(1 for a, b in zip(main1, main2) if a != b) == 1


def calculate_molecular_weight(formula):
    # Dictionary of atomic weights for elements up to Plutonium (94)
    # Values are in atomic mass units (amu) or g/mol
    atomic_weights = {
        "H": 1.008, "D": 2.0141, "He": 4.002602, "Li": 6.94, "Be": 9.0121831, "B": 10.81, "C": 12.011,
        "N": 14.007, "O": 15.999, "F": 18.9984, "Ne": 20.1797, "Na": 22.98977, "Mg": 24.305, "Al": 26.98154,
        "Si": 28.085, "P": 30.97376, "S": 32.06, "Cl": 35.45, "Ar": 39.948, "K": 39.0983, "Ca": 40.078,
        "Sc": 44.955908, "Ti": 47.867, "V": 50.9415, "Cr": 51.9961, "Mn": 54.938044, "Fe": 55.845,
        "Co": 58.933194, "Ni": 58.6934, "Cu": 63.546, "Zn": 65.38, "Ga": 69.723, "Ge": 72.630,
        "As": 74.921595, "Se": 78.971, "Br": 79.904, "Kr": 83.798, "Rb": 85.4678, "Sr": 87.62,
        "Y": 88.90584, "Zr": 91.224, "Nb": 92.90637, "Mo": 95.95, "Tc": 98, "Ru": 101.07,
        "Rh": 102.90550, "Pd": 106.42, "Ag": 107.8682, "Cd": 112.414, "In": 114.818, "Sn": 118.710,
        "Sb": 121.760, "Te": 127.60, "I": 126.90447, "Xe": 131.293, "Cs": 132.90545196, "Ba": 137.327,
        "La": 138.90547, "Ce": 140.116, "Pr": 140.90766, "Nd": 144.242, "Pm": 145, "Sm": 150.36,
        "Eu": 151.964, "Gd": 157.25, "Tb": 158.92535, "Dy": 162.500, "Ho": 164.93033,
        "Er": 167.259, "Tm": 168.93422, "Yb": 173.04, "Lu": 174.9668, "Hf": 178.49,
        "Ta": 180.94788, "W": 183.84, "Re": 186.207, "Os": 190.23, "Ir": 192.217,
        "Pt": 195.084, "Au": 196.96657, "Hg": 200.592, "Tl": 204.38, "Pb": 207.2,
        "Bi": 208.9804, "Po": 209, "At": 210, "Rn": 222, "Fr": 223, "Ra": 226,
        "Ac": 227, "Th": 232.0377, "Pa": 231.03588, "U": 238.02891, "Np": 237, "Pu": 244
    }

    # Parse the molecular formula using regex
    formula_components = re.findall(r"([A-Z][a-z]?)(\d*)", formula)

    # Calculate total molecular weight
    mol_weight = 0.0
    for element, count in formula_components:
        # Get atomic weight from dictionary, default to 0.0 if element not found
        element_weight = atomic_weights.get(element, 0.0)
        # If no count specified, assume 1, otherwise convert string to integer
        mol_weight += element_weight * (int(count) if count else 1)

    return mol_weight

def remove_spaces_within_brackets(s, max_chars=20):
    """
    Removes all spaces within brackets () or [] if the number of non-space characters inside
    is within max_chars. Handles nested brackets appropriately without affecting spaces outside
    the brackets.

    Args:
    - s (str): The input string.
    - max_chars (int): Maximum number of non-space characters between opening and closing brackets.

    Returns:
    - str: The modified string with spaces removed within qualifying brackets.
    """
    stack = []
    # Mapping of opening brackets to their corresponding closing brackets
    opening_to_closing = {'(': ')', '[': ']'}
    # Mapping of closing brackets to their corresponding opening brackets
    closing_to_opening = {')': '(', ']': '['}

    s_list = list(s)  # Convert string to list for mutable operations
    remove_space_ranges = []  # List to hold ranges where spaces need to be removed

    for i, char in enumerate(s_list):
        if char in opening_to_closing:
            # Push opening bracket and its position onto the stack
            stack.append((char, i))
        elif char in closing_to_opening:
            if stack and stack[-1][0] == closing_to_opening[char]:
                # Pop the last opening bracket from the stack
                open_char, open_pos = stack.pop()
                close_pos = i
                # Extract the substring inside the brackets
                content = ''.join(s_list[open_pos + 1:close_pos])
                # Count the number of non-space characters
                non_space_chars = len(content.replace(' ', ''))
                if non_space_chars <= max_chars:
                    # Define the range for space removal (exclusive of brackets)
                    remove_space_ranges.append((open_pos + 1, close_pos))
            else:
                # Unmatched closing bracket; ignore or handle as needed
                pass

    # Sort ranges in descending order of start index to handle inner brackets first
    remove_space_ranges.sort(key=lambda x: x[0], reverse=True)

    for start, end in remove_space_ranges:
        # Extract the substring within the current bracket (excluding brackets)
        substring = ''.join(s_list[start:end])
        # Remove all spaces within this substring
        substring_no_spaces = substring.replace(' ', '')
        # Replace the original substring with the modified one
        s_list[start:end] = list(substring_no_spaces)

    # Join the list back into a string and return
    return ''.join(s_list)


def isotope_correct(text):
    """
    Applies a series of substitutions to a text to correct for isotope labeling and other specific replacements.

    Parameters:
    text (str): The input text to be processed.

    Returns:
    str: The processed text with all substitutions applied.
    """
    # Dictionary of replacements for isotope corrections and other text cleanup
    replacements = {
        "For":" ","[MALDI]":"","[MALDI-TOF]":"","detected":" ","page": " ", "of": " ",  "𝑀": " ", "EI": " ", " . ": " ", ":": " ", "Δ": " ",
        "𝛼": " ", " a ": " ",  "M ": " ", " H ": " ","(ESI)":" ", "ESI": " ", " Na ": " ", " K ": " ",
        " NH4 ": " ", "Obs.": " ", "obs": " ", "78.9183": "", "48Ti": "[48Ti]","54Fe":"[54Fe]",
        "46Ti": "[46Ti]", "47Ti": "[47Ti]", " 2H": "D", " [3H]": "[3H]",
        " 10B": "[10B]", "127I": "[127I]", "120Sn":"[120Sn]", "119Sn":"[119Sn]", "118Sn":"[118Sn]",
        "N23Na": "*N23*Na","O23Na": "*O23*Na", "F23Na": "*F23*Na", "H23Na": "*H23*Na", "23Na":"[23Na]","H28Si": "*H28*Si", "H11B": "*H11*B",
        "H13Co": "*H13*Co", "H13Cl": "*H13*Cl", "H18O": "*H18*O", "H218O": "*H218*O", "N18O": "*N18*O",
        "H35Cl": "*H35*Cl", "H37Cl": "*H37*Cl", "H10B":"*H10*B", "H19F": "*H19*F", "H81Br":"*H81*Br","-2H79Br":"-2H[79Br]","-H79Br":"-H[79Br]","H79Br":"*H79*Br","Br79": "[79Br]",
        " 79Br": "[79Br]", " 81Br": "[81Br]", "18O": "[18O]", "74Ge": "[74Ge]", "65Cu":"[65Cu]",
        "63Cu":"[63Cu]", "Br81": "[81Br]", " 35Cl": "[35Cl]", " 37Cl": "[37Cl]", " 11B": "[11B]",
        " 32S": "S", " 31P": "P", "35Cl":"[35Cl]", "80Se":"[80Se]", "37Cl":"[37Cl]", "28Si":"[28Si]",
        "13C":"[13C]", "[13C]l":"13Cl", "96Ru":"[96Ru]","79Br":"[79Br]", "81Br":"[81Br]", "11B":"[11B]", "10B":"[10B]",
        "[10B]r":"10Br", "[[":"[", "]]":"]", "*H13*Cl": "H13Cl", "*H18*O": "H18O", "*H218*O": "H218O",
        "*N18*O": "N18O", "*H13*Co": "H13Co", "*H37*Cl": "H37Cl", "*H35*Cl": "H35Cl","*H81*Br":"H81Br","*H79*Br":"H79Br",
        "*H28*Si": "H28Si", "*H10*B":"H10B", "*H23*Na": "H23Na", "*F23*Na": "F23Na", "*N23*Na": "N23Na","*O23*Na": "O23Na",
        "*H11*B":"H11B", "*H19*F": "H19F", "cacld": "", "calcd.": "calcd ", "calc’d": "calcd ",
        "calcd gcm": " ", " is ": " ", "calcd": "calcd ", "calcd  ": "calcd ","++": "+","(M":"[M", ")+":"]+ ",
        "MALDI":"","Maldi":""," [13C]":"[13C]","  [127I]":"[127I]"," [12C":"C"," [37Cl]":"37Cl"," [35Cl]":"35Cl",
        "C ":"C","H":"H", " N":"N"," O":"O"," Na":"Na", " Br":"Br", "N ":"N"," Cl":"Cl", " F":"F"," S":"S"," P":"P"," B":"B","M]+H+]":"M+H]+","M]-H+]":"M-H]-",
        "MH+":"M+H]+ ","]-(":"]- ","]+)":"]+ ","]-)":"]- ","]2-)":"]2- ","]+C":"]+ C","[MM":"","=":"","[MeOH":" ","[MeCN":" ","m/z":" ","]+2 ":"]2+ ","]+1":"]+","M+ C":"M+C","+]":"]+","+calc":" calc",
        "Na)]":"Na]","+Na)":"+Na]",";":" ","+H)]":"+H]","+K)]":"+K]","+NH4)]":"+NH4]","+H)":"+H]","H+)":"H]+","Na+)":"Na]+","-calcd":"- calcd","[M-H] ":"[M-H]-","--":"-",
        "NH4+)":"MH4]+","M+)":"M]+","M]+)":"M]+","+)":"+","M- ":"M-","+.":"+","[MNa]+":"[M+Na]+","[MH]+":"[M+H]+",
        " M2+ ":" [M]2+ "," M3+ ":" [M]3+ "," M4+ ":" [M]4+ "," M5+ ":" [M]5+ "," M6+ ":" [M]6+ ",
        " M2- ": " [M]2- ", " M3- ": " [M]3- ", " M4- ": " [M]4- ", " M5- ": " [M]5- ", " M6- ": " [M]6- ","[M+H] ":"[M+H]+ ","[M+Na] ":"[M+Na]+ ","[M] ":"[M]+ ","]calcd":"] calcd","-.":"- ","M+1)":"M+1]+ ","+ꞏ":"+","]-calcd":"]- calcd",
        "[Methyl":" ","[MA":" ","[ME":" ","[MI":" ","[MO":" ","[MU":" ","[Ma":" ","[Mi":" ","[Mo":" ","[Mu":" ","[Mg":" ","[M+H].":"[M+H]+ ","[M+Na].":"[M+Na]+ ","].":"] ","[M+Na]+":"[M+Na]+ ","[M+H]+":"[M+H]+ ","[M]+Na]+":"[M+Na]+","[M]+H]+":"[M+H]+","]++":"]+","-]]+":"-]+","H]]+":"H]+","H]+]+":"H]+","H]+]":"H]+","[ ]":"", " for ":" "," found ":" ","[M":" [M"
    }

    # Apply each replacement in the dictionary to the text
    for original, replacement in replacements.items():
        text = text.replace(original, replacement)

    return text


def transform_expressions_in_text(text):
    """
    Transforms all chemical expressions within a given text into a standardized format.

    Rules for expressions:
    - Starts with M or nM, where n is a single digit integer.
    - Ends with a charge (e.g., +, 2+, -).
    - Can be enclosed in () or [] brackets.
    - May contain spaces which are removed within the expression.
    - Charges can be inside or outside the brackets.

    The transformed expression:
    - Contains no spaces within the expression.
    - Preserves surrounding text intact.

    Args:
    - text (str): The input text containing chemical expressions.

    Returns:
    - str: The text with all expressions transformed accordingly.
    """

    # Step 1: Replace specific symbols with corresponding charges
    symbol_replacements = {

        '⊕': '+',
        '•+': '+',
        '': '+',
        '': "+",
        '+.':'+ ',
        '•': '',
        '·':'',
        '∙':'',
        'ꞏ': '',
        '–': '-',
        '-':'-',
        '−.':'- ',
        '−': '-',  # Minus sign
        '—': '-',  # Em dash
        '―': '-',
        '˗': '-',
        '-.': '- ',
    }

    # Create a regex pattern to match all keys in symbol_replacements
    symbols_pattern = re.compile('|'.join(map(re.escape, symbol_replacements.keys())))
    text = symbols_pattern.sub(lambda match: symbol_replacements[match.group()], text)

    # Step 2: Define regex to find expressions
    # This pattern matches expressions enclosed in [] or () with optional charges outside
    expression_pattern = re.compile(
        r'[\[(]'  # Opening bracket [ or (
        r'(\d*M?\d*[a-zA-Z\d-]*)'  # Capture group (explained above)
        r'[])]'  # Closing bracket ] or )
        r'(\d*\+|-)?'  # Optional charge outside the brackets
        r'[,:]*'  # Optional trailing characters
    )

    def replace_expression(match):
        expression_part = match.group(1)  # The main part of the expression
        charge_outside = match.group(2)  # The charge outside the brackets, if any

        # Step 3: Remove all internal brackets within the main expression
        expression_part = re.sub(r'[\[\]()]', '', expression_part)

        # Step 4: Remove all spaces within the main expression
        expression_part = re.sub(r'\s+', '', expression_part)

        if not charge_outside:
            # Step 5: Extract charge from the main expression if charge_outside is not present
            charge_match = re.search(r'([+-])$', expression_part)
            if charge_match:
                charge = charge_match.group(1)
                expression_part = expression_part[:charge_match.start()]
            else:
                charge = ''
        else:
            charge = charge_outside

        # Step 6: Format the transformed expression
        transformed = f'[{expression_part}]{charge}'

        return transformed

    # Step 7: Substitute all matching expressions in the text
    transformed_text = expression_pattern.sub(replace_expression, text)

    return transformed_text

def transform_molecular_formula(formula):
  """
  Transforms a molecular formula string to a standardized format.

  Args:
    formula: The molecular formula string to transform.

  Returns:
    The transformed molecular formula string.
  """

  # Remove all round brackets and colons
  formula = formula.replace("(", "").replace(")", "").replace(":", "").replace("]+-", "]+")

  # Remove ALL spaces within brackets and move the + or - sign after the bracket (if any)
  formula = re.sub(r'\[(.*?)]', lambda m: '[' + m.group(1).replace(' ', '') + ']' + ('+' if '+' in m.group(1) else '') + ('-' if '-' in m.group(1) else ''), formula)

  # Replace "M-" with "M-"
  formula = re.sub(r'M\s*–', 'M-', formula)

  # Replace "M +" or "M+" with "M+"
  formula = re.sub(r'M\s*\+', 'M+', formula)

  # Ensure standardized ion is surrounded by one space, BUT NOT IF IT IS THE LAST THING
  formula = re.sub(r'([^ ])(\[\w+][+-]?)(?=\S)', r'\1 \2 ', formula)  # Include optional + or - in the ion group

  # Add brackets if "M" is present without brackets
  if "M" in formula and "[" not in formula:
    formula = "[" + formula + "]"

  # Add spaces around "calcd for", "found"
  formula = re.sub(r'(calcd\s*for|found)', r' \1 ', formula)

  # Remove double spaces
  formula = formula.replace("++", "+").replace("++", "+").replace(",", " ")
  formula = re.sub(r'\s+', ' ', formula)
  formula = formula.replace("-+", "+").replace("]+-", "]+").replace("+]+", "]+ ").replace("++", "+").replace("--", "").replace(",", "+")

  return formula


# Configure logging
logging.basicConfig(level=logging.INFO, format='%(message)s')


def generate_error_dictionary(element_list, counts_range, special_cases=None):
    """
    Generates an error dictionary mapping mass differences to element or group descriptions.
    For atoms, includes entries for counts from counts_range.
    For groups, includes entries only for count=1, with descriptions like "1 OH-group".

    Parameters:
    - element_list (list): List of element symbols or groups (e.g., ['H', 'O', 'N', 'OH']).
    - counts_range (range): Range of atom counts for atoms (e.g., range(1, 11) for counts 1-10).
    - special_cases (dict): Optional dictionary for special error cases
                            (e.g., {'0.0005': 'Electron mass error'}).

    Returns:
    - dict: Error dictionary with mass differences as keys and descriptions as values.
    """

    error_dict = {}
    electron_mass = 0.0005486  # Atomic mass units (amu)

    for element in element_list:
        try:
            atomic_mass = Formula(element).monoisotopic_mass
        except Exception as e:
            print(f"Error processing element {element}: {e}")
            continue  # Skip this element if there's an error

        # Determine if the element is a group (more than one capital letter)
        is_group = sum(1 for c in element if c.isupper()) > 1

        if is_group:
            # For groups, create entry only for count=1
            count = 1
            mass_diff_e = atomic_mass * count
            mass_diff_e_rounded = round(mass_diff_e, 4)
            description = f"{count} {element}-group"  # Use the group name with '1' and 'group' with hyphen
            if mass_diff_e_rounded in error_dict:
                if description not in error_dict[mass_diff_e_rounded]:
                    error_dict[mass_diff_e_rounded] += f", {description}"
            else:
                error_dict[mass_diff_e_rounded] = description

            # Positively Charged Ion (E+)
            mass_diff_e_plus = mass_diff_e + (electron_mass * count)
            mass_diff_e_plus_rounded = round(mass_diff_e_plus, 4)
            if mass_diff_e_plus_rounded in error_dict:
                if description not in error_dict[mass_diff_e_plus_rounded]:
                    error_dict[mass_diff_e_plus_rounded] += f", {description}"
            else:
                error_dict[mass_diff_e_plus_rounded] = description

            # Negatively Charged Ion (E-)
            mass_diff_e_minus = mass_diff_e - (electron_mass * count)
            mass_diff_e_minus_rounded = round(mass_diff_e_minus, 4)
            if mass_diff_e_minus_rounded in error_dict:
                if description not in error_dict[mass_diff_e_minus_rounded]:
                    error_dict[mass_diff_e_minus_rounded] += f", {description}"
            else:
                error_dict[mass_diff_e_minus_rounded] = description
        else:
            # For atoms, create entries for counts in counts_range
            for count in counts_range:
                mass_diff_e = atomic_mass * count
                mass_diff_e_rounded = round(mass_diff_e, 4)
                if count == 1:
                    description = f"{count} {element}-atom"
                else:
                    description = f"{count} {element}-atoms"

                if mass_diff_e_rounded in error_dict:
                    if description not in error_dict[mass_diff_e_rounded]:
                        error_dict[mass_diff_e_rounded] += f", {description}"
                else:
                    error_dict[mass_diff_e_rounded] = description

                # Positively Charged Ion (E+)
                mass_diff_e_plus = mass_diff_e + (electron_mass * count)
                mass_diff_e_plus_rounded = round(mass_diff_e_plus, 4)
                if mass_diff_e_plus_rounded in error_dict:
                    if description not in error_dict[mass_diff_e_plus_rounded]:
                        error_dict[mass_diff_e_plus_rounded] += f", {description}"
                else:
                    error_dict[mass_diff_e_plus_rounded] = description

                # Negatively Charged Ion (E-)
                mass_diff_e_minus = mass_diff_e - (electron_mass * count)
                mass_diff_e_minus_rounded = round(mass_diff_e_minus, 4)
                if mass_diff_e_minus_rounded in error_dict:
                    if description not in error_dict[mass_diff_e_minus_rounded]:
                        error_dict[mass_diff_e_minus_rounded] += f", {description}"
                else:
                    error_dict[mass_diff_e_minus_rounded] = description

    # Add Special Cases if Provided
    if special_cases:
        for mass, desc in special_cases.items():
            mass_float = float(mass)
            mass_rounded = round(mass_float, 4)
            if mass_rounded in error_dict:
                if desc not in error_dict[mass_rounded]:
                    error_dict[mass_rounded] += f", {desc}"
            else:
                error_dict[mass_rounded] = desc

    return error_dict


# Define special cases like electron mass error
special_errors = {
    '0.0005': "Electron mass error",
    '0.0006': "Electron mass error",
    '0.0073': "Nominal mass error (H=1.0000)?",
    '0.0072': "Nominal mass error (H=1.0000)?",
    '0.0071': "Nominal mass error (H=1.0000)?",
    '0.0070': "Nominal mass error (H=1.0000)?",
    '1.0005': "Nominal mass error (H=1.0000)?",
    '1.0006': "Nominal mass error (H=1.0000)?",
    '0.0102': "Nominal mass error (Na=23.0000)?",
    '0.0103': "Nominal mass error (Na=23.0000)?",
    '0.0107': "Nominal mass error (Na=23.0000)?",
    '0.0108': "Nominal mass error (Na=23.0000)?",
    '1.0079': '1 H-atom',    
    '1.0077': '1 H-atom',
    '1.0076': '1 H-atom',
    '1.0075': '1 H-atom',
    '1.0083': '1 H-atom',
    '+22.9897': '1 Na-atom',
    '+22.9902': '1 Na-atom',
    '21.9892':"Nominal mass error [M]+1.0000 (not [M+Na]+)",
    '21.9893':"Nominal mass error [M]+1.0000 (not [M+Na]+)",
    '0.9964': 'Specify measured B-isotope(s)',
    '0.9963': 'Specify measured B-isotope(s)',
    '1.9927': 'Specify measured B-isotopes',
    '1.9928': 'Specify measured B-isotopes',
    '1.9979': 'Specify measured Br-isotope(s)',
    '1.9980': 'Specify measured Br-isotope(s)',
    '+17.9906':"Exchange 1 H- with 1 F-atom",
    '-17.9906':"Exchange 1 F- with 1 H-atom",
    '+14.9871':"Exchange 1 H- with 1 O-atom",
    '-14.9871':"Exchange 1 O- with 1 H-atom",
    '+77.9105':"Exchange 1 H- with 1 Br-atom",
    '-77.9105':"Exchange 1 Br- with 1 H-atom",
    '1.0039': 'Mass calcd for [M+1] (1x 13C)',
    '1.0038': 'Mass calcd for [M+1] (1x 13C)',
    '1.0034': 'Mass calcd for [M+1] (1x 13C)',
    '1.0033': 'Mass calcd for [M+1] (1x 13C)',
    '1.0032': 'Mass calcd for [M+1] (1x 13C)',
    '2.0064': 'Mass calcd for [M+2] (2x 13C)',
    '+21.9825':"Check [M+Na] vs. [M+H]",
    '+21.9820':"Check [M+Na] vs. [M+H]",
    '+21.9819':"Check [M+Na] vs. [M+H]",
    '-21.9820':"Check [M+Na] vs. [M+H]",
    '-21.9819':"Check [M+Na] vs. [M+H]",
    '-21.9814':"Check [M+Na] vs. [M+H]",
    '+23.0005':"Nominal mass error (Na=23.0000)",
    '+23.0006':"Nominal mass error (Na=23.0000)"


}

# Generate the error dictionary
elements = [
    'H',  'He', 'Li', 'Be', 'B',  'C',  'N',  'O',  'F',  'Ne',
    'Na', 'Mg', 'Al', 'Si', 'P',  'S',  'Cl', 'Ar', 'K',  'Ca',
    'Sc', 'Ti', 'V',  'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn',
    'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr', 'Rb', 'Sr', 'Y',  'Zr',
    'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn',
    'Sb', 'Te', 'I',  'Xe', 'Cs', 'Ba', 'La', 'Ce', 'Pr', 'Nd',
    'Pm', 'Sm', 'Eu', 'Gd', 'Tb', 'Dy', 'Ho', 'Er', 'Tm', 'Yb',
    'Lu', 'Hf', 'Ta', 'W',  'Re', 'Os', 'Ir', 'Pt', 'Au', 'Hg',
    'Tl', 'Pb', 'Bi','D','CH','CH2','CH3','CH4','NH','NH2','NH3','NH4',
    'OH','H2O','H3O','NO','NO2','OCH3','CF3','C2H5','C2H6','HF','HCl',
    'HBr','HS','HI','C3H8','C4H10'

]

atom_counts = range(1, 11)  # 1 to 10
error_dictionary = generate_error_dictionary(elements, atom_counts, special_errors)

def categorize_error(error_value, known_errors, tolerance=0.0001):
    """
    Categorizes the error based on a given error value and a dictionary of known atomic masses.
    Generates a message indicating whether atoms should be added or removed.

    Parameters:
    error_value (float): The calculated error between the calculated and recalculated mass.
    known_errors (dict): A dictionary where keys are atomic masses and values are the element descriptions.
    tolerance (float): The tolerance range within which the error value should match a known difference.

    Returns:
    str: The dynamically generated error message if a match is found, otherwise returns a blank space for zero difference.
    """
    # Check if the error value is effectively zero within the tolerance range
    if abs(error_value) <= tolerance:
        return ""  # Return a blank space if the difference is zero

    # Special case handling for known mass differences
    for atomic_mass, atom_description in known_errors.items():
        # Check if the error matches the dictionary value or the dictionary value plus 0.0001
        if (abs(abs(error_value) - atomic_mass) <= tolerance or
                abs(abs(error_value) - (atomic_mass + 0.0001)) <= tolerance):

            if len(atom_description) > 13:  # Check if the database entry is longer than six characters
                return atom_description  # Return the database entry directly

            # Extract the count and element from the dictionary entry
            parts = atom_description.split()
            if len(parts) != 2:
                # Handle unexpected format
                return atom_description

            count_str, element = parts
            try:
                count = int(count_str)
            except ValueError:
                # Handle cases where count is not an integer
                return atom_description

            # Generate the correct message based on the sign of the error
            if error_value > 0:
                return f"Add {count} {element} to formula"
            else:
                return f"Remove {count} {element} from formula"

    # If no match found, return the error value as a string with the correct sign
    return f"{error_value:+.4f}"


def hrms_cleanup(result, error_dictionary):
    """
    Processes a list of HRMS data strings and extracts specified components,
    ensuring that the ion notation is correctly captured and then removed from the line.
    Before processing each line, it removes all strings within the line that are shorter than
    5 characters and do not contain a capital 'M'.
    Recalculates the monoisotopic mass using the molmass library and computes error.

    Parameters:
    - result (list of str): The list containing HRMS data strings.
    - error_dictionary (dict): The autogenerated error dictionary with mass differences and descriptions.

    Returns:
    - list of list: A list where each sublist contains extracted data, including error calculations and descriptions.
    """

    # Initialize the parsed_results list
    parsed_results = []

    # Updated ion_pattern to include optional digits before 'M'
    ion_pattern = re.compile(r'\[\d*M[^]]*]\S*')

    # New formula pattern: word starting with 'C', followed by digits, 'H', digits, and possibly other elements
    #formula_pattern = re.compile(r'C\d+H\d+(?:[A-Z][a-z]?\d*|\[\d+[A-Z][a-z]*\d*)*[+-]?')
    #formula_pattern = re.compile(r'C\d+H\d+(?:[A-Z][a-z]?\d*|\[\d+[A-Z][a-z]*\d*\])*[+-]?')

    #formula_pattern = re.compile(r'C\d+(?:H\d+|F\d+)(?:[A-Z][a-z]?\d*|\[\d+[A-Z][a-z]*\d*])*[+-]?')
    #formula_pattern = re.compile(r'C\d+(?:H\d+|F\d+|D\d+)(?:[A-Z][a-z]?\d*|\[\d+[A-Z][a-z]*\d*])*[+-]?')
    #formula_pattern = re.compile(r'C\d+(?:H\d+|F\d+|D\d+)(?:[A-Z][a-z]?\d*|\[\d*[A-Z][a-z]*\]\d*)*[+-]?')
    formula_pattern = re.compile(r'C\d+(?:H\d+|F\d+)(?:[A-Z][a-z]?\d*|\[\d+[A-Z][a-z]*\d*]\d*)*[+-]?')
    
    # Pattern for floats with exactly 4 digits after decimal point
    float_pattern = re.compile(r'\d+\.\d{4}')

    # Process each line in the result list
    for line in result:
        # Remove words shorter than 5 characters that do not contain a capital 'M'
        words = line.split()
        words_filtered = [word for word in words if len(word) >= 5 or ('M' in word)]
        line = ' '.join(words_filtered)

        # Initialize a row with 8 empty elements (added a column for Error)
        row = [''] * 8

        # Extract the ion notation and its charge
        ion_match = ion_pattern.search(line)
        ion_charge = ''
        if ion_match:
            ion = ion_match.group(0)
            row[1] = ion.strip()
            # Extract the charge from the ion notation if present (e.g., ]+, ]-, ]2+)
            ion_charge_match = re.search(r'(\d*[+-])?$', ion)
            if ion_charge_match:
                ion_charge = ion_charge_match.group(1)
            # Remove the ion notation from the line
            line = line.replace(ion, '')
        else:
            row[1] = ''

        # Now proceed to extract the formula, calcd mass, and found mass from the modified line

        # Extract the formula
        formula_match = formula_pattern.search(line)

        if formula_match:
            formula = formula_match.group(0).strip()
            # If the formula ends with ion_charge, remove ion_charge from formula
            if ion_charge and formula.endswith(ion_charge):
                formula = formula[:-len(ion_charge)].strip()
            # Check if there's a charge present in the formula
            charge_match = re.search(r'([+-]\d*)$', formula)
            if charge_match:
                charge = charge_match.group(1)
                formula_no_charge = formula.replace(charge, "")
            else:
                charge = ion_charge if ion_charge else '+'
                formula_no_charge = formula

            # Enclose the formula in square brackets before recalculating the mass

            formula_in_brackets = f'[{formula_no_charge}]{charge}'
            formula_in_brackets = formula_in_brackets.replace("H1HeXe", "[13C]")
            formula_in_brackets = formula_in_brackets.replace("C1F", "CF")
            formula_in_brackets = formula_in_brackets.replace("H1N", "HN")
            row[0] = formula_in_brackets

            # Recalculate the monoisotopic mass using molmass while keeping isotopic notation intact
            try:
                recalculated_mass = Formula(formula_in_brackets).monoisotopic_mass
                if ion_charge:
                    if ion_charge in ("+", "-"):
                        charge_number = 1
                    else:
                        charge_number = int(ion_charge[:-1])  # Extract the numeric part of the charge
                    recalculated_mass /= abs(charge_number)

                row[4] = f'{recalculated_mass:.4f}'  # Store the monoisotopic mass with 4 decimal precision
            except Exception as e:
                row[4] = 'Error'  # Handle the case where the formula is invalid for molmass
        else:
            row[0] = ''
            row[4] = ''

        # Extract all floats with exactly 4 decimal places
        floats_with_4_decimals = float_pattern.findall(line)

        # Extract the calcd mass - first occurring float with 4 decimal places
        if floats_with_4_decimals:
            calcd_mass = floats_with_4_decimals[0]
            row[2] = calcd_mass.strip()
        else:
            row[2] = ''

        # Extract the found mass - second float with 4 decimal places, if it exists
        if len(floats_with_4_decimals) >= 2:
            found_mass = floats_with_4_decimals[1]
            row[3] = found_mass.strip()
        else:
            row[3] = ''

        # Calculate the error between the calculated mass and the recalculated mass
        if row[2] and row[4] and row[2] != 'Error' and row[4] != 'Error':
            try:
                error = float(row[2]) - float(row[4])
                # Categorize the error based on the error value
                error_description = categorize_error(error, error_dictionary)
                # Check for a typo error if no existing error description
                if is_float(error_description) or error==0:

                    if differ_in_single_digit_except_last_two(float(row[2]), float(row[3])):
                        error_description = "Typo (Calcd,Found)"

                    if differ_in_single_digit_except_last_two(float(row[2]), float(row[4])):
                        error_description = "Typo (Calcd,Recalcd)"

                    if have_swapped_adjacent_digits(float(row[2]), float(row[3])):
                        error_description = "Transposed digits (Calcd,Found)"

                    if have_swapped_adjacent_digits(float(row[2]), float(row[4])):
                        error_description = "Transposed digits (Calcd,Recalcd)"

                    if error_description in ("-0.0010", "-0.0011", "-0.0012") and ion_charge == "-":
                        error_description = "Mass was calculated for cation"

                    if error_description in ("-0.0010", "-0.0011", "-0.0012") and "M-" in row[1]:
                        error_description = "Mass was calculated for cation"
                    #print(error_description)

                    mw_plus = round(calculate_molecular_weight(row[0]), 4)
                    if float(row[2]) == mw_plus:
                        error_description = "Molecular weight error"

                    mw_plus_plus1 = round(mw_plus + 1, 4)
                    if float(row[2]) == mw_plus_plus1:
                        error_description = "Molecular weight error"

                    mw_plus_plus23 = round(mw_plus + 23, 4)
                    if float(row[2]) == mw_plus_plus23:
                        error_description = "Molecular weight error"

                    formula_neutral = row[0].replace("+", "")
                    mw_neutral = round(calculate_molecular_weight(formula_neutral), 4)
                    if mw_neutral == float(row[2]):
                        error_description = "Molecular weight error (neutral)"

                    mw_neutral_plus1 = round(mw_neutral + 1, 4)
                    if mw_neutral_plus1 == float(row[2]):
                        error_description = "Molecular weight error (neutral+1)"

                    mw_neutral_plus23 = round(mw_neutral + 23, 4)
                    if mw_neutral_plus23 == float(row[2]):
                        error_description = "Molecular weight error (neutral+23)"

                    if "Na" in row[0]:
                        formula_minus_sodium = row[0].replace("Na", "")
                        mw1 = round(calculate_molecular_weight(formula_minus_sodium), 4) + 23
                        if mw1 == float(row[2]):
                            error_description = "Molecular weight + 23.0000"
                    else:
                        formula_plus_sodium = row[0].replace("[", "").replace("]", "").replace("+", "").replace("-", "")
                        formula_plus_sodium = formula_plus_sodium+"Na"
                        mw_plus_sodium = round(calculate_molecular_weight(formula_plus_sodium), 4)
                        if mw_plus_sodium == float(row[2]):
                            error_description = "Molecular weight error (Formula+Na)"

                    formula_minus_h = row[0].replace("[", "").replace("]", "").replace("+", "").replace("-", "")
                    formula_minus_h = decrease_element_count(formula_minus_h, 'H')
                    mw2 = round(calculate_molecular_weight(formula_minus_h), 4) + 1
                    if mw2 == float(row[2]):
                        error_description = "Molecular weight + 1.0000"

                row[7] = error_description  # Replace the error value with the error description or keep the difference

            except ValueError:
                row[7] = 'Error'
        else:
            row[7] = 'Error'

        if row[1] and row[2] and row[3] and not row[0]:
            row[7] = 'No formula found'

        # Skip the row if both row[0] and row[1] are empty
        if not row[0] and not row[1]:
            continue  # Do not append this row to parsed_results

        # Append the row to the parsed_results list
        parsed_results.append(row)

    return parsed_results


def calc_dev_calcd_and_recalcd(cleaned_results):
    """
    Calculates the absolute deviation between the calculated mass, recalculated mass, and the found mass in ppm,
    and updates the 'Dev (Calcd)' and 'Dev (Recalcd)' columns in the cleaned_results list.

    Parameters:
    cleaned_results (list of list): The list containing extracted data.

    Returns:
    list of list: The updated cleaned_results list with 'Dev (Calcd)' and 'Dev (Recalcd)' columns filled.
    """
    for row in cleaned_results:
        calcd_mass = row[2]
        found_mass = row[3]
        recalcd_mass = row[4]

        # Initialize found_mass_float only if found_mass exists and is valid
        found_mass_float = None
        if found_mass:
            try:
                found_mass_float = float(found_mass)
            except ValueError:
                found_mass_float = None

        # Calculate deviation for the calculated mass
        if calcd_mass and found_mass_float is not None:
            try:
                calcd_mass_float = float(calcd_mass)
                deviation_calcd = abs((found_mass_float - calcd_mass_float) / calcd_mass_float) * 1e6  # ppm
                row[5] = f"{deviation_calcd:.1f}"  # Format to one decimal place
            except ValueError:
                row[5] = ''  # Leave the field empty if conversion fails
        else:
            row[5] = ''

        # Calculate deviation for the recalculated mass
        if recalcd_mass and found_mass_float is not None:
            try:
                recalcd_mass_float = float(recalcd_mass)
                deviation_recalcd = abs((found_mass_float - recalcd_mass_float) / recalcd_mass_float) * 1e6  # ppm
                row[6] = f"{deviation_recalcd:.1f}"  # Format to one decimal place
            except ValueError:
                row[6] = ''  # Leave the field empty if conversion fails
        else:
            row[6] = ''
    return cleaned_results


def print_aligned_table(cleaned_results):
    """
    Displays the cleaned_results in an aligned table format in Streamlit,
    highlighting deviations greater than 10 ppm in red and error messages in purple.
    """
    headers = ['Formula', 'Ion', 'Calcd Mass', 'Found Mass', 'Recalcd Mass',
               'Dev (Calcd)', 'Dev (Recalcd)', 'Error']

    # Build HTML table with inline CSS for borders, padding, and monospaced font
    table_html = '<table style="border-collapse: collapse; width: 100%; font-family: monospace;">'

    # Create header row
    table_html += '<tr>'
    for header in headers:
        table_html += f'<th style="border: 1px solid black; padding: 4px; text-align: left;">{header}</th>'
    table_html += '</tr>'

    # Create data rows
    for row in cleaned_results:
        table_html += '<tr>'
        for i, cell in enumerate(row):
            # Determine text alignment: right align for numeric columns
            align = 'right' if i in [2, 3, 4, 5, 6, 7] else 'left'
            style = f"text-align: {align}; border: 1px solid black; padding: 4px;"
            cell_str = str(cell)

            # For deviation columns, apply red color if deviation > 10
            if i in [5, 6]:
                try:
                    if float(cell) > 10:
                        style += " color: red;"
                except (ValueError, TypeError):
                    pass
            # For the error column, apply purple if the cell doesn't represent a number
            elif i == 7:
                if isinstance(cell, str) and not re.match(r'^[+-]?\d*\.?\d+$', cell_str):
                    style += " color: purple;"

            table_html += f'<td style="{style}">{cell_str}</td>'
        table_html += '</tr>'

    table_html += '</table>'

    # Display the table in Streamlit
    st.markdown(table_html, unsafe_allow_html=True)


def search_calcd_with_floats(text: str) -> List[str]:
    """
    Search for 'calcd' followed by two floats with four decimal places.
    Extract from up to 32 characters before 'calcd' (if no float present) until the second float.
    Only extract if total length is less than 100 characters.

    Args:
        text (str): Input text to search

    Returns:
        List[str]: List of matching strings
    """
    pattern_float = re.compile(r'\d+\.\d{4}')
    results = []

    # Find all occurrences of 'calcd', case-insensitive
    for calcd_match in re.finditer('calcd', text, re.IGNORECASE):
        calcd_start = calcd_match.start()

        # Look at up to 35 characters before 'calcd'
        pre_calcd_start = max(0, calcd_start - 32)
        pre_calcd_text = text[pre_calcd_start:calcd_start]

        # Check if there's a float in the pre-calcd text
        pre_calcd_floats = list(pattern_float.finditer(pre_calcd_text))

        # Determine the start position based on pre-calcd text
        if not pre_calcd_floats:  # If no floats found before calcd
            extraction_start = pre_calcd_start
        else:
            extraction_start = calcd_start

        # Look ahead for floats after 'calcd'
        post_calcd_text = text[calcd_start:calcd_start + 100]
        post_floats = list(pattern_float.finditer(post_calcd_text))

        if len(post_floats) >= 2:
            # End at the second float
            end_pos = calcd_start + post_floats[1].end()

            # Only extract if total length is less than 100 characters
            if end_pos - extraction_start < 100:
                result = text[extraction_start:end_pos]
                results.append(result)

    return results


def search_hrms_with_floats(text: str) -> List[str]:
    """
    Search for 'HRMS' followed by at least two floats with four decimal places.
    If 'calcd' appears in the 25 characters after the second float, stop at the second float.
    Otherwise, include up to 25 characters after the second float.

    Args:
        text (str): Input text to search

    Returns:
        List[str]: List of matching strings
    """
    pattern_float = re.compile(r'\d+\.\d{4}')
    hrms_positions = [m.start() for m in re.finditer('HRMS', text)]
    results = []

    for hrms_pos in hrms_positions:
        # Extract up to 100 characters from 'HRMS'
        max_length_substring = text[hrms_pos:hrms_pos + 100]
        floats = list(pattern_float.finditer(max_length_substring))

        if len(floats) >= 2:
            second_float_end = floats[1].end()

            # Look at the next 25 characters after the second float
            next_25_chars = max_length_substring[second_float_end:second_float_end + 25]

            # If 'calcd' appears in next 25 chars, stop at second float
            if 'calcd' in next_25_chars.lower():
                end_pos = hrms_pos + second_float_end
            else:
                # If no 'calcd', include up to 25 characters after second float
                end_pos = hrms_pos + second_float_end + 25

            # Ensure end position doesn't exceed text length or 100 characters from 'HRMS'
            end_pos = min(len(text), end_pos, hrms_pos + 100)
            result = text[hrms_pos:end_pos].strip()
            results.append(result)

    return results

def process_replacements(text: str) -> str:
    """
    Perform all necessary string replacements on the text.
    """
    replacements = {
        r', M+H':' [M+H',
        r', M+Na': ' [M+Na',
        r' is ':' ',
        r'LCMS':'HRMS',
        r'HRESIMS':"HRMS",
        r'HRESI': 'HRMS',
        r'HR-MS': 'HRMS',
        r'ESI-MS': ' HRMS',
        r'‐': '-',
        r'‒':r'-',
        r'MHz':'',
        r'MeOD':'',
        r'Cal':"cal",
        r'calculated': 'calcd ',
        r'calcd.': 'calcd ',
        r'calc. ': 'calcd ',
        r'calc ': 'calcd ',
        r'chemical':'',
        r'formula':'',
        r' ⊕': "+",
        r'•': "",
        r'':'',
        r'∙':'',
        r'∙':'',
        r'●':'',
        r'＋':'+',
        r'Observed':' ',
        r'observed':' ',

    }

    for pattern, replacement in replacements.items():
        text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
    text = ' '.join(text.split()).strip()
    return text


def extract_text_from_pdf(pdf_file):
    """
    Extract text from a PDF file using fitz (PyMuPDF).

    Args:
        pdf_file: The uploaded PDF file object

    Returns:
        str: The extracted text from the PDF
    """
    try:
        # Create a byte stream from the uploaded file
        pdf_bytes = io.BytesIO(pdf_file.getvalue())

        # Open the PDF with fitz
        doc = fitz.open(stream=pdf_bytes, filetype="pdf")

        # Extract text from all pages
        text = ""
        for page_num in range(len(doc)):
            page = doc[page_num]
            text += page.get_text() + " "

        # Close the document
        doc.close()

        return text
    except Exception as e:
        st.error(f"Error extracting text from PDF: {str(e)}")
        return ""



# Assume utility functions are imported as before

def main():
    st.set_page_config(page_title="Check Accurate Mass Measurements", page_icon="🧪", layout="wide")

    st.markdown(
        """
        <style>
            div.block-container {
                overflow-y: auto !important;
            }
            iframe {
                overflow: visible !important;
            }
        </style>
        """, unsafe_allow_html=True
    )

    st.title("Check Accurate Mass Measurements")

    st.markdown("[M. Christmann, *Org. Lett.* **2025**, *27*, 4–7.](https://pubs.acs.org/doi/10.1021/acs.orglett.4c03458)")

    st.write("""
    This app automatically analyzes accurate mass measurements. 
    Upload a PDF file or paste your text in the box below to analyze it.
    """)

    tab1, tab2 = st.tabs(["Upload PDF", "Text Input"])

    with tab1:
        uploaded_file = st.file_uploader("Choose a PDF file", type=['pdf'])
        analyze_pdf = st.button("Analyze PDF")

        if analyze_pdf and uploaded_file is not None:
            with st.spinner("Extracting text from PDF..."):
                text_content = extract_text_from_pdf(uploaded_file)

                if text_content:
                    st.success(f"Successfully extracted text from {uploaded_file.name}")
                    st.write("---")
                    analyze_content(text_content)
                else:
                    st.error("Failed to extract text from the PDF. Please check if the PDF contains extractable text.")

    with tab2:
        text_input = st.text_area("Paste your text here:", height=300)
        analyze_text = st.button("Analyze Text")

        if analyze_text:
            if not text_input:
                st.warning("Please paste some text to analyze.")
            else:
                st.write("---")
                text_content = text_input.replace('\n', ' ')
                analyze_content(text_content)




def analyze_content(text_content):
    text_content = remove_specific_lines_from_string(text_content)
    # st.write(text_content)
    text_content = re.sub(r'\s+', ' ', text_content).strip()  # Replace multiple spaces with a single space
    text_content = process_replacements(text_content)
    text_content = replace_comma_with_decimal(text_content)
    text_content = adjust_space_around_decimal(text_content)
    text_content = fix_floats(text_content)
    # st.write(text_content)
    text_content = remove_page_numbers(text_content)
    text_content = re.sub(r'\[((C\d+(?:[A-Z][a-z]?\d*)*),\s*([M+][^]]+))', r'\1 [\3]', text_content)
    text_content = re.sub(r'(C)(\d+)(h)(\d+)', lambda m: f'C{m.group(2)}H{m.group(4)}', text_content,
                          flags=re.IGNORECASE)
    text_content = re.sub(r'(c)(\d+)(H)(\d+)', lambda m: f'C{m.group(2)}H{m.group(4)}', text_content,
                          flags=re.IGNORECASE)
    text_content = re.sub(r'\b(C)(\d+)(HD)\b', r'C\2H1D', text_content)
    text_content = re.sub(r'\b(C)\s*(\d*)\s*(H)\s*(\d*)\s*(N)\s*(\d*)\b',
                          lambda
                              m: f"{m.group(1)}{m.group(2) or ''}{m.group(3)}{m.group(4) or ''}{m.group(5)}{m.group(6) or ''}",
                          text_content)

    text_content = re.sub(r'\b(C)\s*(\d*)\s*(H)\s*(\d*)\s*(O)\s*(\d*)\b',
                          lambda
                              m: f"{m.group(1)}{m.group(2) or ''}{m.group(3)}{m.group(4) or ''}{m.group(5)}{m.group(6) or ''}",
                          text_content)
    text_content = text_content.replace("C2o", "C20").replace("C1o", "C10").replace("Cal", "cal")
    text_content = re.sub(r'B(\d+)H(\d+)', r'H\2B\1', text_content)
    text_content = text_content.replace('\n', ' ').replace('+-', '+').replace(':', " ").replace('–', '-').replace(',',
                                                                                                                  " ")
    text_content = remove_spaces_within_brackets(text_content)
    # Remove nested brackets from [(M+H]]+ etc.
    text_content = re.sub(r'\(\[([^]]{1,10})]\+\)', r'[\1]+', text_content)
    text_content = re.sub(r'\[\[([^]]{1,10})]\+]', r'[\1]+', text_content)
    text_content = text_content.replace(' [[', '[').replace(']]', ']')

    replacements = {
        "₁": "1", "₂": "2", "₃": "3", "₄": "4", "₅": "5",
        "₆": "6", "₇": "7", "₈": "8", "₉": "9", "₀": "0",
        "¹": "1", "²": "2", "³": "3", "⁴": "4", "⁵": "5",
        "⁶": "6", "⁷": "7", "⁸": "8", "⁹": "9", "⁰": "0",
        "С": "C", "Н": "H",
        "C ": "C", " H ": "H", " F ": "F", " N ": "N", " Cl ": "Cl",
        " Br ": "Br", " O ": "O", " I ": "I", " P ": "P", " B ": "B",
        " S ": "S", " NO ": "NO", " Na ": "Na", " SNa ": "SNa", " NNa ": "NNa",
        " + ": "+"
    }

    # Apply replacements and additional processing steps.
    for original, replacement in replacements.items():
        text_content = text_content.replace(original, replacement)
    text_content = remove_spaces_in_formula(text_content)
    text_content = text_content.replace('#', '')
    text_content = re.sub(r'(C\d+)', r' \1', text_content)
    text_content = transform_expressions_in_text(text_content)
    text_content = isotope_correct(text_content)
    text_content = protect_floats(text_content)
    text_content = text_content.replace("[13C]", "H1HeXe")
    text_content = text_content.replace("CF", "C1F")
    text_content = text_content.replace("HN", "H1N")
    # st.write(text_content)  # Optionally display intermediate output
    results1 = search_hrms_with_floats(text_content)
    modified_text = text_content
    for match in results1:
        modified_text = modified_text.replace(match, '')
    # Clean up any extra spaces
    modified_text = re.sub(r'\s+', ' ', modified_text).strip()
    text_content = modified_text
    results2 = search_calcd_with_floats(text_content)

    results = results1 + results2
    cleaned_results = hrms_cleanup(results, error_dictionary)

    cleaned_results = calc_dev_calcd_and_recalcd(cleaned_results)
    cleaned_results = remove_sublists_with_missing_element1_positions_swapped(cleaned_results)

    # Remove duplicate sublists
    cleaned_results_new = []
    for sublist in cleaned_results:
        if sublist not in cleaned_results_new:
            cleaned_results_new.append(sublist)
    cleaned_results = cleaned_results_new

    # Count the total number of measurements
    num_row = len(cleaned_results)

    if cleaned_results:
        st.write(" ")
        print_aligned_table(cleaned_results)
        if check_conditions(cleaned_results):
            st.success("Awesome! No mistakes!")
    else:
        st.write(" ")
        st.write(f"No HRMS matches found in the uploaded file")

if __name__ == '__main__':
    main()