"""
This is a placeholder script to extract epr data from files, where we can
"""

"""
July 2025 LiveWest Heating Upgrades
"""
import os
import re
import PyPDF2
import pandas as pd
from tqdm import tqdm
from collections import Counter


def extract_window_age_description(windows_text):
    """
    Extracts the most common window age description and its proportion.

    Parameters:
        windows_text (str): The text section containing window data.

    Returns:
        dict: A dictionary with the most common window age description and its proportion.
    """
    # Clean up windows_text by removing line breaks for better pattern matching
    windows_text = windows_text.replace("\n", "")

    # Define possible window age descriptions
    window_descriptions = [
        "Double post or during 2002",
        "Double pre 2002",
        "Double with unknown install date",
        "Secondary glazing",
        "Triple glazing",
        "Single glazing",
        "Double between 2002 \nand 2021",
        "Double between 2002 and 2021"
    ]

    # Count occurrences of each description
    description_counts = Counter()
    for description in window_descriptions:
        matches = re.findall(re.escape(description), windows_text)
        description_counts[description] = len(matches)

    if not description_counts or not sum(description_counts.values()):
        raise ValueError("Failed to extract window data.")

    # Determine the most common description and calculate its proportion
    most_common_description, window_count = description_counts.most_common(1)[0]
    window_proportion = window_count / sum(description_counts.values()) * 100

    # Get the second most common and the proportion
    if window_proportion == 100:
        second_most_common_description = None
        second_most_common_proportion = 0
    else:
        second_most_common_description, second_window_count = description_counts.most_common(2)[1]
        second_most_common_proportion = second_window_count / sum(description_counts.values()) * 100

    return {
        "Window Age Description": most_common_description,
        "Window Age Description Proportion (%)": window_proportion,
        "Secondary Window Age Description": second_most_common_description,
        "Secondary Window Age Description Proportion (%)": second_most_common_proportion,
        "Number of Windows": sum(description_counts.values())
    }


def extract_building_parts_summary(text):
    """
    Extracts building parts and associated dimensions from the summary report PDF.
    This includes Main Property, multiple extensions if they exist, and Room in Roof areas.
    """
    data = []

    # Locate the Dimensions section
    dimensions_section = re.search(
        r"Dimensions:\s*Dimension type: Internal\n(.*?)\n5\.0 Conservatory:", text, re.DOTALL
    )
    if not dimensions_section:
        dimensions_section = re.search(
            r"Dimensions:\s*Dimension type: External\n(.*?)\n5\.0 Conservatory:", text, re.DOTALL
        )
        if not dimensions_section:
            raise ValueError("Failed to locate dimensions section in the text.")

    dimensions_text = dimensions_section.group(1)

    # Pattern to extract each building part, starting from Main Property and including extensions
    building_part_pattern = re.compile(
        r"(Main Property|\d+(?:st|nd|rd|th) Extension)\s*"
        r"(.*?)(?=\d+(?:st|nd|rd|th) Extension|5\.0 Conservatory|$)",
        re.DOTALL
    )

    # Loop through each building part match, including Main Property and extensions
    for match in building_part_pattern.finditer(dimensions_text):
        part_name = match.group(1)
        floor_data = match.group(2)

        # Pattern to extract floor details: Floor Level, Floor Area, Room Height, Perimeter, Party Wall Length
        floor_pattern = re.compile(
            r"(1st Floor|Lowest Floor|Second floor):\s*([\d.]+)\s+([\d.]+)\s+([\d.]+)\s+([\d.]+)"
        )

        # Extract data for each floor within the building part
        for floor_match in floor_pattern.finditer(floor_data):
            floor_level = floor_match.group(1)
            floor_area = float(floor_match.group(2))
            room_height = float(floor_match.group(3))
            perimeter = float(floor_match.group(4))
            party_wall_length = float(floor_match.group(5))

            # Append to data list
            data.append({
                "Building Part": part_name,
                "Floor Level": floor_level,
                "Floor Area (m2)": floor_area,
                "Room Height (m)": room_height,
                "Perimeter (m)": perimeter,
                "Party Wall Length (m)": party_wall_length
            })

        # Check specifically for "Room(s) in Roof" entries, which only have Floor Area
        room_in_roof_pattern = re.compile(r"Room\(s\) in Roof:\s*([\d.]+)")
        room_in_roof_match = room_in_roof_pattern.search(floor_data)
        if room_in_roof_match:
            floor_area = float(room_in_roof_match.group(1))
            data.append({
                "Building Part": part_name,
                "Floor Level": "Room in Roof",
                "Floor Area (m2)": floor_area,
                "Room Height (m)": None,  # Placeholder for missing data
                "Perimeter (m)": None,  # Placeholder for missing data
                "Party Wall Length (m)": None  # Placeholder for missing data
            })

    # Calculate aggregated dimensions
    main_property = [part for part in data if "Main Property" in part["Building Part"]]
    first_extensions = [part for part in data if "1st Extension" in part["Building Part"]]
    dimensions = {
        "Total Floor Area (m2)": sum([part["Floor Area (m2)"] for part in data]),
        "Total Ground Floor Area (m2)": sum(
            [part["Floor Area (m2)"] for part in data if "Lowest Floor" in part["Floor Level"]]
        ),
        "RIR Floor Area": sum(
            [part["Floor Area (m2)"] for part in data if "Room in Roof" in part["Floor Level"]]
        ),
        "Main Building Wall Area (m2)": sum([x["Perimeter (m)"] * x["Room Height (m)"] for x in main_property if
                                             x["Perimeter (m)"] and x["Room Height (m)"]]),
        "First Extension Wall Area (m2)": sum(
            [x["Perimeter (m)"] * x["Room Height (m)"] for x in first_extensions if
             x["Perimeter (m)"] and x["Room Height (m)"]]
        ),
    }

    return dimensions


def extract_roof_details_summary(text):
    """
    Extracts roof type, insulation, and insulation thickness for each building part
    in the 8.0 Roofs section of the summary report.
    """
    # Define data structure to hold results
    roof_data = []

    # Locate the entire 8.0 Roofs section
    roof_section_match = re.search(r"8\.0 Roofs:\n(.*?)(?=\n9\.0 Floors:|$)", text, re.DOTALL)
    if not roof_section_match:
        return roof_data  # Return empty if no roof section is found

    # Extract the roof section and append "9.0 Floors:" as the boundary
    roof_section = roof_section_match.group(1).strip() + "\n9.0 Floors:"

    # Define pattern to match each building part's roof entry
    building_part_pattern = re.compile(
        r"(Main Property|1st Extension|2nd Extension|[\w\s]+)\n"  # Matches each building part label
        r"Type\s+(.*?)(?=\n(?:Insulation|9\.0 Floors:|[A-Z]))"  # Matches Roof Type until the next field, label, or end
        r"(?:\nInsulation\s+(.*?)(?=\n(?:Insulation Thickness|9\.0 Floors:|[A-Z])))?"  # Optional Insulation
        r"(?:\nInsulation Thickness\s+(.*?)(?=\n(?:9\.0 Floors:|[A-Z])))?",  # Optional Insulation Thickness
        re.DOTALL
    )

    # Extract each building part's data
    for match in building_part_pattern.finditer(roof_section):
        part_name = match.group(1).strip()  # Building part label
        roof_type = match.group(2).strip()  # Roof Type
        roof_insulation = match.group(3).strip() if match.group(3) else None  # Optional Insulation
        roof_insulation_thickness = match.group(4).strip() if match.group(4) else None  # Optional Thickness

        # Cleaning to handle annoying cases when it comes out like this:
        # 'A Another dwelling above\n1st Extension'
        if roof_type.startswith("A Another dwelling above"):
            roof_type = "A Another dwelling above"

        # Store results for this building part
        roof_data.append({
            "Building Part": part_name,
            "Roof Type": roof_type,
            "Roof Insulation": roof_insulation,
            "Roof Insulation Thickness": roof_insulation_thickness,
        })

    return roof_data


def extract_wall_details_summary(text):
    """
    Extracts wall type, insulation, dry-lining, and thickness for each building part,
    including any alternative wall details within the 7.0 Walls section of the summary PDF text.
    """
    # Define data structure to hold all building part wall entries
    wall_data = []

    # Locate the entire 7.0 Walls section
    wall_section = re.search(r"7\.0 Walls:\n(.*?)\n8\.0 Roofs:", text, re.DOTALL).group(1)

    # Define pattern to match each building part's wall entry within the section
    building_part_pattern = re.compile(
        r"(Main Property|1st Extension|2nd Extension|[\w\s]+)\n"  # Matches each building part label
        r"Type\s+(.*?)\n"  # Matches main wall Type
        r"Insulation\s+(.*?)\n",  # Matches main wall Insulation
        # r"(Dry-lining\s+(.*?)\n)?"  # Optional main wall Dry-lining
        # r"Wall Thickness Unknown\s+(.*?)\n"  # Matches main wall Thickness Unknown
        # r"Wall Thickness \[mm\]\s+(\d+)",  # Matches main wall Thickness
        re.DOTALL
    )

    # Define pattern to capture alternative wall details, if present
    alternative_wall_pattern = re.compile(
        r"Alternative Wall Area.*?\n"  # Matches start of alternative wall section
        r"Alternative Type\s+(.*?)\n"  # Matches alternative wall Type
        r"Alternative Insulation\s+(.*?)\n"  # Matches alternative wall Insulation
        r"(Alternative Dry-lining\s+(.*?)\n)?"  # Optional Alternative Dry-lining
        r"Alternative Wall Thickness Unknown\s+(.*?)\n"  # Matches alternative wall Thickness Unknown
        r"Alternative Wall Thickness\s+(\d+)",  # Matches alternative wall Thickness
        re.DOTALL
    )

    # Find all building part entries within the 7.0 Walls section
    for match in building_part_pattern.finditer(wall_section):

        wall_label = match.group(1).strip()
        main_wall_type = match.group(2).strip()
        main_wall_insulation = match.group(3).strip()
        # main_wall_dry_lining = match.group(5).strip() if match.group(5) else "N/A"
        # main_wall_thickness_unknown = match.group(6).strip()
        # main_wall_thickness = int(match.group(7))

        # Initialize dictionary for this wall entry
        wall_entry = {
            "Building Part": wall_label,
            "Wall Type": main_wall_type,
            "Wall Insulation": main_wall_insulation,
            # "Wall Dry-lining": main_wall_dry_lining,
            # "Wall Thickness Unknown": main_wall_thickness_unknown,
            # "Wall Thickness (mm)": main_wall_thickness,
            "Alternative Wall Type": None,
            "Alternative Wall Insulation": None,
            "Alternative Wall Dry-lining": "N/A",
            "Alternative Wall Thickness Unknown": None,
            "Alternative Wall Thickness (mm)": None,
        }

        # Check if there's an alternative wall section following this wall entry
        alt_match = alternative_wall_pattern.search(wall_section, match.end())
        if alt_match:
            wall_entry["Alternative Wall Type"] = alt_match.group(1).strip()
            wall_entry["Alternative Wall Insulation"] = alt_match.group(2).strip()
            wall_entry["Alternative Wall Dry-lining"] = alt_match.group(4).strip() if alt_match.group(4) else "N/A"
            wall_entry["Alternative Wall Thickness Unknown"] = alt_match.group(5).strip()
            wall_entry["Alternative Wall Thickness (mm)"] = int(alt_match.group(6))

        # Append each building part as a dictionary in the wall_data list
        wall_data.append(wall_entry)

    return wall_data


def extract_summary_report(pdf_path):
    """
    Extracts specific data from the provided PDF file.
    Data includes:
    - Current SAP rating
    - Fuel Bill
    - Address
    """

    data = {
        "Address": None,
        "Postcode": None,
        "Current SAP Rating": None,
        "Current EPC Band": None,
        "Fuel Bill": None,
        "Main Building Age Band": None,
        "Number of Storeys": None,
        "Window Age Description": None,
        "Window Age Description Proportion (%)": None,
        "Secondary Window Age Description": None,
        "Secondary Window Age Description Proportion (%)": None,
        "Number of Windows": None,
        "Total Number of Doors": None,
        "Number of Insulated Doors": None,
        "Existing Primary Heating System": None,
        "Existing Primary Heating PCDF Reference": None,
        "Existing Primary Heating Controls": None,
        "Existing Primary Heating % of Heat": None,
        "Existing Secondary Heating System": None,
        "Existing Secondary Heating PCDF Reference": None,
        "Existing Secondary Heating Controls": None,
        "Existing Secondary Heating % of Heat": None,
        "Secondary Heating Code": None,
        "Water Heating Code": None,
        'Total Floor Area (m2)': None,
        'Total Ground Floor Area (m2)': None,
        'RIR Floor Area': None,
        'Main Building Wall Area (m2)': None,
        'First Extension Wall Area (m2)': None,
        "Number of Light Fittings": None,
        "Number of LEL Fittings": None,
        "Number of fittings needing LEL": None,
        "Main Roof Type": None,
        "Main Roof Insulation": None,
        "Main Roof Insulation Thickness": None,
        "Main Wall Type": None,
        "Main Wall Insulation": None,
        "Main Wall Dry-lining": None,
        "Main Wall Thickness": None,
        "Main Building Alternative Wall Type": None,
        "Main Building Alternative Wall Insulation": None,
        "Main Building Alternative Wall Dry-lining": None,
        "Main Building Alternative Wall Thickness": None,
    }

    with (open(pdf_path, "rb") as file):
        reader = PyPDF2.PdfReader(file)
        text = ""
        for page in reader.pages:
            text += page.extract_text()

        # Extract Current SAP rating
        sap_match = re.search(r"Current SAP rating:\s*([A-Z] \d+)", text)
        data["Current SAP Rating"] = sap_match.group(1).split(" ")[1]

        data["Property Type"] = (
            re.search(r"Property type:\s*(.*?)\n2\.0", text, re.DOTALL)
            .group(1).replace('\n', ' ').strip().replace("  ", " ")
        )

        # Extract age
        age_band_match = re.search(
            r"3\.0 Date Built:\s*Main Property\s*[A-Z]?\s*(\d{4}-\d{4}|before \d{4}|\d{4} onwards)",
            text
        )
        data["Main Building Age Band"] = age_band_match.group(1)

        # Number of storeys
        storeys_match = re.search(r"Number of Storeys:\s*(\d+)", text)
        data["Number of Storeys"] = int(storeys_match.group(1))

        # Grab number of heated rooms, number of habitable rooms
        data["Number of Heated Rooms"] = int(re.search(r"Heated Habitable Rooms:\s*(\d+)", text).group(1))
        data["Number of Habitable rooms"] = int(re.search(r"Habitable Rooms:\s*(\d+)", text).group(1))

        # Extract Carbon Emissions
        # carbon_match = re.search(r"Emissions \(t/year\):\s*([\d.]+)\s*tonnes", text)
        # data["Carbon Emissions (t/year)"] = float(carbon_match.group(1))

        # Extract Fuel Bill
        fuel_bill_match = re.search(r"Fuel Bill:\s*£(\d+)", text)
        data["Fuel Bill"] = f"£{fuel_bill_match.group(1)}"

        # Extract individual address components
        postcode = re.search(r"Postcode:\s*(.*?)\nRegion:", text)
        # region = re.search(r"Region:\s*(.*?)\nHouse Name:", text)
        house_name = re.search(r"House Name:\s*(.*?)\nHouse No:", text)
        house_no = re.search(r"House No:\s*(.*?)\nStreet:", text)
        street = re.search(r"Street:\s*(.*?)\nLocality:", text)
        locality = re.search(r"Locality:\s*(.*?)\nTown:", text)
        town = re.search(r"Town:\s*(.*?)\nCounty:", text)
        county = re.search(r"County:\s*(.*?)\nProperty Tenure:", text)

        # Clean extracted values and remove any prefixes
        address_parts = [
            house_no.group(1).strip() if house_no else "",
            house_name.group(1).strip() if house_name else "",
            street.group(1).strip() if street else "",
            locality.group(1).strip() if locality else "",
            town.group(1).strip() if town else "",
            county.group(1).strip() if county else "",
            postcode.group(1).strip() if postcode else ""
        ]

        # Join non-empty parts with a comma
        data["Address"] = ", ".join([part for part in address_parts if part])
        data["Postcode"] = postcode.group(1).strip()

        # windows_section = re.search(r"Windows\s*(.*?)\s*Draught Proofing", text, re.DOTALL)
        # windows_text = windows_section.group(1)
        # window_data = extract_window_age_description(windows_text)
        # data.update(window_data)

        # Extract Total Number of Doors
        total_doors_match = re.search(r"Total Number of Doors\s*(\d+)", text)
        data["Total Number of Doors"] = int(total_doors_match.group(1))

        # Extract Number of Insulated Doors
        insulated_doors_match = re.search(r"Number of Insulated Doors\s*(\d+)", text)
        data["Number of Insulated Doors"] = int(insulated_doors_match.group(1))

        # Extract heating system
        # Extract Primary Heating Data
        # Extract Primary Heating Section
        primary_heating_section1 = re.search(r"Main\s*Heating1\s*(.*?)\s*Main\s*Heating2", text, re.DOTALL)
        primary_heating_section2 = re.search(r"Main\s*Heating1\s*(.*?)\s*Water\s*Heating", text, re.DOTALL)
        primary_heating_section = primary_heating_section1 if primary_heating_section1 else primary_heating_section2

        primary_text = primary_heating_section.group(1)

        # Handle extracting main heating code:
        mainheat_search = re.search(r"Main Heating Code\s*(.*?)\n", primary_text)
        if mainheat_search is None:
            mainheat_search = re.search(r"Main Heating EES Code\s*(.*?)\n", primary_text)
        if mainheat_search is None:
            mainheat_search = re.search(r"PCDF boiler Reference\s*(.*?)\n", primary_text)

        data["Existing Primary Heating System"] = mainheat_search.group(1).strip()

        data["Existing Primary Heating PCDF Reference"] = re.search(
            r"PCDF boiler Reference\s*(\d+)", primary_text
        ).group(1)

        controls_search = re.search(
            r"Main Heating Controls Sap\s*(.*?)\n", primary_text
        )
        if controls_search is None:
            controls_search = re.search(
                r"Main Heating Controls\s*(.*?)\n", primary_text
            )
        data["Existing Primary Heating Controls"] = controls_search.group(1).strip()
        data["Existing Primary Heating % of Heat"] = int(
            re.search(r"Percentage of Heat\s*(\d+)\s*%", primary_text).group(1)
        )

        # Extract Secondary Heating Section
        secondary_heating_section = re.search(r"Main\s*Heating2\s*(.*?)\s*Water\s*Heating", text, re.DOTALL)

        if secondary_heating_section is None:
            data["Existing Secondary Heating System"] = ""
            data["Existing Secondary Heating PCDF Reference"] = ""
            data["Existing Secondary Heating Controls"] = ""
            data["Existing Secondary Heating % of Heat"] = 0

        else:
            secondary_text = secondary_heating_section.group(1)

            main_heating_code_match_secondary = re.search(
                r"Main Heating Code\s*(.*?)(?=\n|Percentage of Heat)", secondary_text
            )
            if main_heating_code_match_secondary is None:
                main_heating_code_match_secondary = re.search(
                    r"Main Heating EES Code\s*(.*?)(?=\n|Percentage of Heat)", secondary_text
                )

            data["Existing Secondary Heating System"] = main_heating_code_match_secondary.group(1).strip()
            data["Existing Secondary Heating PCDF Reference"] = re.search(r"PCDF boiler Reference\s*(\d+)",
                                                                          secondary_text).group(1)
            second_heating_controls_match = re.search(r"Main Heating Controls\s*(.*?)\n", secondary_text)
            data["Existing Secondary Heating Controls"] = (
                second_heating_controls_match.group(1).strip() if second_heating_controls_match else ""
            )
            data["Existing Secondary Heating % of Heat"] = int(
                re.search(r"Percentage of Heat\s*(\d+)\s*%", secondary_text).group(1)
            )

        # Extract Secondary Heating and Water Heating Codes
        secondary_heating_code_match = re.search(r"Secondary Heating Code\s*(.*?)\n", text)
        water_heating_code_match = re.search(r"Water Heating Code\s*(.*?)\n", text)

        if data["Existing Secondary Heating System"] == "":
            data["Secondary Heating Code"] = ""
        else:
            data["Secondary Heating Code"] = secondary_heating_code_match.group(
                1).strip() if secondary_heating_code_match else ""

        data["Water Heating Code"] = water_heating_code_match.group(1).strip()

        dimensions = extract_building_parts_summary(text)
        data.update(dimensions)

        # Need to get the hot water
        section_match = re.search(r"15\.0.*?\n(.*?)15\.1", text, re.DOTALL)
        section_text = section_match.group(1)

        # Extract Water Heating Code
        code_match = re.search(r"Water Heating Code\s+(\S+)", section_text)
        fuel_match = re.search(r"Water Heating Fuel Type\s+(.+)", section_text)
        if fuel_match is None:
            fuel_type = None
        else:
            fuel_type = fuel_match.group(1).strip()

        code = code_match.group(1)
        data["Hot Water System"] = code
        data["Hot Water Fuel"] = fuel_type

        # data["Number of Light Fittings"] = int(re.search(r"Total number of light fittings\s*(\d+)", text).group(1))
        # data["Number of LEL Fittings"] = int(re.search(r"Total number of L.E.L. fittings\s*(\d+)", text).group(1))
        # data["Number of fittings needing LEL"] = data["Number of Light Fittings"] - data["Number of LEL Fittings"]

        extracted_roof_data = extract_roof_details_summary(text)
        main_roof_data = [roof for roof in extracted_roof_data if "Main" in roof["Building Part"]][0]
        data["Main Roof Type"] = main_roof_data["Roof Type"]
        data["Main Roof Insulation"] = main_roof_data["Roof Insulation"]
        data["Main Roof Insulation Thickness"] = main_roof_data["Roof Insulation Thickness"]

        walls_data = extract_wall_details_summary(text)
        # Get the main building wall data
        main_building_walls = [wall for wall in walls_data if "Main" in wall["Building Part"]][0]
        data["Main Wall Type"] = main_building_walls["Wall Type"]
        data["Main Wall Insulation"] = main_building_walls["Wall Insulation"]
        # data["Main Wall Dry-lining"] = main_building_walls["Wall Dry-lining"]
        # data["Main Wall Thickness"] = main_building_walls["Wall Thickness (mm)"]
        # data["Main Building Alternative Wall Type"] = main_building_walls["Alternative Wall Type"]
        # data["Main Building Alternative Wall Insulation"] = main_building_walls["Alternative Wall Insulation"]
        # data["Main Building Alternative Wall Dry-lining"] = main_building_walls["Alternative Wall Dry-lining"]
        # data["Main Building Alternative Wall Thickness"] = main_building_walls["Alternative Wall Thickness (mm)"]

    return data


folder_location = "/Users/khalimconn-kowlessar/Documents/hestia/Customers/Livewest/July 2025 Heating Upgrades"

df = pd.read_csv("/Users/khalimconn-kowlessar/Documents/hestia/July 2025 Surveys/export_summary_table.csv")

property_data = []
for _, x in tqdm(df.iterrows(), total=len(df)):

    if not pd.isnull(x["error"]):
        continue

    filepath = x["filepath"]
    if filepath in ["No summary file found"]:
        continue
    summary_data = extract_summary_report(pdf_path=filepath)
    property_data.append(
        {
            **x.to_dict(),
            **summary_data
        }
    )

property_data = pd.DataFrame(property_data)
# Store as excel
property_data.to_excel(
    "/Users/khalimconn-kowlessar/Documents/hestia/Customers/Livewest/July 2025 Heating "
    "Upgrades/property_table_24th_july.xlsx"
)

sandwell_data = property_data[property_data["company"] == "sandwell.gov.uk"]
sandwell_data.to_csv(
    "/Users/khalimconn-kowlessar/Documents/hestia/Customers/Livewest/July 2025 Heating "
    "Upgrades/Sandwell EPR data (WIP).xlsx"
)