app.py

import streamlit as st
fuel_values = ["Coal", "Natural Gas", "Oil", "Renewable Energy", "Other"]
purchased_goods_values = ["Cement", "Plaster", "Paint", "Timber", "Concrete"]
supplier_values = ["Supplier C", "Supplier D", "Supplier E", "Supplier F", "Supplier G"]
scope_values = ["Electricity", "Natural Gas"]
material_inputs_values = ["Cotton", "Polymer", "Chemical A", "Chemical B"]
transport_values = ["Cotton", "Polymer", "Chemical A", "Chemical B"]
waste_output_values = ["Waste sent to landfill"]
categories = ["Category 1", "Category 2", "Category 3", "Category 4", "Category 5",
              "Category 6", "Category 7", "Category 8", "Category 9", "Category 10",
              "Category 11", "Category 12", "Category 13", "Category 14", "Category 15"]

def calculate_emissions_supplier_specific(purchased_goods_data):
    total_emissions = sum([qty * emission_factor for _, _, qty, emission_factor in purchased_goods_data])
    st.header(f"Total Emissions for Supplier-specific Method: {total_emissions} kg CO2e")
    

def calculate_emissions_hybrid(scope1_and_scope2_data, material_inputs_data, transport_data, waste_output_data):
    scope1_and_scope2_emissions = sum([float(item['Amount (kWh)']) * float(item['Emission factor (kg CO2e/kWh)']) for item in scope1_and_scope2_data])
    waste_output_emissions = sum([float(item['Amount (kg)']) * float(item['Emission factor (kg CO2e/kg of waste sent to landfill)']) for item in waste_output_data])
    other_upstream_emissions = sum([float(item['Mass purchased (kg)']) * float(item['Emission factor (kg CO2e/kg)']) for item in material_inputs_data])
    total_emissions = scope1_and_scope2_emissions + waste_output_emissions + other_upstream_emissions

    transport_emissions_per_item = [
        float(item['Distance of transport (km)']) * float(item1['Mass purchased (kg)']) * float(item['Vehicle type emission factor (kg CO2e/kg/km)'])
        for item in transport_data for item1 in material_inputs_data if item["Purchased Goods"] == item1["Purchased Goods"]
    ]

    for i, item in enumerate(transport_data):
        st.header(f"Emissions for Purchased Item {i + 1}: {transport_emissions_per_item[i]} kg CO2e")

    

def calculate_emissions_hybrid_pro(tshirt_data, scope_data, waste_output_data):
    scope1_and_scope2_emissions = sum([float(item['Amount (kWh)']) * float(item['Emission factor (kg CO2e/kWh)']) for item in scope_data])
    waste_output_emissions = sum([float(item['Amount (kg)']) * float(item['Emission factor (kg CO2e/kg of waste sent to landfill)']) for item in waste_output_data])
    other_upstream_emissions = sum([float(item['Number of t-shirts purchased']) * float(item['Cradle-to-gate process emission factor (kg CO2e/per t-shirt(excluding scopes)']) for item in tshirt_data])
    total_emissions = scope1_and_scope2_emissions + waste_output_emissions + other_upstream_emissions
    st.header(f"Total Emissions for HybridPro Method: {total_emissions} kg CO2e")
    

def collect_category_3_data():
    st.header("Category 3: Fuel and Energy related activities not included in scope 1 and Scope 2")

    method_options = ["Method 1: Upstream emissions of purchased fuels",
                      "Method 2: Upstream emissions of purchased electricity",
                      "Method 3: Transmission and distribution losses",
                      "Method 4: Emissions from power that is purchased and sold"]
    selected_method = st.selectbox("Select Method", method_options)

    if selected_method == "Method 1: Upstream emissions of purchased fuels":
        fuel_data = dynamic_input_fields("Fuel Data", ["Fuel consumed (kWh)", "Upstream fuel emission factor (kg CO2e/kWh)"], ["Fuel consumed (kWh)", "Upstream fuel emission factor (kg CO2e/kWh)"])
        calculate_emissions_category_3_method_1(fuel_data)

    elif selected_method == "Method 2: Upstream emissions of purchased electricity":
        selected_country = st.selectbox("Select country", ["Australia", "Canada", "India", "US", "Turkey"])
        electricity_data = dynamic_input_fields("Electricity Data", ["Electricity"], ["Electricity"], country=selected_country)
        steam_data = dynamic_input_fields("Steam Data", ["Steam"], ["Steam"], country=selected_country)
        heating_data = dynamic_input_fields("Heating Data", ["Heating"], ["Heating"], country=selected_country)
        cooling_data = dynamic_input_fields("Cooling Data", ["Cooling"], ["Cooling"], country=selected_country)
        upstream_emission_factors = dynamic_input_fields("Upstream Emission Factors", ["Electricity", "Steam", "Heating", "Cooling"], ["Electricity", "Steam", "Heating", "Cooling"], country=selected_country)
        calculate_emissions_category_3_method_2(electricity_data, steam_data, heating_data, cooling_data, upstream_emission_factors,selected_country)

    elif selected_method == "Method 3: Transmission and distribution losses":
        selected_country = st.selectbox("Select country", ["Australia", "Canada", "India", "US", "Turkey"])
        electricity_data = dynamic_input_fields("Electricity Data", ["Electricity"], ["Electricity"], country=selected_country)
        steam_data = dynamic_input_fields("Steam Data", ["Steam"], ["Steam"], country=selected_country)
        heating_data = dynamic_input_fields("Heating Data", ["Heating"], ["Heating"], country=selected_country)
        cooling_data = dynamic_input_fields("Cooling Data", ["Cooling"], ["Cooling"], country=selected_country)
        t_and_d_loss_data = dynamic_input_fields("T&D Loss Data", ["Transmission"], ["Transmission"], country=selected_country)
        upstream_emission_factors = dynamic_input_fields("Upstream Emission Factors", ["Electricity", "Steam", "Heating", "Cooling"], ["Electricity", "Steam", "Heating", "Cooling"], country=selected_country)
        calculate_emissions_category_3_method_3(electricity_data,steam_data,heating_data,cooling_data,upstream_emission_factors, t_and_d_loss_data,selected_country)   
    
    elif selected_method == "Method 4: Emissions from power that is purchased and sold":
        selected_country = st.selectbox("Select country", ["Australia", "Canada", "India", "US", "Turkey"])
        electricity_data = dynamic_input_fields("Electricity Data", ["Electricity"], ["Electricity"],country=selected_country)
        steam_data = dynamic_input_fields("Steam Data", ["Steam"], ["Steam"],country=selected_country)
        heating_data = dynamic_input_fields("Heating Data", ["Heating"], ["Heating"],country=selected_country)
        cooling_data = dynamic_input_fields("Cooling Data", ["Cooling"], ["Cooling"],country=selected_country)
        upstream_emission_factors = dynamic_input_fields("Upstream Emission Factors", ["Electricity", "Steam", "Heating", "Cooling"], ["Country", "Electricity", "Steam", "Heating", "Cooling"], country=selected_country)
        calculate_emissions_category_3_method_4(electricity_data,steam_data,heating_data,cooling_data,upstream_emission_factors,selected_country) 

def calculate_emissions_category_3_method_1(fuel_data):
    total_emissions = sum(
        [
            item["Fuel consumed (kWh)"] * (item["Upstream fuel emission factor (kg CO2e/kWh)"])
            for item in fuel_data
        ]
    )
    st.header(f"Total Emissions for Upstream emissions of purchased fuels is {total_emissions} kg CO2e")

def calculate_emissions_category_3_method_2(electricity_data, steam_data, heating_data, cooling_data, upstream_emission_factor,selected_country):
    country_electricity = next(item for item in electricity_data if item["Country"] == selected_country)["Electricity"]
    country_steam = next(item for item in steam_data if item["Country"] == selected_country)["Steam"]
    country_heating = next(item for item in heating_data if item["Country"] == selected_country)["Heating"]
    country_cooling = next(item for item in cooling_data if item["Country"] == selected_country)["Cooling"]
    country_factors = next(item for item in upstream_emission_factor if item["Country"] == selected_country)

    total_emissions = (
        country_electricity * country_factors["Electricity"]
        + country_steam * country_factors["Steam"]
        + country_heating * country_factors["Heating"]
        + country_cooling * country_factors["Cooling"]
    )

    st.header(f"Total Emissions for Upstream emissions of purchased electricity: {total_emissions} kg CO2e")

def calculate_emissions_category_3_method_3(electricity_data, steam_data, heating_data, cooling_data, upstream_emission_factors,t_and_d_loss, selected_country):
    country_electricity = next(item for item in electricity_data if item["Country"] == selected_country)["Electricity"]
    country_steam = next(item for item in steam_data if item["Country"] == selected_country)["Steam"]
    country_heating = next(item for item in heating_data if item["Country"] == selected_country)["Heating"]
    country_cooling = next(item for item in cooling_data if item["Country"] == selected_country)["Cooling"]
    country_factors = next(item for item in upstream_emission_factors if item["Country"] == selected_country)
    country_td = next(item for item in t_and_d_loss if item["Country"] == selected_country)
    st.header(country_factors)
    total_emissions = (
        country_electricity * country_factors["Electricity"] * country_td["Transmission"]
        + country_steam * country_factors["Steam"] * country_td["Transmission"]
        + country_heating * country_factors["Heating"] * country_td["Transmission"]
        + country_cooling * country_factors["Cooling"] * country_td["Transmission"]
    )

    st.header(f"Total Emissions for Transmission and distribution losses: {total_emissions} kg CO2e")

def calculate_emissions_category_3_method_4(electricity_data, steam_data, heating_data, cooling_data, emission_factors, selected_country):
    country_factors = next((item for item in emission_factors if item["Country"] == selected_country), None)
    st.header(country_factors)
    if country_factors is not None:
        total_emissions = (
            sum(item["Electricity"] * country_factors["Electricity"] for item in electricity_data)
            + sum(item["Steam"] * country_factors["Steam"] for item in steam_data)
            + sum(item["Heating"] * country_factors["Heating"] for item in heating_data)
            + sum(item["Cooling"] * country_factors["Cooling"] for item in cooling_data)
        )

        st.header(f"Total Emissions where power is purchased and sold: {total_emissions} kg CO2e")
    else:
        st.warning(f"No emission factors found for {selected_country} in emission_factors.")


def calculate_emissions_category_4_method_1(fuel_data, electricity_data, refrigerant_data, total_fuel_spend=None, total_distance_travelled=None):
    fuel_emissions = sum([item["Fuel consumed (liters)"] * item["Emission factor (kg CO2e/liter)"] for item in fuel_data])
    electricity_emissions = sum([item["Quantity of electricity consumed (kWh)"] * item["Emission factor for electricity grid (kg CO2e/kWh)"] for item in electricity_data])
    refrigerant_emissions = sum([item["Refrigerant leakage (kg)"] * item["Global warming potential for refrigerant (kg CO2e)"] for item in refrigerant_data])

    if total_fuel_spend:
        quantities_of_fuel = sum([item["Total fuel spend ($)"] / item["Average fuel price ($/liter)"] for item in fuel_data])
        fuel_emissions_from_spending = quantities_of_fuel * sum([item["Average fuel price ($/liter)"] * item["Emission factor (kg CO2e/liter)"] for item in fuel_data])
        total_emissions = fuel_emissions + electricity_emissions + refrigerant_emissions + fuel_emissions_from_spending
    elif total_distance_travelled:
        quantities_of_fuel_consumed = sum([item["Total distance travelled (km)"] * item["Fuel efficiency of vehicle (liters/km)"] for item in fuel_data])
        fuel_emissions_from_distance = quantities_of_fuel_consumed * sum([item["Emission factor for the fuel (kg CO2e/liter)"] for item in fuel_data])
        total_emissions = fuel_emissions + electricity_emissions + refrigerant_emissions + fuel_emissions_from_distance
    else:
        total_emissions = fuel_emissions + electricity_emissions + refrigerant_emissions

    st.header(f"Total Emissions for Fuel-based Method: {total_emissions} kg CO2e")


def calculate_emissions_category_4_method_2(fuel_data, average_efficiency_unladen, total_distance_travelled_unladen):
    total_emissions_unladen = sum([item["Quantity of fuel consumed from backhaul"] * item["Emission factor for the fuel (kg CO2e/liter)"] for item in fuel_data])
    total_emissions_unladen += sum([average_efficiency_unladen * total_distance_travelled_unladen * item["Emission factor for the fuel (kg CO2e/liter)"] for item in fuel_data])

    st.header(f"Total Emissions for Unladen Backhaul: {total_emissions_unladen} kg CO2e")


def calculate_emissions_category_4_method_3(transport_data):
    total_emissions_transport = sum([
        item["Mass of goods purchased (tonnes)"] * item["Distance travelled in transport leg (km)"] * item["Emission factor of transport mode or vehicle type (kg CO2e/tonne-km)"]
        for item in transport_data
    ])

    st.header(f"Total Emissions for Transportation: {total_emissions_transport} kg CO2e")


def calculate_emissions_category_4_method_4(storage_data):
    total_emissions_distribution = sum([
        (
            item["Fuel consumed (kWh)"] * item["Fuel emission factor (kg CO2e/kWh)"]
            + item["Electricity consumed (kWh)"] * item["Electricity emission factor (kg CO2e/kWh)"]
            + item["Refrigerant leakage (kg)"] * item["Refrigerant emission factor (kg CO2e/kg)"]
        ) * (
            item["Volume of company A’s goods (m3)"] / item["Total volume of goods in storage facility (m3)"] if item["Total volume of goods in storage facility (m3)"] != 0 else 0
        )
        for item in storage_data
    ])

    st.header(f"Total Emissions for Distribution: {total_emissions_distribution} kg CO2e")


def calculate_emissions_category_4_method_5(storage_data):
    total_emissions_distribution = sum([
        item["Volume of stored goods (m3)"] * item["Average number of days stored (days)"] * item["Emission factor for storage facility (kg CO2e/m3/day)"]
        for item in storage_data
    ])

    st.header(f"Total Emissions for Distribution (Method 5): {total_emissions_distribution} kg CO2e")

def calculate_emissions_category_5_method_1(waste_treatment_data):
    total_emissions_category_5 = sum([
        item["Allocated scope 1 and scope 2 emissions of waste treatment company"]
        for item in waste_treatment_data
    ])

    st.header(f"Total Emissions for Category 5 (Method 1): {total_emissions_category_5} kg CO2e")

def collect_category_4_method_1_data():
    st.header("Category 4: Method 1 - Fuel-based Method")

    fuel_data = dynamic_input_fields_with_emission_factor("Fuel Data", "Enter fuel data", ["Fuel consumed (liters)", "Emission factor (kg CO2e/liter)", "Total fuel spend ($)", "Average fuel price ($/liter)","Total distance travelled (km)"],
                                                          ["Fuel consumed (liters)", "Emission factor (kg CO2e/liter)", "Total fuel spend ($)", "Average fuel price ($/liter)","Total distance travelled (km)"])
    electricity_data = dynamic_input_fields_with_emission_factor("Electricity Data", "Enter electricity data", ["Quantity of electricity consumed (kWh)", "Emission factor for electricity grid (kg CO2e/kWh)"],
                                                                 ["Quantity of electricity consumed (kWh)", "Emission factor for electricity grid (kg CO2e/kWh)"])
    refrigerant_data = dynamic_input_fields_with_emission_factor("Refrigerant Data", "Enter refrigerant data", ["Refrigerant leakage (kg)", "Global warming potential for refrigerant (kg CO2e)"],
                                                                ["Refrigerant leakage (kg)", "Global warming potential for refrigerant (kg CO2e)"])

    total_fuel_spend = st.checkbox("Calculate based on total fuel spend")
    calculate_emissions_category_4_method_1(fuel_data, electricity_data, refrigerant_data, total_fuel_spend=total_fuel_spend)

def collect_category_4_method_2_data():
    st.header("Category 4: Method 2 - Unladen Backhaul")

    fuel_data = dynamic_input_fields_with_emission_factor("Fuel Data", "Enter fuel data", ["Quantity of fuel consumed from backhaul", "Emission factor for the fuel (kg CO2e/liter)"],
                                                          ["Quantity of fuel consumed from backhaul", "Emission factor for the fuel (kg CO2e/liter)"])
    average_efficiency_unladen = st.number_input("Average efficiency unladen", min_value=0.0, step=0.01, key="average_efficiency_unladen")
    total_distance_travelled_unladen = st.number_input("Total distance travelled unladen (km)", min_value=0.0, step=0.01, key="total_distance_travelled_unladen")

    calculate_emissions_category_4_method_2(fuel_data, average_efficiency_unladen, total_distance_travelled_unladen)

def collect_category_4_method_3_data():
    st.header("Category 4: Method 3 - Transportation")

    transport_data = dynamic_input_fields_with_emission_factor("Transport Data", "Enter transport data", ["Mass of goods purchased (tonnes)", "Distance travelled in transport leg (km)", "Emission factor of transport mode or vehicle type (kg CO2e/tonne-km)"],
                                                               ["Mass of goods purchased (tonnes)", "Distance travelled in transport leg (km)", "Emission factor of transport mode or vehicle type (kg CO2e/tonne-km)"])

    calculate_emissions_category_4_method_3(transport_data)

def collect_category_4_method_4_data():
    st.header("Category 4: Method 4 - Distribution")

    storage_data = dynamic_input_fields_with_emission_factor("Storage Data", "Enter storage data", ["Fuel consumed (kWh)", "Electricity consumed (kWh)", "Refrigerant leakage (kg)",
                                                                                                 "Volume of company A’s goods (m3)", "Total volume of goods in storage facility (m3)",
                                                                                                 "Fuel emission factor (kg CO2e/kWh)", "Electricity emission factor (kg CO2e/kWh)", "Refrigerant emission factor (kg CO2e/kg)"],
                                                             ["Fuel consumed (kWh)", "Electricity consumed (kWh)", "Refrigerant leakage (kg)",
                                                              "Volume of company A’s goods (m3)", "Total volume of goods in storage facility (m3)",
                                                              "Fuel emission factor (kg CO2e/kWh)", "Electricity emission factor (kg CO2e/kWh)", "Refrigerant emission factor (kg CO2e/kg)"])

    calculate_emissions_category_4_method_4(storage_data)

def collect_category_4_method_5_data():
    st.header("Category 4: Method 5 - Distribution (Method 5)")

    storage_data = dynamic_input_fields_with_emission_factor("Storage Data", "Enter storage data", ["Volume of stored goods (m3)", "Average number of days stored (days)", "Emission factor for storage facility (kg CO2e/m3/day)"],
                                                             ["Volume of stored goods (m3)", "Average number of days stored (days)", "Emission factor for storage facility (kg CO2e/m3/day)"])

    calculate_emissions_category_4_method_5(storage_data)

def get_input_category_5_method_1():
    st.subheader("Method 1: CO2e emissions from waste generated in operations")
    waste_treatment_data = dynamic_input_fields("Waste Treatment Provider", ["Allocated emissions"], ["Allocated scope 1 and scope 2 emissions of waste treatment company"])
    calculate_emissions_category_5_method_1(waste_treatment_data)

def calculate_emissions_category_5_method_1(waste_treatment_data):
    total_emissions = sum([item["Allocated emissions"] for item in waste_treatment_data])
    st.header(f"Total Emissions for Method 1: {total_emissions} kg CO2e")


def get_input_category_5_method_2():
    st.subheader("Method 2: CO2e emissions from waste generated in operations")
    waste_type_data = dynamic_input_fields_with_emission_factor("Waste Type", "Enter waste type data",
                                                                ["Waste produced (tonnes)", "Waste treatment", "Waste type and waste treatment specific emission factor"],
                                                                ["Waste produced (tonnes)", "Waste treatment", "Waste type and waste treatment specific emission factor"])
    calculate_emissions_category_5_method_2(waste_type_data)

def calculate_emissions_category_5_method_2(waste_type_data):
    total_emissions = sum([
        item["Waste produced (tonnes)"] * item["Waste type and waste treatment specific emission factor"]
        for item in waste_type_data
    ])
    st.header(f"Total Emissions for Method 2: {total_emissions} kg CO2e")


def get_input_category_5_method_3():
    st.subheader("Method 3: Average Method - CO2e emissions from waste generated in operations")
    waste_treatment_method_data = dynamic_input_fields_with_emission_factor("Waste Treatment Method", "Enter waste treatment method data",
                                                                            ["Total mass of waste (tonnes)", "Proportion (percent)", "Emission factor (kg CO2e/tonne)"],
                                                                            ["Total mass of waste (tonnes)", "Proportion (percent)", "Emission factor (kg CO2e/tonne)"])
    calculate_emissions_category_5_method_3(waste_treatment_method_data)

def calculate_emissions_category_5_method_3(waste_treatment_method_data):
    total_emissions = sum([
        item["Total mass of waste (tonnes)"] * (item["Proportion (percent)"] / 100) * item["Emission factor (kg CO2e/tonne)"]
        for item in waste_treatment_method_data
    ])
    st.header(f"Total Emissions for Method 3: {total_emissions} kg CO2e")

def get_input_category_6_method_1():
    st.subheader("Method 1: Distance-based Method - Business Travel Emissions")
    road_travel_data = dynamic_input_fields_with_dropdown_int("Road Travel", "Select road travel data",
                                                          ["Location", "Average employees per vehicle","Number of employees in group", "Car_type", "Distance (km)", "Emission factor (kg CO2e/vehicle-km)"],
                                                          ["Location", "Average employees per vehicle", "Number of employees in group", "Car_type", "Distance (km)", "Emission factor (kg CO2e/vehicle-km)"])

    air_travel_data = dynamic_input_fields_with_dropdown_int("Air Travel", "Select air travel data",
                                                         ["Number of employees in group", "Flight type", "Distance (km)", "Emission factor (kg CO2e/passenger-km)"],
                                                         ["Number of employees in group", "Flight type", "Distance (km)", "Emission factor (kg CO2e/passenger-km)"])

    include_hotel = st.checkbox("Include Hotel Emissions (Optional)")
    hotel_data = []
    if include_hotel:
        hotel_data = dynamic_input_fields("Hotel", ["Annual number of hotel nights", "Hotel emission factor (kg CO2e/night)"],
                                          ["Annual number of hotel nights", "Hotel emission factor (kg CO2e/night)"])

    calculate_emissions_category_6_method_1(road_travel_data, air_travel_data, hotel_data)



def calculate_emissions_category_6_method_1(road_travel_data, air_travel_data, hotel_data):
    road_travel_emissions = 0
    for item in road_travel_data:
        if item["Average employees per vehicle"] != 0:
            road_travel_emissions += (item["Distance (km)"] / item["Average employees per vehicle"]) * item["Emission factor (kg CO2e/vehicle-km)"]

    air_travel_emissions = sum([
        item["Distance (km)"] * item["Emission factor (kg CO2e/passenger-km)"]
        for item in air_travel_data
    ])

    total_emissions = road_travel_emissions + air_travel_emissions

    if hotel_data:
        hotel_emissions = sum([
            item["Annual number of hotel nights"] * item["Hotel emission factor (kg CO2e/night)"]
            for item in hotel_data
        ])
        total_emissions += hotel_emissions

    st.header(f"Total Business Travel Emissions: {total_emissions} kg CO2e")

def get_input_category_7_method_1():
    st.subheader("Method 1: Distance-based Method - Employee Travel Emissions")

    employee_data = dynamic_input_fields_with_dropdown_int("Employee", "Select employee data",
                                                           ["Rail commute (times per week)", "One way distance by rail (km)",
                                                            "Rail emission factor (kg CO2e/passenger-km)",
                                                            "Car commute (times per week)", "Car emission factor (kg CO2e/vehicle-km)",
                                                            "One way distance by car (km)"],
                                                           ["Rail commute (times per week)", "One way distance by rail (km)",
                                                            "Rail emission factor (kg CO2e/passenger-km)",
                                                            "Car commute (times per week)", "Car emission factor (kg CO2e/vehicle-km)",
                                                            "One way distance by car (km)"])

    telework_data = dynamic_input_fields_with_dropdown_int("Telework", "Select telework data",
                                                           ["Quantities of energy consumed (kWh)", "Emission factor for energy source (kg CO2e/kWh)"],
                                                           ["Quantities of energy consumed (kWh)", "Emission factor for energy source (kg CO2e/kWh)"])

    calculate_emissions_category_7_method_1(employee_data, telework_data)

def calculate_emissions_category_7_method_1(employee_data, telework_data):
    total_distance_rail = sum([
        item["Rail commute (times per week)"] * 2 * 5 * item["One way distance by rail (km)"]
        for item in employee_data
    ])

    total_distance_car = sum([
        item["Car commute (times per week)"] * 2 * 5 * item["One way distance by car (km)"]
        for item in employee_data
    ])

    total_emissions = sum([
        (total_distance_rail * item["Rail emission factor (kg CO2e/passenger-km)"]) +
        (total_distance_car * item["Car emission factor (kg CO2e/vehicle-km)"])
        for item in employee_data
    ])

    if telework_data:
        total_emissions += sum([
            item["Quantities of energy consumed (kWh)"] * item["Emission factor for energy source (kg CO2e/kWh)"]
            for item in telework_data
        ])

    st.header(f"Total Employee Travel Emissions (Method 1): {total_emissions} kg CO2e")


def get_input_category_7_method_2():
    st.subheader("Method 2: Average-data Method - Employee Travel Emissions")

    commute_data = dynamic_input_fields_with_dropdown_int("Commute Group", "Select commute group data",
                                                          ["Percent of total commutes", "Average one-way distance (km)",
                                                           "Emission factor (kg CO2e/vehicle or passenger km)"],
                                                          ["Percent of total commutes", "Average one-way distance (km)",
                                                           "Emission factor (kg CO2e/vehicle or passenger km)"])

    total_employees = st.number_input("Enter the total number of employees:", min_value=1, step=1, key="total_employees")

    calculate_emissions_category_7_method_2(commute_data, total_employees)

def calculate_emissions_category_7_method_2(commute_data, total_employees):
    total_emissions = sum([
        total_employees * (item["Percent of total commutes"] / 100) * 2 * 235 * item["Average one-way distance (km)"] *
        item["Emission factor (kg CO2e/vehicle or passenger km)"]
        for item in commute_data
    ])

    st.header(f"Total Employee Travel Emissions (Method 2): {total_emissions} kg CO2e")

def get_input_category_8_method_1():
    st.subheader("Method 1: Asset-specific method - Upstream Leased Assets Emissions")
    asset_data = dynamic_input_fields("Upstream Leased Asset", ["Natural gas (kWh)", "Natural gas emission factor (kg CO2e/kWh)",
                                                               "Electricity (kWh)", "Electricity emission factor (kg CO2e/kWh)",
                                                               "Fugitive emissions", "Fugitive emission factor"],
                                      ["Natural gas (kWh)", "Natural gas emission factor (kg CO2e/kWh)",
                                       "Electricity (kWh)", "Electricity emission factor (kg CO2e/kWh)",
                                       "Fugitive emissions", "Fugitive emission factor"])

    calculate_emissions_category_8_method_1(asset_data)

def calculate_emissions_category_8_method_1(asset_data):
    total_emissions = sum([
        (
            item["Natural gas (kWh)"] * item["Natural gas emission factor (kg CO2e/kWh)"]
            + item["Electricity (kWh)"] * item["Electricity emission factor (kg CO2e/kWh)"]
            + item["Fugitive emissions"] * item["Fugitive emission factor"]
        )
        for item in asset_data
    ])

    st.header(f"Total Emissions from Upstream Leased Assets (Asset-specific Method): {total_emissions} kg CO2e")

def calculate_emissions_category_8_method_2(lessor_data, leased_asset_data):
    total_emissions = sum([
        (
            item["Fuel consumed (e.g., liter)"] * item["Emission factor for fuel source (e.g., kg CO2e/liter)"]
            + item["Refrigerant leakage (kg)"] * item["Emission factor for refrigerant (kg CO2e/kg)"]
            + item["Process emissions"]
            + item["Electricity, steam, heating, cooling consumed (e.g., kWh)"]
            * item["Emission factor for electricity, steam, heating, cooling (e.g., kg CO2e/kWh)"]
        )
        for item in lessor_data
    ])

    total_emissions_allocated = sum([
        (item["Scope 1 and Scope 2 emissions of lessor (kg CO2e)"]
         * item["Area, volume, quantity, etc., of the leased asset"]
         / item["Total area, volume, quantity, etc., of lessor assets"]) if item["Total area, volume, quantity, etc., of lessor assets"] != 0 else 0
        for item in leased_asset_data
    ])

    st.header(f"Total Emissions from Upstream Leased Assets (CO2e Emissions from Leased Assets Method): {total_emissions + total_emissions_allocated} kg CO2e")

def calculate_emissions_category_8_method_3(building_data):
    total_emissions = sum([
        item["Total floor space of building type (m2)"] * item["Average emission factor for building type (kg CO2e/m2/year)"]
        for item in building_data
    ])

    st.header(f"Total Emissions from Upstream Leased Assets (Average-data Method for Leased Buildings): {total_emissions} kg CO2e")


def calculate_emissions_category_8_method_4(asset_data):
    total_emissions = sum([
        item["Number of assets"] * item["Average emissions per asset type (kg CO2e/asset type/year)"]
        for item in asset_data
    ])

    st.header(f"Total Emissions from Upstream Leased Assets (Average-data Method for Other Leased Assets): {total_emissions} kg CO2e")


def get_input_category_8_method_2():
    st.subheader("Method 2: CO2e emissions from leased assets - Upstream Leased Assets Emissions")
    lessor_data = dynamic_input_fields("Lessor", ["Fuel consumed (e.g., liter)", "Emission factor for fuel source (e.g., kg CO2e/liter)",
                                                  "Refrigerant leakage (kg)", "Emission factor for refrigerant (kg CO2e/kg)",
                                                  "Process emissions", "Electricity, steam, heating, cooling consumed (e.g., kWh)",
                                                  "Emission factor for electricity, steam, heating, cooling (e.g., kg CO2e/kWh)"],
                                       ["Fuel consumed (e.g., liter)", "Emission factor for fuel source (e.g., kg CO2e/liter)",
                                        "Refrigerant leakage (kg)", "Emission factor for refrigerant (kg CO2e/kg)",
                                        "Process emissions", "Electricity, steam, heating, cooling consumed (e.g., kWh)",
                                        "Emission factor for electricity, steam, heating, cooling (e.g., kg CO2e/kWh)"])

    leased_asset_data = dynamic_input_fields("Leased Asset", ["Scope 1 and Scope 2 emissions of lessor (kg CO2e)",
                                                             "Area, volume, quantity, etc., of the leased asset",
                                                             "Total area, volume, quantity, etc., of lessor assets"],
                                              ["Scope 1 and Scope 2 emissions of lessor (kg CO2e)",
                                               "Area, volume, quantity, etc., of the leased asset",
                                               "Total area, volume, quantity, etc., of lessor assets"])

    calculate_emissions_category_8_method_2(lessor_data, leased_asset_data)


def get_input_category_8_method_3():
    st.subheader("Method 3: Average-data method for leased buildings - Upstream Leased Assets Emissions")
    building_data = dynamic_input_fields("Building", ["Total floor space of building type (m2)",
                                                      "Average emission factor for building type (kg CO2e/m2/year)"],
                                         ["Total floor space of building type (m2)",
                                          "Average emission factor for building type (kg CO2e/m2/year)"])

    calculate_emissions_category_8_method_3(building_data)


def get_input_category_8_method_4():
    st.subheader("Method 4: Average-data method for leased assets other than buildings - Upstream Leased Assets Emissions")
    asset_data = dynamic_input_fields("Leased Asset", ["Number of assets", "Average emissions per asset type (kg CO2e/asset type/year)"],
                                      ["Number of assets", "Average emissions per asset type (kg CO2e/asset type/year)"])

    calculate_emissions_category_8_method_4(asset_data)

def calculate_emissions_category_9_method_1(transportation_data):
    total_emissions = sum([
        item["Mass of goods sold (tonnes)"] * item["Total downstream distance transported (km)"]
        * item["Emission factor (kg CO2e/tonne-km)"]
        for item in transportation_data
    ])

    st.header(f"Total Emissions from Downstream Transportation: {total_emissions} kg CO2e")

def get_input_category_9_method_1():
    st.subheader("Method 1: Downstream Transportation Emissions")
    transportation_data = dynamic_input_fields("Transportation", ["Mass of goods sold (tonnes)",
                                                                   "Total downstream distance transported (km)",
                                                                   "Transport mode or vehicle type",
                                                                   "Emission factor (kg CO2e/tonne-km)"],
                                                ["Mass of goods sold (tonnes)",
                                                 "Total downstream distance transported (km)",
                                                 "Transport mode or vehicle type",
                                                 "Emission factor (kg CO2e/tonne-km)"])

    calculate_emissions_category_9_method_1(transportation_data)

def get_input_category_10_method_1():
    st.subheader("Method 1: Site-specific Method - Processing of Sold Intermediate Products")
    
    fuel_data = dynamic_input_fields("Fuel", ["Quantity consumed (e.g., liter)", "Life cycle emission factor (kg CO2e/liter)"],
                                     ["Quantity consumed (e.g., liter)", "Life cycle emission factor (kg CO2e/liter)"])

    electricity_data = dynamic_input_fields("Electricity", ["Quantity consumed (e.g., kWh)", "Life cycle emission factor (kg CO2e/kWh)"],
                                            ["Quantity consumed (e.g., kWh)", "Life cycle emission factor (kg CO2e/kWh)"])

    refrigerant_data = dynamic_input_fields("Refrigerant", ["Quantity of leakage (kg)", "Global Warming Potential (kg CO2e/kg)"],
                                            ["Quantity of leakage (kg)", "Global Warming Potential (kg CO2e/kg)"])

    process_emissions = st.number_input("Sum of Process Emissions (kg CO2e)", min_value=0.0, step=0.1)

    include_waste = st.checkbox("Include Waste Emissions (Optional)")
    waste_data = []
    if include_waste:
        waste_data = dynamic_input_fields("Waste", ["Mass of waste output (kg)", "Emission factor (kg CO2e/kg waste)"],
                                          ["Mass of waste output (kg)", "Emission factor (kg CO2e/kg waste)"])

    calculate_emissions_category_10_method_1(fuel_data, electricity_data, refrigerant_data, process_emissions, waste_data)

def calculate_emissions_category_10_method_1(fuel_data, electricity_data, refrigerant_data, process_emissions, waste_data):
    total_fuel_emissions = sum([
        item["Quantity consumed (e.g., liter)"] * item["Life cycle emission factor (kg CO2e/liter)"]
        for item in fuel_data
    ])

    total_electricity_emissions = sum([
        item["Quantity consumed (e.g., kWh)"] * item["Life cycle emission factor (kg CO2e/kWh)"]
        for item in electricity_data
    ])

    total_refrigerant_emissions = sum([
        item["Quantity of leakage (kg)"] * item["Global Warming Potential (kg CO2e/kg)"]
        for item in refrigerant_data
    ])

    total_waste_emissions = 0.0
    if waste_data:
        total_waste_emissions = sum([
            item["Mass of waste output (kg)"] * item["Emission factor (kg CO2e/kg waste)"]
            for item in waste_data
        ])

    total_emissions = total_fuel_emissions + total_electricity_emissions + total_refrigerant_emissions + process_emissions + total_waste_emissions
    st.header(f"Total Emissions from Processing of Sold Intermediate Products (Method 1): {total_emissions} kg CO2e")

def get_input_category_10_method_2():
    st.subheader("Method 2: Average-data Method - Processing of Sold Intermediate Products")
    
    product_data = dynamic_input_fields("Intermediate Product", ["Mass of sold intermediate product (kg)", "Emission factor of processing stages (kg CO2e/kg of final product)"],
                                        ["Mass of sold intermediate product (kg)", "Emission factor of processing stages (kg CO2e/kg of final product)"])

    calculate_emissions_category_10_method_2(product_data)

def calculate_emissions_category_10_method_2(product_data):
    total_emissions = sum([
        item["Mass of sold intermediate product (kg)"] * item["Emission factor of processing stages (kg CO2e/kg of final product)"]
        for item in product_data
    ])
    st.header(f"Total Emissions from Processing of Sold Intermediate Products (Method 2): {total_emissions} kg CO2e")

def get_input_category_11_method_1():
    st.subheader("Method 1: Direct Use-phase Emissions from Products Consuming Energy (Fuels or Electricity) during Use")
    
    product_data = dynamic_input_fields("Product", ["Total lifetime expected uses", "Number sold", 
                                                    "Fuel consumed per use (kWh)", "Emission factor for fuel (kg CO2e/kWh)"],
                                       ["Total lifetime expected uses", "Number sold", 
                                        "Fuel consumed per use (kWh)", "Emission factor for fuel (kg CO2e/kWh)"])

    include_electricity = st.checkbox("Include Electricity Emissions (Optional)")
    electricity_data = []
    if include_electricity:
        electricity_data = dynamic_input_fields("Product Electricity", ["Electricity consumed per use (kWh)", "Emission factor for electricity (kg CO2e/kWh)"],
                                               ["Electricity consumed per use (kWh)", "Emission factor for electricity (kg CO2e/kWh)"])

    refrigerant_data = dynamic_input_fields("Product Refrigerant", ["Refrigerant leakage per use (kg)", "Global Warming Potential (kg CO2e/kg)"],
                                            ["Refrigerant leakage per use (kg)", "Global Warming Potential (kg CO2e/kg)"])

    calculate_emissions_category_11_method_1(product_data, electricity_data, refrigerant_data)

def calculate_emissions_category_11_method_1(product_data, electricity_data, refrigerant_data):
    total_fuel_emissions = sum([
        item["Total lifetime expected uses"] * item["Number sold"] * item["Fuel consumed per use (kWh)"] * item["Emission factor for fuel (kg CO2e/kWh)"]
        for item in product_data
    ])

    total_electricity_emissions = 0.0
    if electricity_data:
        total_electricity_emissions = sum([
            item1["Total lifetime expected uses"] * item1["Number sold"] * item["Electricity consumed per use (kWh)"] * item["Emission factor for electricity (kg CO2e/kWh)"]
            for item in electricity_data for item1 in product_data
        ])

    total_refrigerant_emissions = sum([
        item1["Total lifetime expected uses"] * item1["Number sold"] * item["Refrigerant leakage per use (kg)"] * item["Global Warming Potential (kg CO2e/kg)"]
        for item in refrigerant_data for item1 in product_data
    ])

    total_emissions = total_fuel_emissions + total_electricity_emissions + total_refrigerant_emissions
    st.header(f"Total Emissions from Use of Sold Products (Method 1): {total_emissions} kg CO2e")

def get_input_category_11_method_2():
    st.subheader("Method 2: Direct Use-phase Emissions from Combusted Fuels and Feedstocks")
    
    fuel_data = dynamic_input_fields("Fuel/Feedstock", ["Total quantity sold (e.g., kWh)", "Combustion emission factor (kg CO2e/kWh)"],
                                     ["Total quantity sold (e.g., kWh)", "Combustion emission factor (kg CO2e/kWh)"])

    calculate_emissions_category_11_method_2(fuel_data)

def calculate_emissions_category_11_method_2(fuel_data):
    total_fuel_emissions = sum([
        item["Total quantity sold (e.g., kWh)"] * item["Combustion emission factor (kg CO2e/kWh)"]
        for item in fuel_data
    ])
    st.header(f"Total Emissions from Use of Sold Products (Method 2): {total_fuel_emissions} kg CO2e")

def get_input_category_11_method_3():
    st.subheader("Method 3: Direct Use-phase Emissions from Greenhouse Gases and Products Containing or Forming Greenhouse Gases")
    
    ghg_data = dynamic_input_fields("GHG/Product Group", ["GHG contained per product", "Total Number of products sold",
                                                          "% of GHG released during lifetime use of product", "GWP of the GHG"],
                                    ["GHG contained per product", "Total Number of products sold",
                                     "% of GHG released during lifetime use of product", "GWP of the GHG"])

    calculate_emissions_category_11_method_3(ghg_data)

def calculate_emissions_category_11_method_3(ghg_data):
    total_emissions = sum([
        item["GHG contained per product"] * item["Total Number of products sold"] * 
        item["% of GHG released during lifetime use of product"] * item["GWP of the GHG"]
        for item in ghg_data
    ])
    st.header(f"Total Emissions from Use of Sold Products (Method 3): {total_emissions} kg CO2e")

def get_input_category_11_method_4():
    st.subheader("Method 4: Indirect Use-phase CO2e Emissions of Products")
    
    use_scenario_data = dynamic_input_fields("Use Scenario", ["% of total lifetime uses", "Number sold",
                                                             "Fuel consumed per use (e.g., kWh)", "Emission factor for fuel (e.g., kg CO2e/kWh)"],
                                            ["% of total lifetime uses", "Number sold",
                                             "Fuel consumed per use (e.g., kWh)", "Emission factor for fuel (e.g., kg CO2e/kWh)"])

    include_electricity = st.checkbox("Include Electricity Emissions (Optional)")
    electricity_data = []
    if include_electricity:
        electricity_data = dynamic_input_fields("Use Scenario electricity", ["% of total lifetime uses", "Number sold",
                                                                "Electricity consumed per use (kWh)", "Emission factor for electricity (kg CO2e/kWh)"],
                                               ["% of total lifetime uses", "Number sold",
                                                "Electricity consumed per use (kWh)", "Emission factor for electricity (kg CO2e/kWh)"])

    refrigerant_data = dynamic_input_fields("Use Scenario refrigerant", ["% of total lifetime uses", "Number sold",
                                                             "Refrigerant leakage per use (kg)", "Emission factor for refrigerant (kg CO2e/kg)"],
                                            ["% of total lifetime uses", "Number sold",
                                             "Refrigerant leakage per use (kg)", "Emission factor for refrigerant (kg CO2e/kg)"])

    ghg_data = dynamic_input_fields("Use Scenario ghg data", ["% of total lifetime uses", "Number sold",
                                                     "GHG emitted indirectly (kg)", "GWP of the GHG"],
                                    ["% of total lifetime uses", "Number sold",
                                     "GHG emitted indirectly (kg)", "GWP of the GHG"])

    calculate_emissions_category_11_method_4(use_scenario_data, electricity_data, refrigerant_data, ghg_data)

def calculate_emissions_category_11_method_4(use_scenario_data, electricity_data, refrigerant_data, ghg_data):
    total_fuel_emissions = sum([
        item["% of total lifetime uses"] * item["Number sold"] * item["Fuel consumed per use (e.g., kWh)"] * item["Emission factor for fuel (e.g., kg CO2e/kWh)"]
        for item in use_scenario_data
    ])

    total_electricity_emissions = 0.0
    if electricity_data:
        total_electricity_emissions = sum([
            item["% of total lifetime uses"] * item["Number sold"] * item["Electricity consumed per use (kWh)"] * item["Emission factor for electricity (kg CO2e/kWh)"]
            for item in electricity_data
        ])

    total_refrigerant_emissions = sum([
        item["% of total lifetime uses"] * item["Number sold"] * item["Refrigerant leakage per use (kg)"] * item["Emission factor for refrigerant (kg CO2e/kg)"]
        for item in refrigerant_data
    ])

    total_ghg_emissions = sum([
        item["% of total lifetime uses"] * item["Number sold"] * item["GHG emitted indirectly (kg)"] * item["GWP of the GHG"]
        for item in ghg_data
    ])

    total_emissions = total_fuel_emissions + total_electricity_emissions + total_refrigerant_emissions + total_ghg_emissions
    st.header(f"Total Emissions from Use of Sold Products (Method 4): {total_emissions} kg CO2e")

def get_input_category_11_method_5():
    st.subheader("Method 5: Use-phase CO2e Emissions of Sold Intermediate Products")
    
    intermediate_product_data = dynamic_input_fields("Intermediate Product", ["Total intermediate products sold", 
                                                                             "Total lifetime uses of final sold product",
                                                                             "Emissions per use of sold intermediate product (kg CO2e/use)"],
                                                    ["Total intermediate products sold", 
                                                     "Total lifetime uses of final sold product",
                                                     "Emissions per use of sold intermediate product (kg CO2e/use)"])

    calculate_emissions_category_11_method_5(intermediate_product_data)

def calculate_emissions_category_11_method_5(intermediate_product_data):
    total_emissions = sum([
        item["Total intermediate products sold"] * item["Total lifetime uses of final sold product"] * 
        item["Emissions per use of sold intermediate product (kg CO2e/use)"]
        for item in intermediate_product_data
    ])
    st.header(f"Total Emissions from Use of Sold Products (Method 5): {total_emissions} kg CO2e")

def get_input_category_12_method_1():
    st.subheader("Category 12: End-of-Life Treatment of Sold Products - Method 1: Waste-type-specific method")
    
    waste_data = dynamic_input_fields("Waste Treatment Method", ["Total mass of sold products and packaging (kg)",
                                                                 "Proportion of waste produced (%)",
                                                                 "Emission factor of waste treatment method (kg CO2e/kg)"],
                                     ["Total mass of sold products and packaging (kg)",
                                      "Proportion of waste produced (%)",
                                      "Emission factor of waste treatment method (kg CO2e/kg)"])

    calculate_emissions_category_12_method_1(waste_data)

def calculate_emissions_category_12_method_1(waste_data):
    total_emissions = sum([
        item["Total mass of sold products and packaging (kg)"] * 
        (item["Proportion of waste produced (%)"] / 100) * 
        item["Emission factor of waste treatment method (kg CO2e/kg)"]
        for item in waste_data
    ])
    st.header(f"Total CO2e Emissions from End-of-Life Treatment of Sold Products (Method 1): {total_emissions} kg CO2e")

def get_input_category_13():
    st.subheader("Category 13: Downstream Leased Assets")
    
    leased_assets_data = dynamic_input_fields("Lessee", ["Scope 1 and Scope 2 emissions (kg CO2e)",
                                                        "Physical area of the leased asset (e.g., area, volume)"],
                                             ["Scope 1 and Scope 2 emissions (kg CO2e)",
                                              "Physical area of the leased asset (e.g., area, volume)"])

    calculate_emissions_category_13(leased_assets_data)

def calculate_emissions_category_13(leased_assets_data):
    total_physical_area = calculate_total_physical_area(leased_assets_data)

    total_emissions = sum([
        item["Scope 1 and Scope 2 emissions (kg CO2e)"] * 
        (item["Physical area of the leased asset (e.g., area, volume)"] / total_physical_area) if total_physical_area!=0 else 0 
        for item in leased_assets_data
    ])
    st.header(f"Total CO2e Emissions from Leased Assets (Category 13): {total_emissions} kg CO2e")

def calculate_total_physical_area(leased_assets_data):
    return sum([item["Physical area of the leased asset (e.g., area, volume)"] for item in leased_assets_data])

def get_input_category_14_method_1():
    st.subheader("Category 14: Franchises - Method 1: Franchise-specific method")
    
    franchise_data = dynamic_input_fields("Franchise", ["Scope 1 emissions (kg CO2e)", "Scope 2 emissions (kg CO2e)"],
                                         ["Scope 1 emissions (kg CO2e)", "Scope 2 emissions (kg CO2e)"])

    calculate_emissions_category_14_method_1(franchise_data)

def calculate_emissions_category_14_method_1(franchise_data):
    total_emissions = sum([
        item["Scope 1 emissions (kg CO2e)"] + item["Scope 2 emissions (kg CO2e)"]
        for item in franchise_data
    ])
    st.header(f"Total CO2e Emissions from Franchises (Method 1): {total_emissions} kg CO2e")

def get_input_category_14_method_2():
    st.subheader("Category 14: Franchises - Method 2: Allocating emissions from franchise buildings")
    
    franchise_building_data = dynamic_input_fields("Franchise Building",
                                                   ["Energy use from franchise (kWh)", "Franchise's area (m2)",
                                                    "Building's total area (m2)", "Building's occupancy rate"],
                                                   ["Energy use from franchise (kWh)", "Franchise's area (m2)",
                                                    "Building's total area (m2)", "Building's occupancy rate"])

    calculate_emissions_category_14_method_2(franchise_building_data)

def calculate_emissions_category_14_method_2(franchise_building_data):
    total_emissions = sum([
        item["Energy use from franchise (kWh)"] *
        (item["Franchise's area (m2)"] / item["Building's total area (m2)"] * item["Building's occupancy rate"]) if item["Building's total area (m2)"] * item["Building's occupancy rate"] !=0 else 0
        for item in franchise_building_data
    ])
    st.header(f"Total CO2e Emissions from Franchises (Method 2): {total_emissions} kg CO2e")

def get_input_category_14_method_3():
    st.subheader("Category 14: Franchises - Method 3: Extrapolating emissions from sample groups")
    
    franchise_groups_data = dynamic_input_fields("Franchise Group", ["Total emissions from sampled franchises within group",
                                                                     "Total number of franchises within group",
                                                                     "Number of franchises sampled within group"],
                                                  ["Total emissions from sampled franchises within group",
                                                   "Total number of franchises within group",
                                                   "Number of franchises sampled within group"])

    calculate_emissions_category_14_method_3(franchise_groups_data)

def calculate_emissions_category_14_method_3(franchise_groups_data):
    total_emissions = sum([
        (item["Total emissions from sampled franchises within group"] / item["Total number of franchises within group"]) *
        item["Number of franchises sampled within group"] if item["Total number of franchises within group"]!=0 else 0
        for item in franchise_groups_data
    ])
    st.header(f"Total CO2e Emissions from Franchises (Method 3): {total_emissions} kg CO2e")

def get_input_category_14_method_4():
    st.subheader("Category 14: Franchises - Method 4: Average data method for leased buildings (if floor space data is available)")
    
    building_types_data = dynamic_input_fields("Building Type", ["Total floor space of building type (m2)",
                                                                "Average emission factor for building type (kg CO2e/m2/year)"],
                                              ["Total floor space of building type (m2)",
                                               "Average emission factor for building type (kg CO2e/m2/year)"])

    calculate_emissions_category_14_method_4(building_types_data)

def calculate_emissions_category_14_method_4(building_types_data):
    total_emissions = sum([
        item["Total floor space of building type (m2)"] * item["Average emission factor for building type (kg CO2e/m2/year)"]
        for item in building_types_data
    ])
    st.header(f"Total CO2e Emissions from Franchises (Method 4): {total_emissions} kg CO2e")

def get_input_category_14_method_5():
    st.subheader("Category 14: Franchises - Method 5: Average data method for other asset types or for leased buildings where floor space data is not available")
    
    building_asset_types_data = dynamic_input_fields("Building/Asset Type", ["Number of buildings or assets",
                                                                             "Average emissions per building or asset type per year (kg CO2e/building or asset type/year)"],
                                                    ["Number of buildings or assets",
                                                     "Average emissions per building or asset type per year (kg CO2e/building or asset type/year)"])

    calculate_emissions_category_14_method_5(building_asset_types_data)

def calculate_emissions_category_14_method_5(building_asset_types_data):
    total_emissions = sum([
        item["Number of buildings or assets"] * item["Average emissions per building or asset type per year (kg CO2e/building or asset type/year)"]
        for item in building_asset_types_data
    ])
    st.header(f"Total CO2e Emissions from Franchises (Method 5): {total_emissions} kg CO2e")

def get_input_category_15_method_1():
    st.subheader("Category 15: Investments - Method 1: Investment-specific method for equity investments")
    
    equity_investment_data = dynamic_input_fields("Equity Investment",
                                                 ["Scope 1 and scope 2 emissions of investee company (tonnes CO2e)",
                                                  "Reporting company’s share of equity (%)"],
                                                 ["Scope 1 and scope 2 emissions of investee company (tonnes CO2e)",
                                                  "Reporting company’s share of equity (%)"])

    calculate_emissions_category_15_method_1(equity_investment_data)

def calculate_emissions_category_15_method_1(equity_investment_data):
    total_emissions = sum([
        item["Scope 1 and scope 2 emissions of investee company (tonnes CO2e)"] *
        (item["Reporting company’s share of equity (%)"] / 100)
        for item in equity_investment_data
    ])
    st.header(f"Total CO2e Emissions from Investments (Method 1): {total_emissions} tonnes CO2e")

def get_input_category_15_method_2():
    st.subheader("Category 15: Investments - Method 2: Average data method for equity investments")
    
    equity_investment_average_data = dynamic_input_fields("Equity Investment Average Data",
                                                          ["Investee company total revenue ($)",
                                                           "Emission factor for investee’s sector (kg CO2e/$ revenue)",
                                                           "Reporting company’s share of equity (%)"],
                                                          ["Investee company total revenue ($)",
                                                           "Emission factor for investee’s sector (kg CO2e/$ revenue)",
                                                           "Reporting company’s share of equity (%)"])

    calculate_emissions_category_15_method_2(equity_investment_average_data)

def calculate_emissions_category_15_method_2(equity_investment_average_data):
    total_emissions = sum([
        (item["Investee company total revenue ($)"] * item["Emission factor for investee’s sector (kg CO2e/$ revenue)"]) *
        (item["Reporting company’s share of equity (%)"] / 100)
        for item in equity_investment_average_data
    ])
    st.header(f"Total CO2e Emissions from Investments (Method 2): {total_emissions} tonnes CO2e")

def get_input_category_15_method_3():
    st.subheader("Category 15: Investments - Method 3: Project-specific method for project finance and debt investments")
    
    project_finance_data = dynamic_input_fields("Project Finance",
                                                ["Scope 1 and scope 2 emissions of relevant project (tonnes CO2e)",
                                                 "Value of debt investment ($)", "Total project costs (total equity plus debt) ($)",
                                                 "Share of total project costs (%)"],
                                                ["Scope 1 and scope 2 emissions of relevant project (tonnes CO2e)",
                                                 "Value of debt investment ($)", "Total project costs (total equity plus debt) ($)",
                                                 "Share of total project costs (%)"])

    calculate_emissions_category_15_method_3(project_finance_data)

def calculate_emissions_category_15_method_3(project_finance_data):
    total_emissions = sum([
        item["Scope 1 and scope 2 emissions of relevant project (tonnes CO2e)"] *
        (item["Share of total project costs (%)"] / 100)
        for item in project_finance_data
    ])
    st.header(f"Total CO2e Emissions from Investments (Method 3): {total_emissions} tonnes CO2e")

def get_input_category_15_method_4():
    st.subheader("Category 15: Investments - Method 4: Average-data method for project finance and debt investments")
    
    project_finance_average_data = dynamic_input_fields("Project Finance Average Data",
                                                        ["Project construction cost or project revenue in reporting year ($ million)",
                                                         "Emission factor of relevant construction or operating sector (kg CO2e/$ revenue)",
                                                         "Share of total project costs (value of debt investment / total equity plus debt) (%)"],
                                                        ["Project construction cost or project revenue in reporting year ($ million)",
                                                         "Emission factor of relevant construction or operating sector (kg CO2e/$ revenue)",
                                                         "Share of total project costs (value of debt investment / total equity plus debt) (%)"])

    calculate_emissions_category_15_method_4(project_finance_average_data)

def calculate_emissions_category_15_method_4(project_finance_average_data):
    total_emissions = sum([
        ((item["Project construction cost or project revenue in reporting year ($ million)"] *
          item["Emission factor of relevant construction or operating sector (kg CO2e/$ revenue)"]) *
         item["Share of total project costs (value of debt investment / total equity plus debt) (%)"] / 100)
        for item in project_finance_average_data
    ])
    st.header(f"Total CO2e Emissions from Investments (Method 4): {total_emissions} tonnes CO2e")

def main():
    st.title("CO2 Emission Calculator")
    selected_category = st.selectbox("Select Category", categories)

    if selected_category in ["Category 1", "Category 2"]:
        method_options = ["Supplier Specific Method", "Hybrid Method", "HybridPro Method"]
        method = st.selectbox("Select Method", method_options)

        if method == "Supplier Specific Method":
            st.header("Supplier Specific Method")
            num_items = st.number_input("Number of items", min_value=1, step=1)
            purchased_goods_data = []
            for i in range(num_items):
                goods = st.selectbox(f"Purchased Goods {i + 1}", purchased_goods_values, key=f"goods_{i}")
                supplier = st.selectbox(f"Supplier {i + 1}", supplier_values, key=f"supplier_{i}")
                qty = st.number_input(f"Qty Purchased (kg) {i + 1}", min_value=0.0, step=0.01, key=f"qty_{i}")
                emission_factor = st.number_input(f"Supplier-specific Emission Factor (kg CO2e/kg) {i + 1}", min_value=0.0, step=0.01, key=f"emission_factor_{i}")
                purchased_goods_data.append((goods, supplier, qty, emission_factor))
            calculate_emissions_supplier_specific(purchased_goods_data)

        elif method == "Hybrid Method":
            st.header("Hybrid Method")
            scope1_and_scope2_data = dynamic_input_fields_with_dropdown("Scope 1 and Scope 2 data from supplier B relating to production of purchased goods", "Enter scope 1 and scope 2 data", scope_values, ["Category","Amount (kWh)", "Emission factor (kg CO2e/kWh)"])
            material_inputs_data = dynamic_input_fields_with_dropdown("Material inputs of purchased goods", "Enter material input data", material_inputs_values, ["Purchased Goods", "Mass purchased (kg)", "Emission factor (kg CO2e/kg)"])
            transport_data = dynamic_input_fields_with_dropdown("Transport of material inputs to supplier B", "Enter transport data", transport_values, ["Purchased Goods", "Distance of transport (km)", "Vehicle type emission factor (kg CO2e/kg/km)"])
            waste_output_data = dynamic_input_fields_with_emission_factor("Waste outputs by supplier B relating to production of purchased goods", "Enter waste output data", waste_output_values, ["Amount (kg)", "Emission factor (kg CO2e/kg of waste sent to landfill)"])
            calculate_emissions_hybrid(scope1_and_scope2_data, material_inputs_data, transport_data, waste_output_data)

        elif method == "HybridPro Method":
            scope_data = dynamic_input_fields_with_dropdown("Scope 1 and Scope 2 data from supplier B", "Enter scope data", scope_values, ["Category","Amount (kWh)", "Emission factor (kg CO2e/kWh)"])
            tshirt_data = dynamic_input_fields_with_emission_factor("T-shirts", "Enter T-shirt data", purchased_goods_values,
                                                                    ["Number of t-shirts purchased",
                                                                    "Cradle-to-gate process emission factor (kg CO2e/per t-shirt)","Cradle-to-gate process emission factor (kg CO2e/per t-shirt(excluding scopes)"])
            waste_output_data = dynamic_input_fields_with_emission_factor("Waste outputs by supplier B", "Enter waste output data", waste_output_values,
                                                                        ["Amount (kg)", "Emission factor (kg CO2e/kg of waste sent to landfill)"])
            calculate_emissions_hybrid_pro(tshirt_data, scope_data, waste_output_data)
        
    elif selected_category=="Category 3":
        collect_category_3_data()
    
    elif selected_category == "Category 4":
        method_options = ["Method 1: Fuel-based Method", "Method 2: Unladen Backhaul", "Method 3: Transportation", "Method 4: Distribution", "Method 5: Distribution"]
        selected_method = st.selectbox("Select Method for Category 4", method_options)

        if selected_method == "Method 1: Fuel-based Method":
            collect_category_4_method_1_data()
        elif selected_method == "Method 2: Unladen Backhaul":
            collect_category_4_method_2_data()
        elif selected_method == "Method 3: Transportation":
            collect_category_4_method_3_data()
        elif selected_method == "Method 4: Distribution":
            collect_category_4_method_4_data()
        elif selected_method == "Method 5: Distribution":
            collect_category_4_method_5_data()

    elif selected_category == "Category 5":
        method_options = ["Method 1: Waste Operations using scope", "Method 2: Waste operations using produce", "Method 3: Average Method"]
        selected_method = st.selectbox("Select Method for Category 5", method_options)

        if selected_method == "Method 1: Waste Operations using scope":
            get_input_category_5_method_1()
        elif selected_method == "Method 2: Waste operations using produce":
            get_input_category_5_method_2()
        elif selected_method == "Method 3: Average Method":
            get_input_category_5_method_3()

    elif selected_category == "Category 6":
        get_input_category_6_method_1()
    
    elif selected_category == "Category 7":
        method_options = ["Method 1: Standard method", "Method 2: Average Method"]
        selected_method = st.selectbox("Select Method for Category 7", method_options)
        if selected_method == "Method 1: Standard method":
            get_input_category_7_method_1()
        elif selected_method == "Method 2: Average Method":
            get_input_category_7_method_2()

    elif selected_category == "Category 8":
        method_options = ["Method 1: Asset specific", "Method 2: Leased assets", "Method 3: Average method for leased assets","Method 4: Average method for leased buildings"]
        selected_method = st.selectbox("Select Method for Category 8", method_options)

        if selected_method == "Method 1: Asset specific":
            get_input_category_8_method_1()
        elif selected_method == "Method 2: Leased assets":
            get_input_category_8_method_2()
        elif selected_method == "Method 3: Average method for leased assets":
            get_input_category_8_method_3()
        elif selected_method == "Method 4: Average method for leased buildings":
            get_input_category_8_method_4()
 
    elif selected_category == "Category 9":
        get_input_category_9_method_1()

    elif selected_category == "Category 10":
        method_options = ["Method 1: Site-specific", "Method 2: Average specific"]
        selected_method = st.selectbox("Select Method for Category 10", method_options)

        if selected_method == "Method 1: Site-specific":
            get_input_category_10_method_1()
        elif selected_method == "Method 2: Average specific":
            get_input_category_10_method_2()

    elif selected_category == "Category 11":
        method_options = ["Method 1: Direct energy consumption", "Method 2: Combusted Fuels", "Method 3: Greenhouse gases","Method 4: Indirect use","Method 5: Sold-intermediate products"]
        selected_method = st.selectbox("Select Method for Category 11", method_options)

        if selected_method == "Method 1: Direct energy consumption":
            get_input_category_11_method_1()
        elif selected_method == "Method 2: Combusted Fuels":
            get_input_category_11_method_2()
        elif selected_method == "Method 3: Greenhouse gases":
            get_input_category_11_method_3()
        elif selected_method == "Method 4: Indirect use":
            get_input_category_11_method_4()
        else:
            get_input_category_11_method_5()

    elif selected_category == "Category 12":
        get_input_category_12_method_1()

    elif selected_category == "Category 13":
        get_input_category_13()

    elif selected_category == "Category 14":
        method_options = ["Method 1: Franchise-specific", "Method 2: Allocating emissions from franchise buildings that are not sub-metered", "Method 3: Extrapolating emissions from sample groups","Method 4: Average data method for leased buildings (if floor space data is available)","Method 5: Average data method for other asset types or for leased buildings where floor space data is not available"]
        selected_method = st.selectbox("Select Method for Category 14", method_options)

        if selected_method == "Method 1: Franchise-specific":
            get_input_category_14_method_1()
        elif selected_method == "Method 2: Allocating emissions from franchise buildings that are not sub-metered":
            get_input_category_14_method_2()
        elif selected_method == "Method 3: Extrapolating emissions from sample groups":
            get_input_category_14_method_3()
        elif selected_method == "Method 4: Average data method for leased buildings (if floor space data is available)":
            get_input_category_14_method_4()
        else:
            get_input_category_14_method_5()

    else:
        method_options = ["Method 1: Investment-specific method for calculating emissions from equity investments", "Method 2: Average data method ", "Method 3: Project-specific method for calculating emissions from project finance and debt investments with known use of proceeds","Method 4: Average-data method for calculating emissions from project finance and debt investments with known use of proceeds"]
        selected_method = st.selectbox("Select Method for Category 14", method_options)

        if selected_method == "Method 1: Investment-specific method for calculating emissions from equity investments":
            get_input_category_15_method_1()
        elif selected_method == "Method 2: Average data method ":
            get_input_category_15_method_2()
        elif selected_method == "Method 3: Project-specific method for calculating emissions from project finance and debt investments with known use of proceeds":
            get_input_category_15_method_3()
        elif selected_method == "Method 4: Average-data method for calculating emissions from project finance and debt investments with known use of proceeds":
            get_input_category_15_method_4()

def dynamic_input_fields(label, values, headings, country=None):
    num_items = st.number_input(f"**Number of {label} items**", min_value=1, step=1, key=f"{label}_num_items")
    input_fields = []

    for i in range(num_items):
        st.subheader(f"{label} {i + 1}")
        input_data = {}
        
        if country:
            input_data["Country"] = country

        for value, heading in zip(values, headings):
            key = f"{label}_{i}_{value}_{heading}"
            input_data[value] = st.number_input(f"{heading} {i + 1}", min_value=0.0, step=0.01, key=key)

        input_fields.append(input_data)

    return input_fields

def dynamic_input_fields_with_dropdown(label, prompt, values, headings):
    num_items = st.number_input(f"**Number of {label} items**", min_value=1, step=1, key=f"{label}_num_items")
    input_fields = []
    for i in range(num_items):
        st.subheader(f"{label} {i + 1}")
        input_data = {}
        input_data[headings[0]] = st.selectbox(f"{headings[0]} {i + 1}", values, key=f"{label}_{i}_{headings[0]}")
        for heading in headings[1:]:
            input_data[heading] = st.number_input(f"{heading} {i + 1}", min_value=0.0, step=0.01, key=f"{label}_{i}_{heading}")
        input_fields.append(input_data)
    return input_fields

def dynamic_input_fields_with_emission_factor(label, prompt, values, headings):
    num_items = st.number_input(f"**Number of {label} items**", min_value=1, step=1, key=f"{label}_num_items")
    input_fields = []
    for i in range(num_items):
        st.subheader(f"{label} {i + 1}")
        input_data = {}
        for heading in headings:
            input_data[heading] = st.number_input(f"{heading} {i + 1}", min_value=0.0, step=0.01, key=f"{label}_{i}_{heading}")
        input_fields.append(input_data)
    return input_fields

def dynamic_input_fields_with_dropdown_int(label, prompt, values, headings):
    num_items = st.number_input(f"**Number of {label} items**", min_value=1, step=1, key=f"{label}_num_items")
    input_fields = []

    dropdown_options = {
        "Location": ["US", "Aus"],
        "Car_type": ["Hybrid", "Gasoline", "4 wheel"],

    }

    for i in range(num_items):
        st.subheader(f"{label} {i + 1}")
        input_data = {}

        for j, heading in enumerate(headings):
            if heading in dropdown_options:
                input_data[heading] = st.selectbox(f"{heading} {i + 1}", dropdown_options[heading], key=f"{label}_{i}_{heading}")
            else:
                input_data[heading] = st.number_input(f"{heading} {i + 1}", min_value=0, step=1, key=f"{label}_{i}_{heading}")

        input_fields.append(input_data)

    return input_fields



if __name__ == "__main__":
    main()