Update app/component_selection.py

app/component_selection.py

@@ -1,45 +1,98 @@
 """
-Component selection interface module for HVAC Load Calculator.
-This module implements the Streamlit interface for selecting building components.
+HVAC Component Selection Module
+Provides UI for selecting building components in the HVAC Load Calculator.
 """
 
 import streamlit as st
 import pandas as pd
 import numpy as np
 import json
-from typing import Dict, List, Any
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List, Any, Optional
 
-# Import application modules
-from utils.component_library import component_library, ComponentLibrary
-from utils.u_value_calculator import u_value_calculator, UValueCalculator
-from data.building_components import (
-    Wall, Roof, Floor, Window, Door, Orientation, ComponentType, BuildingComponent, MaterialLayer
-)
+# Imports from your project structure
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
 from data.reference_data import reference_data
+from utils.component_library import ComponentLibrary
+from utils.u_value_calculator import UValueCalculator
 
+# --- Shading System (New Addition) ---
+class ShadingType(Enum):
+    NONE = "None"
+    INTERNAL = "Internal"
+    EXTERNAL = "External"
+    BETWEEN_GLASS = "Between-glass"
 
+@dataclass
+class ShadingDevice:
+    id: str
+    name: str
+    shading_type: ShadingType
+    shading_coefficient: float
+    coverage_percentage: float = 100.0
+    description: str = ""
+
+    def __post_init__(self):
+        if self.shading_coefficient < 0 or self.shading_coefficient > 1:
+            raise ValueError("Shading coefficient must be between 0 and 1")
+        if self.coverage_percentage < 0 or self.coverage_percentage > 100:
+            raise ValueError("Coverage percentage must be between 0 and 100")
+
+    @property
+    def effective_shading_coefficient(self) -> float:
+        coverage_factor = self.coverage_percentage / 100.0
+        return self.shading_coefficient * coverage_factor + 1.0 * (1 - coverage_factor)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id, "name": self.name, "shading_type": self.shading_type.value,
+            "shading_coefficient": self.shading_coefficient, "coverage_percentage": self.coverage_percentage,
+            "description": self.description, "effective_shading_coefficient": self.effective_shading_coefficient
+        }
+
+class ShadingSystem:
+    def __init__(self):
+        self.shading_devices = {}
+        self.load_preset_devices()
+
+    def load_preset_devices(self) -> None:
+        self.shading_devices["preset_none"] = ShadingDevice(
+            id="preset_none", name="None", shading_type=ShadingType.NONE, shading_coefficient=1.0, description="No shading"
+        )
+        self.shading_devices["preset_venetian_blinds"] = ShadingDevice(
+            id="preset_venetian_blinds", name="Venetian Blinds", shading_type=ShadingType.INTERNAL, shading_coefficient=0.6, description="Standard internal venetian blinds"
+        )
+        self.shading_devices["preset_overhang"] = ShadingDevice(
+            id="preset_overhang", name="Overhang", shading_type=ShadingType.EXTERNAL, shading_coefficient=0.4, description="External overhang"
+        )
+
+    def get_device(self, device_id: str) -> Optional[ShadingDevice]:
+        return self.shading_devices.get(device_id)
+
+    def calculate_effective_shgc(self, base_shgc: float, device_id: str) -> float:
+        device = self.get_device(device_id)
+        if not device:
+            return base_shgc
+        return base_shgc * device.effective_shading_coefficient
+
+shading_system = ShadingSystem()
+
+# --- Component Selection Interface ---
 class ComponentSelectionInterface:
-    """Class for managing the component selection interface."""
-    
     def __init__(self):
-        """Initialize component selection interface."""
-        pass
-    
+        self.component_library = ComponentLibrary()
+        self.u_value_calculator = UValueCalculator()
+        self.shading_system = shading_system
+
     def display_component_selection(self, session_state: Any) -> None:
-        """
-        Display the component selection interface.
-        
-        Args:
-            session_state: Streamlit session state object
-        """
         st.title("Building Components")
         
         if 'components' not in session_state:
-            session_state.components = {
-                'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []
-            }
+            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
         
-        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors"])
+        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "U-Value Calculator"])
         
         with tabs[0]:
             self._display_component_tab(session_state, ComponentType.WALL)
@@ -51,6 +104,8 @@ class ComponentSelectionInterface:
             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)
         
         col1, col2 = st.columns(2)
         with col1:
@@ -60,7 +115,7 @@ class ComponentSelectionInterface:
             uploaded_file = st.file_uploader("Load Components", type=["json"])
             if uploaded_file and st.button("Load Uploaded Components"):
                 self._load_components(session_state, uploaded_file)
-    
+
     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")
@@ -74,119 +129,166 @@ class ComponentSelectionInterface:
             self._display_components_table(session_state, component_type, components)
         else:
             st.info(f"No {type_name} components defined yet.")
-    
+
     def _display_add_component_form(self, session_state: Any, component_type: ComponentType) -> None:
         type_name = component_type.value.lower()
-        preset_components = component_library.get_preset_components_by_type(component_type)
+        preset_components = self.component_library.get_preset_components_by_type(component_type)
         
         with st.form(f"add_{type_name}_form"):
             col1, col2 = st.columns(2)
-            
             with col1:
-                use_preset = st.checkbox("Use Preset", value=True)
-                if use_preset and preset_components:
-                    preset_options = {comp.name: comp.id for comp in preset_components}
-                    selected_preset = st.selectbox(f"Select Preset {type_name.capitalize()}", 
-                                                 options=list(preset_options.keys()))
+                name = st.text_input("Name", f"New {type_name.capitalize()}")
+                area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
+                    orientation = st.selectbox("Orientation", [o.name for o in Orientation], index=0)
                 else:
-                    name = st.text_input("Name", f"Custom {type_name.capitalize()}")
+                    orientation = Orientation.HORIZONTAL.name
             
             with col2:
-                area = st.number_input("Area (m²)", min_value=0.1, value=1.0, step=0.1)
-                if not use_preset:
+                selection_method = st.radio(f"{type_name.capitalize()} Selection Method", ["Select from Presets", "Custom Properties"])
+                if selection_method == "Select from Presets" and preset_components:
+                    preset_options = {comp.name: comp.id for comp in preset_components}
+                    selected_preset = st.selectbox(f"Select Preset {type_name.capitalize()}", options=list(preset_options.keys()))
+                    component = self.component_library.get_component(preset_options[selected_preset])
+                    u_value = st.number_input("U-Value (W/m²·K)", value=component.u_value, disabled=True)
+                    if component_type == ComponentType.WALL:
+                        st.text_input("Wall Type", value=component.wall_type, disabled=True)
+                        st.text_input("Wall Group", value=component.wall_group, disabled=True)
+                    elif component_type == ComponentType.ROOF:
+                        st.text_input("Roof Type", value=component.roof_type, disabled=True)
+                        st.text_input("Roof Group", value=component.roof_group, disabled=True)
+                    elif component_type == ComponentType.FLOOR:
+                        st.text_input("Floor Type", value=component.floor_type, disabled=True)
+                    elif component_type == ComponentType.WINDOW:
+                        st.number_input("SHGC", value=component.shgc, disabled=True)
+                        st.number_input("VT", value=component.vt, disabled=True)
+                        st.text_input("Window Type", value=component.window_type, disabled=True)
+                    elif component_type == ComponentType.DOOR:
+                        st.text_input("Door Type", value=component.door_type, disabled=True)
+                else:
                     u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=0.5, step=0.01)
-            
-            if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
-                orientation = st.selectbox("Orientation", 
-                                         [o.value for o in Orientation],
-                                         index=[o.value for o in Orientation].index("N/A"))
-            else:
-                orientation = Orientation.HORIZONTAL.value
+                    if component_type == ComponentType.WALL:
+                        wall_type = st.text_input("Wall Type", "Custom")
+                        wall_group = st.selectbox("Wall Group", ["A", "B", "C", "D", "E", "F", "G", "H"], index=1)
+                    elif component_type == ComponentType.ROOF:
+                        roof_type = st.text_input("Roof Type", "Custom")
+                        roof_group = st.selectbox("Roof Group", ["A", "B", "C", "D", "E", "F", "G"], index=2)
+                    elif component_type == ComponentType.FLOOR:
+                        floor_type = st.text_input("Floor Type", "Custom")
+                    elif component_type == ComponentType.WINDOW:
+                        shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
+                        vt = st.number_input("VT", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
+                        window_type = st.text_input("Window Type", "Custom")
+                        glazing_layers = st.selectbox("Glazing Layers", [1, 2, 3], index=1)
+                        gas_fill = st.selectbox("Gas Fill", ["Air", "Argon", "Krypton"], index=0)
+                        low_e_coating = st.checkbox("Low-E Coating")
+                        shading_options = {d.name: d.id for d in self.shading_system.shading_devices.values()}
+                        shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=0)
+                        coverage = st.number_input("Coverage (%)", min_value=0.0, max_value=100.0, value=100.0, step=5.0)
+                        device = self.shading_system.get_device(shading_options[shading_device])
+                        device.coverage_percentage = coverage
+                        st.write(f"Effective SHGC: {self.shading_system.calculate_effective_shgc(shgc, shading_options[shading_device]):.2f}")
+                    elif component_type == ComponentType.DOOR:
+                        door_type = st.text_input("Door Type", "Custom")
             
             submitted = st.form_submit_button("Add Component")
-            
             if submitted:
-                try:
-                    if use_preset and preset_components:
-                        component_id = preset_options[selected_preset]
-                        component = component_library.get_component(component_id)
-                        if not component:
-                            raise ValueError(f"Preset component {selected_preset} not found.")
-                        new_component_id = component_library.clone_component(component_id, f"{component.name} (Copy)")
-                        component = component_library.get_component(new_component_id)
-                        component.area = area
-                        component.orientation = Orientation(orientation)
-                    else:
-                        component_dict = {
-                            "id": f"custom_{type_name}_{len(session_state.components[type_name + 's'])}",
-                            "name": name,
-                            "u_value": u_value,
-                            "area": area,
-                            "orientation": Orientation(orientation)
-                        }
-                        if component_type == ComponentType.WALL:
-                            component = Wall(**component_dict)
-                        elif component_type == ComponentType.ROOF:
-                            component = Roof(**component_dict)
-                        elif component_type == ComponentType.FLOOR:
-                            component = Floor(**component_dict)
-                        elif component_type == ComponentType.WINDOW:
-                            component = Window(**component_dict, shgc=0.7, vt=0.7)
-                        elif component_type == ComponentType.DOOR:
-                            component = Door(**component_dict, shgc=0.0, vt=0.0)
+                if not name:
+                    st.error(f"{type_name.capitalize()} name is required!")
+                elif area <= 0:
+                    st.error(f"{type_name.capitalize()} area must be greater than zero!")
+                elif u_value <= 0:
+                    st.error(f"{type_name.capitalize()} U-value must be greater than zero!")
+                else:
+                    try:
+                        if selection_method == "Select from Presets" and preset_components:
+                            component_id = preset_options[selected_preset]
+                            component = self.component_library.get_component(component_id)
+                            new_component = component.__class__(
+                                id=str(uuid.uuid4()), name=name, area=area, 
+                                orientation=Orientation[orientation], **vars(component)
+                            )
+                            del new_component.__dict__["id"]
                         else:
-                            raise ValueError(f"Unsupported component type: {component_type}")
-                        component_library.add_component(component)
-                    
-                    session_state.components[type_name + 's'].append(component)
-                    st.success(f"Added {component.name}")
-                    st.rerun()
-                except ValueError as e:
-                    st.error(f"Error adding component: {str(e)}")
-                except Exception as e:
-                    st.error(f"Unexpected error: {str(e)}")
-    
-    def _display_components_table(self, session_state: Any, component_type: ComponentType, 
-                                components: List[BuildingComponent]) -> None:
+                            if component_type == ComponentType.WALL:
+                                new_component = Wall(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation[orientation], wall_type=wall_type, wall_group=wall_group
+                                )
+                            elif component_type == ComponentType.ROOF:
+                                new_component = Roof(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation[orientation], roof_type=roof_type, roof_group=roof_group
+                                )
+                            elif component_type == ComponentType.FLOOR:
+                                new_component = Floor(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation[orientation], floor_type=floor_type
+                                )
+                            elif component_type == ComponentType.WINDOW:
+                                new_component = Window(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation[orientation], shgc=shgc, vt=vt, window_type=window_type,
+                                    glazing_layers=glazing_layers, gas_fill=gas_fill, low_e_coating=low_e_coating,
+                                    shading_device_id=shading_options[shading_device]
+                                )
+                            elif component_type == ComponentType.DOOR:
+                                new_component = Door(
+                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                    orientation=Orientation[orientation], door_type=door_type
+                                )
+                        self.component_library.add_component(new_component)
+                        session_state.components[type_name + 's'].append(new_component)
+                        st.success(f"Added {new_component.name}")
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+    def _display_components_table(self, session_state: Any, component_type: ComponentType, components: List[Any]) -> None:
         type_name = component_type.value.lower()
         data = []
         for comp in components:
-            data.append({
-                "Name": comp.name,
-                "Area (m²)": comp.area,
-                "U-Value (W/m²·K)": comp.u_value,
-                "Orientation": comp.orientation.value,
-                "ID": comp.id
-            })
+            row = {"Name": comp.name, "Area (m²)": comp.area, "U-Value (W/m²·K)": comp.u_value, "Orientation": comp.orientation.name, "ID": comp.id}
+            if component_type == ComponentType.WALL:
+                row.update({"Wall Type": comp.wall_type, "Wall Group": comp.wall_group})
+            elif component_type == ComponentType.ROOF:
+                row.update({"Roof Type": comp.roof_type, "Roof Group": comp.roof_group})
+            elif component_type == ComponentType.FLOOR:
+                row.update({"Floor Type": comp.floor_type})
+            elif component_type == ComponentType.WINDOW:
+                row.update({"SHGC": comp.shgc, "VT": comp.vt, "Window Type": comp.window_type,
+                           "Effective SHGC": self.shading_system.calculate_effective_shgc(comp.shgc, comp.shading_device_id)})
+            elif component_type == ComponentType.DOOR:
+                row.update({"Door Type": comp.door_type})
+            data.append(row)
         
         df = pd.DataFrame(data)
-        st.dataframe(df.drop(columns=["ID"]), use_container_width=True)
+        display_cols = [col for col in df.columns if col != "ID"]
+        st.dataframe(df[display_cols], use_container_width=True)
         
         for i, row in df.iterrows():
-            col1, col2, col3 = st.columns([1, 1, 1])
+            col1, col2 = st.columns(2)
             with col1:
                 if st.button("Edit", key=f"edit_{row['ID']}"):
-                    self._display_edit_component_form(session_state, component_type, row["ID"])
+                    session_state[f"edit_{type_name}"] = row["ID"]
+                    st.rerun()
             with col2:
                 if st.button("Delete", key=f"delete_{row['ID']}"):
                     if not row["ID"].startswith("preset_"):
-                        component_library.remove_component(row["ID"])
-                        session_state.components[type_name + 's'] = [
-                            c for c in components if c.id != row["ID"]
-                        ]
+                        self.component_library.remove_component(row["ID"])
+                        session_state.components[type_name + 's'] = [c for c in components if c.id != row["ID"]]
                         st.success(f"Deleted {row['Name']}")
                         st.rerun()
                     else:
                         st.warning("Cannot delete preset components.")
-            with col3:
-                if st.button("Calculate U-Value", key=f"u_calc_{row['ID']}"):
-                    self._display_u_value_calculator(session_state, component_type, row["ID"])
-    
-    def _display_edit_component_form(self, session_state: Any, component_type: ComponentType, 
-                                   component_id: str) -> None:
+        
+        if f"edit_{type_name}" in session_state:
+            self._display_edit_component_form(session_state, component_type, session_state[f"edit_{type_name}"])
+            del session_state[f"edit_{type_name}"]
+
+    def _display_edit_component_form(self, session_state: Any, component_type: ComponentType, component_id: str) -> None:
         type_name = component_type.value.lower()
         component = next((c for c in session_state.components[type_name + 's'] if c.id == component_id), None)
-        
         if not component:
             st.error("Component not found.")
             return
@@ -195,140 +297,205 @@ class ComponentSelectionInterface:
             col1, col2 = st.columns(2)
             with col1:
                 name = st.text_input("Name", value=component.name)
-            with col2:
-                area = st.number_input("Area (m²)", min_value=0.1, value=component.area, step=0.1)
+                area = st.number_input("Area (m²)", min_value=0.0, value=component.area, step=0.1)
+                if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
+                    orientation = st.selectbox("Orientation", [o.name for o in Orientation], 
+                                             index=[o.name for o in Orientation].index(component.orientation.name))
+                else:
+                    orientation = Orientation.HORIZONTAL.name
             
-            if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
-                orientation = st.selectbox("Orientation", 
-                                         [o.value for o in Orientation],
-                                         index=[o.value for o in Orientation].index(component.orientation.value))
-            else:
-                orientation = component.orientation.value
+            with col2:
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=component.u_value, step=0.01)
+                if component_type == ComponentType.WALL:
+                    wall_type = st.text_input("Wall Type", value=component.wall_type)
+                    wall_group = st.selectbox("Wall Group", ["A", "B", "C", "D", "E", "F", "G", "H"], 
+                                            index=["A", "B", "C", "D", "E", "F", "G", "H"].index(component.wall_group))
+                elif component_type == ComponentType.ROOF:
+                    roof_type = st.text_input("Roof Type", value=component.roof_type)
+                    roof_group = st.selectbox("Roof Group", ["A", "B", "C", "D", "E", "F", "G"], 
+                                            index=["A", "B", "C", "D", "E", "F", "G"].index(component.roof_group))
+                elif component_type == ComponentType.FLOOR:
+                    floor_type = st.text_input("Floor Type", value=component.floor_type)
+                elif component_type == ComponentType.WINDOW:
+                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=component.shgc, step=0.01)
+                    vt = st.number_input("VT", min_value=0.0, max_value=1.0, value=component.vt, step=0.01)
+                    window_type = st.text_input("Window Type", value=component.window_type)
+                    glazing_layers = st.selectbox("Glazing Layers", [1, 2, 3], index=[1, 2, 3].index(component.glazing_layers))
+                    gas_fill = st.selectbox("Gas Fill", ["Air", "Argon", "Krypton"], 
+                                          index=["Air", "Argon", "Krypton"].index(component.gas_fill))
+                    low_e_coating = st.checkbox("Low-E Coating", value=component.low_e_coating)
+                    shading_options = {d.name: d.id for d in self.shading_system.shading_devices.values()}
+                    shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), 
+                                                index=list(shading_options.keys()).index(self.shading_system.get_device(component.shading_device_id).name))
+                    coverage = st.number_input("Coverage (%)", min_value=0.0, max_value=100.0, 
+                                             value=self.shading_system.get_device(component.shading_device_id).coverage_percentage, step=5.0)
+                    device = self.shading_system.get_device(shading_options[shading_device])
+                    device.coverage_percentage = coverage
+                    st.write(f"Effective SHGC: {self.shading_system.calculate_effective_shgc(shgc, shading_options[shading_device]):.2f}")
+                elif component_type == ComponentType.DOOR:
+                    door_type = st.text_input("Door Type", value=component.door_type)
             
             submitted = st.form_submit_button("Update Component")
-            
             if submitted:
-                try:
+                if not name:
+                    st.error(f"{type_name.capitalize()} name is required!")
+                elif area <= 0:
+                    st.error(f"{type_name.capitalize()} area must be greater than zero!")
+                elif u_value <= 0:
+                    st.error(f"{type_name.capitalize()} U-value must be greater than zero!")
+                else:
                     component.name = name
                     component.area = area
-                    component.orientation = Orientation(orientation)
-                    component_library.update_component(component_id, component)
+                    component.u_value = u_value
+                    component.orientation = Orientation[orientation]
+                    if component_type == ComponentType.WALL:
+                        component.wall_type = wall_type
+                        component.wall_group = wall_group
+                    elif component_type == ComponentType.ROOF:
+                        component.roof_type = roof_type
+                        component.roof_group = roof_group
+                    elif component_type == ComponentType.FLOOR:
+                        component.floor_type = floor_type
+                    elif component_type == ComponentType.WINDOW:
+                        component.shgc = shgc
+                        component.vt = vt
+                        component.window_type = window_type
+                        component.glazing_layers = glazing_layers
+                        component.gas_fill = gas_fill
+                        component.low_e_coating = low_e_coating
+                        component.shading_device_id = shading_options[shading_device]
+                    elif component_type == ComponentType.DOOR:
+                        component.door_type = door_type
+                    self.component_library.update_component(component_id, component)
                     st.success(f"Updated {name}")
                     st.rerun()
-                except ValueError as e:
-                    st.error(f"Error updating component: {str(e)}")
-    
-    def _display_u_value_calculator(self, session_state: Any, component_type: ComponentType, 
-                                  component_id: str) -> None:
-        type_name = component_type.value.lower()
-        component = next((c for c in session_state.components[type_name + 's'] if c.id == component_id), None)
+
+    def _display_u_value_calculator_tab(self, session_state: Any) -> None:
+        st.subheader("U-Value Calculator")
+        
+        if "material_layers" not in session_state:
+            session_state.material_layers = []
+        
+        components = []
+        for type_name in ['walls', 'roofs', 'floors', 'windows', 'doors']:
+            components.extend(session_state.components[type_name])
+        
+        if not components:
+            st.warning("No components available. Add components first.")
+            return
         
+        selected_component = st.selectbox("Select Component", options=[c.name for c in components])
+        component = next((c for c in components if c.name == selected_component), None)
         if not component:
             st.error("Component not found.")
             return
         
-        st.subheader(f"U-Value Calculator for {component.name}")
-        
-        if component.material_layers:
-            st.write("Current Material Layers:")
-            layers_df = pd.DataFrame([{
-                "Name": layer.name,
-                "Thickness (m)": layer.thickness,
-                "Conductivity (W/m·K)": layer.conductivity
-            } for layer in component.material_layers])
-            st.dataframe(layers_df, use_container_width=True)
-        else:
-            st.info("No material layers defined yet.")
-        
-        with st.form(f"u_value_form_{component_id}"):
-            st.write("Add New Layer:")
+        if session_state.material_layers:
+            st.write("Current 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.material_layers)]
+            st.dataframe(pd.DataFrame(layer_data), use_container_width=True)
+            
+            r_outside = 0.04  # m²·K/W
+            r_inside = 0.13  # m²·K/W
+            r_layers = sum([l["thickness"] / 1000 / l["conductivity"] for l in session_state.material_layers])
+            r_total = r_outside + r_layers + r_inside
+            u_value = 1 / r_total if r_total > 0 else 0
+            
             col1, col2, col3 = st.columns(3)
             with col1:
-                material_options = {m["name"]: mid for mid, m in reference_data.materials.items()}
-                material_name = st.selectbox("Material", options=list(material_options.keys()))
+                st.metric("Total R-Value", f"{r_total:.3f} m²·K/W")
             with col2:
-                thickness = st.number_input("Thickness (m)", min_value=0.001, value=0.1, step=0.01)
+                st.metric("U-Value", f"{u_value:.3f} W/m²·K")
             with col3:
-                custom_conductivity = st.checkbox("Custom Conductivity")
-                if custom_conductivity:
-                    conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=0.5, step=0.01)
+                if st.button("Use This U-Value"):
+                    component.u_value = u_value
+                    self.component_library.update_component(component.id, component)
+                    session_state.material_layers = []
+                    st.success(f"U-Value set to {u_value:.3f} W/m²·K for {component.name}")
+                    st.rerun()
+            
+            if st.button("Remove Last Layer"):
+                if session_state.material_layers:
+                    session_state.material_layers.pop()
+                    st.rerun()
+        
+        with st.form("material_layer_form"):
+            col1, col2 = st.columns(2)
+            with col1:
+                material_selection = st.radio("Material Selection", ["Select from Presets", "Custom Material"])
+                if material_selection == "Select from Presets":
+                    preset_materials = self.u_value_calculator.get_preset_materials()
+                    material_options = {m["name"]: m for m in preset_materials}
+                    material_name = st.selectbox("Material", options=list(material_options.keys()))
+                    conductivity = material_options[material_name]["conductivity"]
+                    st.number_input("Conductivity (W/m·K)", value=conductivity, disabled=True)
                 else:
-                    conductivity = reference_data.materials[material_options[material_name]]["conductivity"]
+                    material_name = st.text_input("Material Name", "Custom Material")
+                    conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=1.0, step=0.01)
             
-            col4, col5 = st.columns(2)
-            with col4:
-                add_layer = st.form_submit_button("Add Layer")
-            with col5:
-                calculate = st.form_submit_button("Calculate U-Value")
+            with col2:
+                thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
+                if conductivity > 0:
+                    r_value = thickness / 1000 / conductivity
+                    st.metric("Layer R-Value", f"{r_value:.3f} m²·K/W")
             
-            if add_layer:
-                try:
-                    layer = MaterialLayer(
-                        name=material_name,
-                        thickness=thickness,
-                        conductivity=conductivity,
-                        density=reference_data.materials.get(material_options[material_name], {}).get("density"),
-                        specific_heat=reference_data.materials.get(material_options[material_name], {}).get("specific_heat")
-                    )
-                    component.material_layers.append(layer)
-                    component_library.update_component(component_id, component)
+            submitted = st.form_submit_button("Add Layer")
+            if submitted:
+                if not material_name:
+                    st.error("Material name is required!")
+                elif thickness <= 0:
+                    st.error("Thickness must be greater than zero!")
+                elif conductivity <= 0:
+                    st.error("Conductivity must be greater than zero!")
+                else:
+                    session_state.material_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
                     st.success(f"Added layer: {material_name}")
                     st.rerun()
-                except ValueError as e:
-                    st.error(f"Error adding layer: {str(e)}")
-            
-            if calculate:
-                if not component.material_layers:
-                    st.error("No layers defined for U-value calculation.")
-                else:
-                    assembly_id = u_value_calculator.create_assembly(f"{component.name} Assembly")
-                    for layer in component.material_layers:
-                        u_value_calculator.add_custom_layer_to_assembly(
-                            assembly_id, layer.name, layer.thickness, layer.conductivity,
-                            layer.density, layer.specific_heat
-                        )
-                    u_value = u_value_calculator.calculate_u_value(assembly_id)
-                    if u_value is not None:
-                        component.u_value = u_value
-                        component_library.update_component(component_id, component)
-                        st.success(f"Calculated U-Value: {u_value:.3f} W/(m²·K)")
-                        st.rerun()
-                    else:
-                        st.error("Failed to calculate U-value.")
-    
+
     def _save_components(self, session_state: Any) -> None:
-        try:
-            for type_name in ['walls', 'roofs', 'floors', 'windows', 'doors']:
-                for comp in session_state.components[type_name]:
-                    component_library.update_component(comp.id, comp)
-            
-            file_path = "components_export.json"
-            component_library.export_to_json(file_path)
-            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.")
-        except Exception as e:
-            st.error(f"Error saving components: {str(e)}")
-    
+        components_dict = {
+            "walls": [c.__dict__ for c in session_state.components["walls"]],
+            "roofs": [c.__dict__ for c in session_state.components["roofs"]],
+            "floors": [c.__dict__ for c in session_state.components["floors"]],
+            "windows": [c.__dict__ for c in session_state.components["windows"]],
+            "doors": [c.__dict__ for c in session_state.components["doors"]]
+        }
+        for type_name in components_dict:
+            for comp in components_dict[type_name]:
+                comp["orientation"] = comp["orientation"].name
+                comp["component_type"] = comp["component_type"].name
+        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.")
+
     def _load_components(self, session_state: Any, uploaded_file: Any) -> None:
-        try:
-            data = json.load(uploaded_file)
-            count = component_library.import_from_json(data)
-            
-            session_state.components = {
-                'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []
-            }
-            
-            for comp_id, comp in component_library.components.items():
-                type_name = comp.component_type.value.lower() + 's'
+        data = json.load(uploaded_file)
+        session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
+        for type_name in data:
+            for comp_dict in data[type_name]:
+                comp_dict["orientation"] = Orientation[comp_dict["orientation"]]
+                comp_dict["component_type"] = ComponentType[comp_dict["component_type"]]
+                if type_name == "walls":
+                    comp = Wall(**comp_dict)
+                elif type_name == "roofs":
+                    comp = Roof(**comp_dict)
+                elif type_name == "floors":
+                    comp = Floor(**comp_dict)
+                elif type_name == "windows":
+                    comp = Window(**comp_dict)
+                elif type_name == "doors":
+                    comp = Door(**comp_dict)
+                self.component_library.add_component(comp)
                 session_state.components[type_name].append(comp)
-            
-            st.success(f"Loaded {count} components successfully.")
-            st.rerun()
-        except Exception as e:
-            st.error(f"Error loading components: {str(e)}")
+        st.success("Loaded components successfully.")
+        st.rerun()
+
+# --- Main Execution ---
+if __name__ == "__main__":
+    interface = ComponentSelectionInterface()
+    interface.display_component_selection(st.session_state)