app/component_selection.py

"""
HVAC Component Selection Module
Provides UI for selecting building components in the HVAC Load Calculator.
All dependencies are included within this file for standalone operation.
Updated 2025-04-28: Added perimeter field to Floor class for F-factor calculations.
Updated 2025-04-29: Fixed Floors table headings, added insulated field for dynamic F-factor.
"""

import streamlit as st
import pandas as pd
import numpy as np
import json
import uuid
from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, List, Any, Optional
import io

# --- Enums ---
class Orientation(Enum):
    NORTH = "North"
    NORTHEAST = "Northeast"
    EAST = "East"
    SOUTHEAST = "Southeast"
    SOUTH = "South"
    SOUTHWEST = "Southwest"
    WEST = "West"
    NORTHWEST = "Northwest"
    HORIZONTAL = "Horizontal"
    NOT_APPLICABLE = "N/A"

class ComponentType(Enum):
    WALL = "Wall"
    ROOF = "Roof"
    FLOOR = "Floor"
    WINDOW = "Window"
    DOOR = "Door"

# --- Data Models ---
@dataclass
class MaterialLayer:
    name: str
    thickness: float  # in mm
    conductivity: float  # W/(m·K)

@dataclass
class BuildingComponent:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    name: str = "Unnamed Component"
    component_type: ComponentType = ComponentType.WALL
    u_value: float = 0.0  # W/(m²·K)
    area: float = 0.0  # m²
    orientation: Orientation = Orientation.NOT_APPLICABLE

    def __post_init__(self):
        if self.area <= 0:
            raise ValueError("Area must be greater than zero")
        if self.u_value <= 0:
            raise ValueError("U-value must be greater than zero")

    def to_dict(self) -> dict:
        return {
            "id": self.id, "name": self.name, "component_type": self.component_type.value,
            "u_value": self.u_value, "area": self.area, "orientation": self.orientation.value
        }

@dataclass
class Wall(BuildingComponent):
    wall_type: str = "Brick"
    wall_group: str = "A"  # ASHRAE group
    absorptivity: float = 0.6
    shading_coefficient: float = 1.0
    infiltration_rate_cfm: float = 0.0

    def __post_init__(self):
        super().__post_init__()
        self.component_type = ComponentType.WALL
        if not 0 <= self.absorptivity <= 1:
            raise ValueError("Absorptivity must be between 0 and 1")
        if not 0 <= self.shading_coefficient <= 1:
            raise ValueError("Shading coefficient must be between 0 and 1")
        if self.infiltration_rate_cfm < 0:
            raise ValueError("Infiltration rate cannot be negative")
        VALID_WALL_GROUPS = {"A", "B", "C", "D", "E", "F", "G", "H"}
        if self.wall_group not in VALID_WALL_GROUPS:
            st.warning(f"Invalid wall_group '{self.wall_group}' for wall '{self.name}'. Defaulting to 'A'.")
            self.wall_group = "A"

    def to_dict(self) -> dict:
        base_dict = super().to_dict()
        base_dict.update({
            "wall_type": self.wall_type, "wall_group": self.wall_group, "absorptivity": self.absorptivity,
            "shading_coefficient": self.shading_coefficient, "infiltration_rate_cfm": self.infiltration_rate_cfm
        })
        return base_dict

@dataclass
class Roof(BuildingComponent):
    roof_type: str = "Concrete"
    roof_group: str = "A"  # ASHRAE group
    slope: str = "Flat"
    absorptivity: float = 0.6

    def __post_init__(self):
        super().__post_init__()
        self.component_type = ComponentType.ROOF
        if not self.orientation == Orientation.HORIZONTAL:
            self.orientation = Orientation.HORIZONTAL
        if not 0 <= self.absorptivity <= 1:
            raise ValueError("Absorptivity must be between 0 and 1")
        VALID_ROOF_GROUPS = {"A", "B", "C", "D", "E", "F", "G"}
        if self.roof_group not in VALID_ROOF_GROUPS:
            st.warning(f"Invalid roof_group '{self.roof_group}' for roof '{self.name}'. Defaulting to 'A'.")
            self.roof_group = "A"

    def to_dict(self) -> dict:
        base_dict = super().to_dict()
        base_dict.update({
            "roof_type": self.roof_type, "roof_group": self.roof_group, "slope": self.slope, "absorptivity": self.absorptivity
        })
        return base_dict

@dataclass
class Floor(BuildingComponent):
    floor_type: str = "Concrete"
    ground_contact: bool = True
    ground_temperature_c: float = 25.0
    perimeter: float = 0.0
    insulated: bool = False  # NEW: For dynamic F-factor

    def __post_init__(self):
        super().__post_init__()
        self.component_type = ComponentType.FLOOR
        self.orientation = Orientation.NOT_APPLICABLE
        if self.perimeter < 0:
            raise ValueError("Perimeter cannot be negative")
        if self.ground_contact and not (-10 <= self.ground_temperature_c <= 40):
            raise ValueError("Ground temperature must be between -10°C and 40°C for ground-contact floors")

    def to_dict(self) -> dict:
        base_dict = super().to_dict()
        base_dict.update({
            "floor_type": self.floor_type, "ground_contact": self.ground_contact,
            "ground_temperature_c": self.ground_temperature_c, "perimeter": self.perimeter,
            "insulated": self.insulated
        })
        return base_dict

@dataclass
class Window(BuildingComponent):
    shgc: float = 0.7
    shading_device: str = "None"
    shading_coefficient: float = 1.0
    frame_type: str = "Aluminum"
    frame_percentage: float = 20.0
    infiltration_rate_cfm: float = 0.0

    def __post_init__(self):
        super().__post_init__()
        self.component_type = ComponentType.WINDOW
        if not 0 <= self.shgc <= 1:
            raise ValueError("SHGC must be between 0 and 1")
        if not 0 <= self.shading_coefficient <= 1:
            raise ValueError("Shading coefficient must be between 0 and 1")
        if not 0 <= self.frame_percentage <= 30:
            raise ValueError("Frame percentage must be between 0 and 30")
        if self.infiltration_rate_cfm < 0:
            raise ValueError("Infiltration rate cannot be negative")

    def to_dict(self) -> dict:
        base_dict = super().to_dict()
        base_dict.update({
            "shgc": self.shgc, "shading_device": self.shading_device, "shading_coefficient": self.shading_coefficient,
            "frame_type": self.frame_type, "frame_percentage": self.frame_percentage, "infiltration_rate_cfm": self.infiltration_rate_cfm
        })
        return base_dict

@dataclass
class Door(BuildingComponent):
    door_type: str = "Solid Wood"
    infiltration_rate_cfm: float = 0.0

    def __post_init__(self):
        super().__post_init__()
        self.component_type = ComponentType.DOOR
        if self.infiltration_rate_cfm < 0:
            raise ValueError("Infiltration rate cannot be negative")

    def to_dict(self) -> dict:
        base_dict = super().to_dict()
        base_dict.update({"door_type": self.door_type, "infiltration_rate_cfm": self.infiltration_rate_cfm})
        return base_dict

# --- Reference Data ---
class ReferenceData:
    def __init__(self):
        self.data = {
            "materials": {
                "Concrete": {"conductivity": 1.4},
                "Insulation": {"conductivity": 0.04},
                "Brick": {"conductivity": 0.8},
                "Glass": {"conductivity": 1.0},
                "Wood": {"conductivity": 0.15}
            },
            "wall_types": {
                "Brick Wall": {"u_value": 2.0, "absorptivity": 0.6, "wall_group": "A"},
                "Insulated Brick": {"u_value": 0.5, "absorptivity": 0.6, "wall_group": "B"},
                "Concrete Block": {"u_value": 1.8, "absorptivity": 0.6, "wall_group": "C"},
                "Insulated Concrete": {"u_value": 0.4, "absorptivity": 0.6, "wall_group": "D"},
                "Timber Frame": {"u_value": 0.3, "absorptivity": 0.6, "wall_group": "E"},
                "Cavity Brick": {"u_value": 0.6, "absorptivity": 0.6, "wall_group": "F"},
                "Lightweight Panel": {"u_value": 1.0, "absorptivity": 0.6, "wall_group": "G"},
                "Reinforced Concrete": {"u_value": 1.5, "absorptivity": 0.6, "wall_group": "H"},
                "SIP": {"u_value": 0.25, "absorptivity": 0.6, "wall_group": "A"},
                "Custom": {"u_value": 0.5, "absorptivity": 0.6, "wall_group": "A"}
            },
            "roof_types": {
                "Concrete Roof": {"u_value": 0.3, "absorptivity": 0.6, "group": "A"},
                "Metal Roof": {"u_value": 1.0, "absorptivity": 0.75, "group": "B"}
            },
            "roof_ventilation_methods": {
                "No Ventilation": 0.0,
                "Natural Low": 0.1,
                "Natural High": 0.5,
                "Mechanical": 1.0
            },
            "floor_types": {
                "Concrete Slab": {"u_value": 0.4, "ground_contact": True},
                "Wood Floor": {"u_value": 0.8, "ground_contact": False}
            },
            "window_types": {
                "Double Glazed": {"u_value": 2.8, "shgc": 0.7, "frame_type": "Aluminum"},
                "Single Glazed": {"u_value": 5.0, "shgc": 0.9, "frame_type": "Wood"}
            },
            "shading_devices": {
                "None": 1.0,
                "Venetian Blinds": 0.6,
                "Overhang": 0.4,
                "Roller Shades": 0.5,
                "Drapes": 0.7
            },
            "door_types": {
                "Solid Wood": {"u_value": 2.0},
                "Glass Door": {"u_value": 3.5}
            }
        }

    def get_materials(self) -> List[Dict[str, Any]]:
        return [{"name": k, "conductivity": v["conductivity"]} for k, v in self.data["materials"].items()]

reference_data = ReferenceData()

# --- Component Library ---
class ComponentLibrary:
    def __init__(self):
        self.components = {}

    def add_component(self, component: BuildingComponent):
        self.components[component.id] = component

    def remove_component(self, component_id: str):
        if not component_id.startswith("preset_") and component_id in self.components:
            del self.components[component_id]

component_library = ComponentLibrary()

# --- U-Value Calculator ---
class UValueCalculator:
    def __init__(self):
        self.materials = reference_data.get_materials()

    def calculate_u_value(self, layers: List[Dict[str, float]], outside_resistance: float, inside_resistance: float) -> float:
        r_layers = sum(layer["thickness"] / 1000 / layer["conductivity"] for layer in layers)
        r_total = outside_resistance + r_layers + inside_resistance
        return 1 / r_total if r_total > 0 else 0

u_value_calculator = UValueCalculator()

# --- Component Selection Interface ---
class ComponentSelectionInterface:
    def __init__(self):
        self.component_library = component_library
        self.u_value_calculator = u_value_calculator
        self.reference_data = reference_data

    def display_component_selection(self, session_state: Any) -> None:
        st.title("Building Components")
        
        if 'components' not in session_state:
            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
        if 'roof_air_volume_m3' not in session_state:
            session_state.roof_air_volume_m3 = 0.0
        if 'roof_ventilation_ach' not in session_state:
            session_state.roof_ventilation_ach = 0.0

        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "U-Value Calculator"])
        
        with tabs[0]:
            self._display_component_tab(session_state, ComponentType.WALL)
        with tabs[1]:
            self._display_component_tab(session_state, ComponentType.ROOF)
        with tabs[2]:
            self._display_component_tab(session_state, ComponentType.FLOOR)
        with tabs[3]:
            self._display_component_tab(session_state, ComponentType.WINDOW)
        with tabs[4]:
            self._display_component_tab(session_state, ComponentType.DOOR)
        with tabs[5]:
            self._display_u_value_calculator_tab(session_state)
        
        if st.button("Save Components"):
            self._save_components(session_state)

    def _display_component_tab(self, session_state: Any, component_type: ComponentType) -> None:
        type_name = component_type.value.lower()
        st.subheader(f"{type_name.capitalize()} Components")
        
        with st.expander(f"Add {type_name.capitalize()}", expanded=True):
            if component_type == ComponentType.WALL:
                self._display_add_wall_form(session_state)
            elif component_type == ComponentType.ROOF:
                self._display_add_roof_form(session_state)
            elif component_type == ComponentType.FLOOR:
                self._display_add_floor_form(session_state)
            elif component_type == ComponentType.WINDOW:
                self._display_add_window_form(session_state)
            elif component_type == ComponentType.DOOR:
                self._display_add_door_form(session_state)
        
        components = session_state.components.get(type_name + 's', [])
        if components or component_type == ComponentType.ROOF:
            st.subheader(f"Existing {type_name.capitalize()} Components")
            self._display_components_table(session_state, component_type, components)

    def _display_add_wall_form(self, session_state: Any) -> None:
        st.write("Add walls manually or upload a file.")
        method = st.radio("Add Wall Method", ["Manual Entry", "File Upload"])
        if "add_wall_submitted" not in session_state:
            session_state.add_wall_submitted = False

        if method == "Manual Entry":
            with st.form("add_wall_form", clear_on_submit=True):
                col1, col2 = st.columns(2)
                with col1:
                    name = st.text_input("Name", "New Wall")
                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
                    orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
                with col2:
                    wall_options = self.reference_data.data["wall_types"]
                    selected_wall = st.selectbox("Wall Type", options=list(wall_options.keys()))
                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(wall_options[selected_wall]["u_value"]), step=0.01)
                    wall_group = st.selectbox("Wall Group (ASHRAE)", ["A", "B", "C", "D", "E", "F", "G", "H"], index=0)
                    absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"], index=2)
                    shading_coefficient = st.number_input("Shading Coefficient", min_value=0.0, max_value=1.0, value=1.0, step=0.05)
                    infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)

                submitted = st.form_submit_button("Add Wall")
                if submitted and not session_state.add_wall_submitted:
                    try:
                        absorptivity_value = float(absorptivity.split("(")[1].strip(")"))
                        new_wall = Wall(
                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
                            wall_type=selected_wall, wall_group=wall_group, absorptivity=absorptivity_value,
                            shading_coefficient=shading_coefficient, infiltration_rate_cfm=infiltration_rate
                        )
                        self.component_library.add_component(new_wall)
                        session_state.components['walls'].append(new_wall)
                        st.success(f"Added {new_wall.name}")
                        session_state.add_wall_submitted = True
                        st.rerun()
                    except ValueError as e:
                        st.error(f"Error: {str(e)}")

            if session_state.add_wall_submitted:
                session_state.add_wall_submitted = False

        elif method == "File Upload":
            uploaded_file = st.file_uploader("Upload Walls File", type=["csv", "xlsx"], key="wall_upload")
            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Absorptivity", "Shading Coefficient", "Infiltration Rate (CFM)"]
            template_data = pd.DataFrame(columns=required_cols)
            template_data.loc[0] = ["Example Wall", 10.0, 2.0, "North", "Brick Wall", "A", 0.6, 1.0, 0.0]
            st.download_button(label="Download Wall Template", data=template_data.to_csv(index=False), file_name="wall_template.csv", mime="text/csv")
            if uploaded_file:
                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                if all(col in df.columns for col in required_cols):
                    valid_wall_groups = {"A", "B", "C", "D", "E", "F", "G", "H"}
                    for _, row in df.iterrows():
                        try:
                            wall_group = str(row["Wall Group"])
                            if wall_group not in valid_wall_groups:
                                st.warning(f"Invalid Wall Group '{wall_group}' in row '{row['Name']}'. Defaulting to 'A'.")
                                wall_group = "A"
                            new_wall = Wall(
                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
                                orientation=Orientation(row["Orientation"]), wall_type=str(row["Wall Type"]),
                                wall_group=wall_group, absorptivity=float(row["Absorptivity"]),
                                shading_coefficient=float(row["Shading Coefficient"]), infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
                            )
                            self.component_library.add_component(new_wall)
                            session_state.components['walls'].append(new_wall)
                        except ValueError as e:
                            st.error(f"Error in row {row['Name']}: {str(e)}")
                    st.success("Walls uploaded successfully!")
                    st.rerun()
                else:
                    st.error(f"File must contain: {', '.join(required_cols)}")

    def _display_add_roof_form(self, session_state: Any) -> None:
        st.write("Add roofs manually or upload a file.")
        method = st.radio("Add Roof Method", ["Manual Entry", "File Upload"])
        if "add_roof_submitted" not in session_state:
            session_state.add_roof_submitted = False

        st.subheader("Roof System Ventilation")
        air_volume = st.number_input("Air Volume (m³)", min_value=0.0, value=session_state.roof_air_volume_m3, step=1.0, help="Total volume between roof and ceiling")
        vent_options = {f"{k} (ACH={v})": v for k, v in self.reference_data.data["roof_ventilation_methods"].items()}
        vent_options["Custom"] = None
        ventilation_method = st.selectbox("Ventilation Method", options=list(vent_options.keys()), index=0, help="Applies to entire roof system")
        ventilation_ach = st.number_input("Custom Ventilation Rate (ACH)", min_value=0.0, max_value=10.0, value=0.0, step=0.1) if ventilation_method == "Custom" else vent_options[ventilation_method]
        session_state.roof_air_volume_m3 = air_volume
        session_state.roof_ventilation_ach = ventilation_ach

        if method == "Manual Entry":
            with st.form("add_roof_form", clear_on_submit=True):
                col1, col2 = st.columns(2)
                with col1:
                    name = st.text_input("Name", "New Roof")
                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
                    orientation = Orientation.HORIZONTAL.value
                with col2:
                    roof_options = self.reference_data.data["roof_types"]
                    selected_roof = st.selectbox("Roof Type", options=list(roof_options.keys()))
                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(roof_options[selected_roof]["u_value"]), step=0.01)
                    roof_group = st.selectbox("Roof Group (ASHRAE)", ["A", "B", "C", "D", "E", "F", "G"], index=0)
                    slope = st.selectbox("Slope", ["Flat", "Pitched"], index=0)
                    absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"], index=2)

                submitted = st.form_submit_button("Add Roof")
                if submitted and not session_state.add_roof_submitted:
                    try:
                        absorptivity_value = float(absorptivity.split("(")[1].strip(")"))
                        new_roof = Roof(
                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
                            roof_type=selected_roof, roof_group=roof_group, slope=slope, absorptivity=absorptivity_value
                        )
                        self.component_library.add_component(new_roof)
                        session_state.components['roofs'].append(new_roof)
                        st.success(f"Added {new_roof.name}")
                        session_state.add_roof_submitted = True
                        st.rerun()
                    except ValueError as e:
                        st.error(f"Error: {str(e)}")

            if session_state.add_roof_submitted:
                session_state.add_roof_submitted = False

        elif method == "File Upload":
            uploaded_file = st.file_uploader("Upload Roofs File", type=["csv", "xlsx"], key="roof_upload")
            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Roof Type", "Roof Group", "Slope", "Absorptivity"]
            template_data = pd.DataFrame(columns=required_cols)
            template_data.loc[0] = ["Example Roof", 10.0, 0.3, "Horizontal", "Concrete Roof", "A", "Flat", 0.6]
            st.download_button(label="Download Roof Template", data=template_data.to_csv(index=False), file_name="roof_template.csv", mime="text/csv")
            if uploaded_file:
                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                if all(col in df.columns for col in required_cols):
                    valid_roof_groups = {"A", "B", "C", "D", "E", "F", "G"}
                    for _, row in df.iterrows():
                        try:
                            roof_group = str(row["Roof Group"])
                            if roof_group not in valid_roof_groups:
                                st.warning(f"Invalid Roof Group '{roof_group}' in row '{row['Name']}'. Defaulting to 'A'.")
                                roof_group = "A"
                            new_roof = Roof(
                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
                                orientation=Orientation(row["Orientation"]), roof_type=str(row["Roof Type"]),
                                roof_group=roof_group, slope=str(row["Slope"]), absorptivity=float(row["Absorptivity"])
                            )
                            self.component_library.add_component(new_roof)
                            session_state.components['roofs'].append(new_roof)
                        except ValueError as e:
                            st.error(f"Error in row {row['Name']}: {str(e)}")
                    st.success("Roofs uploaded successfully!")
                    st.rerun()
                else:
                    st.error(f"File must contain: {', '.join(required_cols)}")

    def _display_add_floor_form(self, session_state: Any) -> None:
        st.write("Add floors manually or upload a file.")
        method = st.radio("Add Floor Method", ["Manual Entry", "File Upload"])
        if "add_floor_submitted" not in session_state:
            session_state.add_floor_submitted = False

        if method == "Manual Entry":
            with st.form("add_floor_form", clear_on_submit=True):
                col1, col2 = st.columns(2)
                with col1:
                    name = st.text_input("Name", "New Floor")
                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
                    perimeter = st.number_input("Perimeter (m)", min_value=0.0, value=0.0, step=0.1)
                with col2:
                    floor_options = self.reference_data.data["floor_types"]
                    selected_floor = st.selectbox("Floor Type", options=list(floor_options.keys()))
                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(floor_options[selected_floor]["u_value"]), step=0.01)
                    ground_contact = st.selectbox("Ground Contact", ["Yes", "No"], index=0 if floor_options[selected_floor]["ground_contact"] else 1)
                    ground_temp = st.number_input("Ground Temperature (°C)", min_value=-10.0, max_value=40.0, value=25.0, step=0.1) if ground_contact == "Yes" else 25.0
                    insulated = st.checkbox("Insulated Floor (e.g., R-10)", value=False)  # NEW: Insulation option

                submitted = st.form_submit_button("Add Floor")
                if submitted and not session_state.add_floor_submitted:
                    try:
                        new_floor = Floor(
                            name=name, u_value=u_value, area=area, floor_type=selected_floor,
                            ground_contact=(ground_contact == "Yes"), ground_temperature_c=ground_temp,
                            perimeter=perimeter, insulated=insulated
                        )
                        self.component_library.add_component(new_floor)
                        session_state.components['floors'].append(new_floor)
                        st.success(f"Added {new_floor.name}")
                        session_state.add_floor_submitted = True
                        st.rerun()
                    except ValueError as e:
                        st.error(f"Error: {str(e)}")

            if session_state.add_floor_submitted:
                session_state.add_floor_submitted = False

        elif method == "File Upload":
            uploaded_file = st.file_uploader("Upload Floors File", type=["csv", "xlsx"], key="floor_upload")
            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Floor Type", "Ground Contact", "Ground Temperature (°C)", "Perimeter (m)", "Insulated"]  # NEW: Added Insulated
            template_data = pd.DataFrame(columns=required_cols)
            template_data.loc[0] = ["Example Floor", 10.0, 0.4, "Concrete Slab", "Yes", 25.0, 12.0, "No"]
            st.download_button(label="Download Floor Template", data=template_data.to_csv(index=False), file_name="floor_template.csv", mime="text/csv")
            if uploaded_file:
                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                if all(col in df.columns for col in required_cols):
                    for _, row in df.iterrows():
                        try:
                            insulated = str(row["Insulated"]).lower() in ["yes", "true", "1"]
                            new_floor = Floor(
                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
                                floor_type=str(row["Floor Type"]), ground_contact=(str(row["Ground Contact"]).lower() == "yes"),
                                ground_temperature_c=float(row["Ground Temperature (°C)"]), perimeter=float(row["Perimeter (m)"]),
                                insulated=insulated
                            )
                            self.component_library.add_component(new_floor)
                            session_state.components['floors'].append(new_floor)
                        except ValueError as e:
                            st.error(f"Error in row {row['Name']}: {str(e)}")
                    st.success("Floors uploaded successfully!")
                    st.rerun()
                else:
                    st.error(f"File must contain: {', '.join(required_cols)}")

    def _display_add_window_form(self, session_state: Any) -> None:
        st.write("Add windows manually or upload a file.")
        method = st.radio("Add Window Method", ["Manual Entry", "File Upload"])
        if "add_window_submitted" not in session_state:
            session_state.add_window_submitted = False

        if method == "Manual Entry":
            with st.form("add_window_form", clear_on_submit=True):
                col1, col2 = st.columns(2)
                with col1:
                    name = st.text_input("Name", "New Window")
                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
                    orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
                with col2:
                    window_options = self.reference_data.data["window_types"]
                    selected_window = st.selectbox("Window Type", options=list(window_options.keys()))
                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(window_options[selected_window]["u_value"]), step=0.01)
                    shading_options = {f"{k} (SC={v})": k for k, v in self.reference_data.data["shading_devices"].items()}
                    shading_options["Custom"] = "Custom"
                    shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=0)
                    shading_coefficient = st.number_input("Custom Shading Coefficient", min_value=0.0, max_value=1.0, value=1.0, step=0.05) if shading_device == "Custom" else self.reference_data.data["shading_devices"][shading_options[shading_device]]
                    frame_type = st.selectbox("Frame Type", ["Aluminum", "Wood", "Vinyl"], index=0)
                    frame_percentage = st.slider("Frame Percentage (%)", min_value=0.0, max_value=30.0, value=20.0)
                    infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)

                submitted = st.form_submit_button("Add Window")
                if submitted and not session_state.add_window_submitted:
                    try:
                        new_window = Window(
                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
                            shgc=shgc, shading_device=shading_options[shading_device], shading_coefficient=shading_coefficient,
                            frame_type=frame_type, frame_percentage=frame_percentage, infiltration_rate_cfm=infiltration_rate
                        )
                        self.component_library.add_component(new_window)
                        session_state.components['windows'].append(new_window)
                        st.success(f"Added {new_window.name}")
                        session_state.add_window_submitted = True
                        st.rerun()
                    except ValueError as e:
                        st.error(f"Error: {str(e)}")

            if session_state.add_window_submitted:
                session_state.add_window_submitted = False

        elif method == "File Upload":
            uploaded_file = st.file_uploader("Upload Windows File", type=["csv", "xlsx"], key="window_upload")
            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "SHGC", "Shading Device", "Shading Coefficient", "Frame Type", "Frame Percentage", "Infiltration Rate (CFM)"]
            st.download_button(label="Download Window Template", data=pd.DataFrame(columns=required_cols).to_csv(index=False), file_name="window_template.csv", mime="text/csv")
            if uploaded_file:
                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                if all(col in df.columns for col in required_cols):
                    for _, row in df.iterrows():
                        try:
                            new_window = Window(
                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
                                orientation=Orientation(row["Orientation"]), shgc=float(row["SHGC"]),
                                shading_device=str(row["Shading Device"]), shading_coefficient=float(row["Shading Coefficient"]),
                                frame_type=str(row["Frame Type"]), frame_percentage=float(row["Frame Percentage"]),
                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
                            )
                            self.component_library.add_component(new_window)
                            session_state.components['windows'].append(new_window)
                        except ValueError as e:
                            st.error(f"Error in row {row['Name']}: {str(e)}")
                    st.success("Windows uploaded successfully!")
                    st.rerun()
                else:
                    st.error(f"File must contain: {', '.join(required_cols)}")

    def _display_add_door_form(self, session_state: Any) -> None:
        st.write("Add doors manually or upload a file.")
        method = st.radio("Add Door Method", ["Manual Entry", "File Upload"])
        if "add_door_submitted" not in session_state:
            session_state.add_door_submitted = False

        if method == "Manual Entry":
            with st.form("add_door_form", clear_on_submit=True):
                col1, col2 = st.columns(2)
                with col1:
                    name = st.text_input("Name", "New Door")
                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
                    orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
                with col2:
                    door_options = self.reference_data.data["door_types"]
                    selected_door = st.selectbox("Door Type", options=list(door_options.keys()))
                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(door_options[selected_door]["u_value"]), step=0.01)
                    infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)

                submitted = st.form_submit_button("Add Door")
                if submitted and not session_state.add_door_submitted:
                    try:
                        new_door = Door(
                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
                            door_type=selected_door, infiltration_rate_cfm=infiltration_rate
                        )
                        self.component_library.add_component(new_door)
                        session_state.components['doors'].append(new_door)
                        st.success(f"Added {new_door.name}")
                        session_state.add_door_submitted = True
                        st.rerun()
                    except ValueError as e:
                        st.error(f"Error: {str(e)}")

            if session_state.add_door_submitted:
                session_state.add_door_submitted = False

        elif method == "File Upload":
            uploaded_file = st.file_uploader("Upload Doors File", type=["csv", "xlsx"], key="door_upload")
            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Door Type", "Infiltration Rate (CFM)"]
            st.download_button(label="Download Door Template", data=pd.DataFrame(columns=required_cols).to_csv(index=False), file_name="door_template.csv", mime="text/csv")
            if uploaded_file:
                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                if all(col in df.columns for col in required_cols):
                    for _, row in df.iterrows():
                        try:
                            new_door = Door(
                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
                                orientation=Orientation(row["Orientation"]), door_type=str(row["Door Type"]),
                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
                            )
                            self.component_library.add_component(new_door)
                            session_state.components['doors'].append(new_door)
                        except ValueError as e:
                            st.error(f"Error in row {row['Name']}: {str(e)}")
                    st.success("Doors uploaded successfully!")
                    st.rerun()
                else:
                    st.error(f"File must contain: {', '.join(required_cols)}")

    def _display_components_table(self, session_state: Any, component_type: ComponentType, components: List[BuildingComponent]) -> None:
        type_name = component_type.value.lower()
        if component_type == ComponentType.ROOF:
            st.write(f"Roof Air Volume: {session_state.roof_air_volume_m3} m³, Ventilation Rate: {session_state.roof_ventilation_ach} ACH")

        if components:
            headers = {
                ComponentType.WALL: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Absorptivity", "Shading Coefficient", "Infiltration Rate (CFM)", "Delete"],
                ComponentType.ROOF: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Roof Type", "Roof Group", "Slope", "Absorptivity", "Delete"],
                ComponentType.FLOOR: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Floor Type", "Ground Contact", "Ground Temperature (°C)", "Perimeter (m)", "Insulated", "Delete"],  # NEW: Added Insulated
                ComponentType.WINDOW: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "SHGC", "Shading Device", "Shading Coefficient", "Frame Type", "Frame Percentage", "Infiltration Rate (CFM)", "Delete"],
                ComponentType.DOOR: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Door Type", "Infiltration Rate (CFM)", "Delete"]
            }[component_type]
            cols = st.columns([1] * len(headers))
            for i, header in enumerate(headers):
                cols[i].write(f"**{header}**")

            for comp in components:
                cols = st.columns([1] * len(headers))
                cols[0].write(comp.name)
                cols[1].write(comp.area)
                cols[2].write(comp.u_value)
                cols[3].write(comp.orientation.value)
                if component_type == ComponentType.WALL:
                    cols[4].write(comp.wall_type)
                    cols[5].write(comp.wall_group)
                    cols[6].write(comp.absorptivity)
                    cols[7].write(comp.shading_coefficient)
                    cols[8].write(comp.infiltration_rate_cfm)
                elif component_type == ComponentType.ROOF:
                    cols[4].write(comp.roof_type)
                    cols[5].write(comp.roof_group)
                    cols[6].write(comp.slope)
                    cols[7].write(comp.absorptivity)
                elif component_type == ComponentType.FLOOR:
                    cols[4].write(comp.floor_type)
                    cols[5].write("Yes" if comp.ground_contact else "No")
                    cols[6].write(comp.ground_temperature_c if comp.ground_contact else "N/A")
                    cols[7].write(comp.perimeter)
                    cols[8].write("Yes" if comp.insulated else "No")  # NEW: Display insulated
                elif component_type == ComponentType.WINDOW:
                    cols[4].write(comp.shgc)
                    cols[5].write(comp.shading_device)
                    cols[6].write(comp.shading_coefficient)
                    cols[7].write(comp.frame_type)
                    cols[8].write(comp.frame_percentage)
                    cols[9].write(comp.infiltration_rate_cfm)
                elif component_type == ComponentType.DOOR:
                    cols[4].write(comp.door_type)
                    cols[5].write(comp.infiltration_rate_cfm)
                if cols[-1].button("Delete", key=f"delete_{comp.id}"):
                    self.component_library.remove_component(comp.id)
                    session_state.components[type_name + 's'] = [c for c in components if c.id != comp.id]
                    st.success(f"Deleted {comp.name}")
                    st.rerun()

    def _display_u_value_calculator_tab(self, session_state: Any) -> None:
        st.subheader("U-Value Calculator (Standalone)")
        if "u_value_layers" not in session_state:
            session_state.u_value_layers = []

        if session_state.u_value_layers:
            st.write("Material Layers (Outside to Inside):")
            layer_data = [{"Layer": i+1, "Material": l["name"], "Thickness (mm)": l["thickness"], 
                           "Conductivity (W/m·K)": l["conductivity"], "R-Value (m²·K/W)": l["thickness"] / 1000 / l["conductivity"]} 
                          for i, l in enumerate(session_state.u_value_layers)]
            st.dataframe(pd.DataFrame(layer_data))
            outside_resistance = st.selectbox("Outside Resistance (m²·K/W)", ["Summer (0.04)", "Winter (0.03)", "Custom"], index=0)
            outside_r = float(st.number_input("Custom Outside Resistance", min_value=0.0, value=0.04, step=0.01)) if outside_resistance == "Custom" else (0.04 if outside_resistance.startswith("Summer") else 0.03)
            inside_r = st.number_input("Inside Resistance (m²·K/W)", min_value=0.0, value=0.13, step=0.01)
            u_value = self.u_value_calculator.calculate_u_value(session_state.u_value_layers, outside_r, inside_r)
            st.metric("U-Value", f"{u_value:.3f} W/m²·K")

        with st.form("u_value_form"):
            col1, col2 = st.columns(2)
            with col1:
                material_options = {m["name"]: m["conductivity"] for m in self.u_value_calculator.materials}
                material_name = st.selectbox("Material", options=list(material_options.keys()))
                conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=material_options[material_name], step=0.01)
            with col2:
                thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
            submitted = st.form_submit_button("Add Layer")
            if submitted:
                session_state.u_value_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
                st.rerun()

        col1, col2 = st.columns(2)
        with col1:
            if st.button("Remove Last Layer"):
                if session_state.u_value_layers:
                    session_state.u_value_layers.pop()
                    st.rerun()
        with col2:
            if st.button("Reset"):
                session_state.u_value_layers = []
                st.rerun()

    def _save_components(self, session_state: Any) -> None:
        components_dict = {
            "walls": [c.to_dict() for c in session_state.components["walls"]],
            "roofs": [c.to_dict() for c in session_state.components["roofs"]],
            "floors": [c.to_dict() for c in session_state.components["floors"]],
            "windows": [c.to_dict() for c in session_state.components["windows"]],
            "doors": [c.to_dict() for c in session_state.components["doors"]],
            "roof_air_volume_m3": session_state.roof_air_volume_m3,
            "roof_ventilation_ach": session_state.roof_ventilation_ach
        }
        file_path = "components_export.json"
        with open(file_path, 'w') as f:
            json.dump(components_dict, f, indent=4)
        with open(file_path, 'r') as f:
            st.download_button(label="Download Components", data=f, file_name="components.json", mime="application/json")
        st.success("Components saved successfully.")

# --- Main Execution ---
if __name__ == "__main__":
    interface = ComponentSelectionInterface()
    interface.display_component_selection(st.session_state)