app.py

import pandas as pd
import streamlit as st
import matplotlib.pyplot as plt
import numpy as np
from second import double_main
from multiple import multiple_main
from multiple import display_story_points_stats
from jira_integration import render_jira_login, JIRA_SERVER
from weekly import generate_weekly_report
from pre import preprocess_uploaded_file, add_app_description
from multi_env_compare import multi_env_compare_main
import multiple_env_loader



def single_main(uploaded_file):     

    if uploaded_file is not None:
       # Process the file with header
        data = preprocess_uploaded_file(uploaded_file)

       # Display debugging information
        st.write("Data shape:", data.shape)
        st.write("Unique functional areas:", data['Functional area'].nunique())
        st.write("Sample of data:", data.head())

       # Display scenarios with status "failed" grouped by functional area
        failed_scenarios = data[data['Status'] == 'FAILED']
        passed_scenarios = data[data['Status'] == 'PASSED']

        # Display total count of failures
        fail_count = len(failed_scenarios)
        st.markdown(f"Failing scenarios Count: {fail_count}")
        # Display total count of Passing
        pass_count = len(passed_scenarios)
        st.markdown(f"Passing scenarios Count: {pass_count}")

         # Use radio buttons for selecting status
        selected_status = st.radio("Select a status", ['Failed', 'Passed'])

        # Determine which scenarios to display based on selected status
        if selected_status == 'Failed':
            unique_areas = np.append(failed_scenarios['Functional area'].unique(), "All")
            selected_scenarios = failed_scenarios
        elif selected_status == 'Passed':
            unique_areas = np.append(passed_scenarios['Functional area'].unique(), "All")
            selected_scenarios = passed_scenarios
        else:  
            selected_scenarios = None
        
        if selected_scenarios is not None:
            # st.write(f"Scenarios with status '{selected_status}' grouped by functional area:")
            st.markdown(f"### Scenarios with status '{selected_status}' grouped by functional area:")
            
            # Display count of unique functional areas
            # st.write(f"Number of unique functional areas: {len(unique_areas) - 1}")  # Subtract 1 for "All"
            
            # Select a range of functional areas to filter scenarios
            selected_functional_areas = st.multiselect("Select functional areas", unique_areas, ["All"])
           
            if "All" in selected_functional_areas:
                filtered_scenarios = selected_scenarios
            else:
                filtered_scenarios = selected_scenarios[selected_scenarios['Functional area'].isin(selected_functional_areas)]
            
            if not selected_functional_areas:  # Check if the list is empty
                st.error("Please select at least one functional area.")
            else:
                # Display count of filtered scenarios
                st.write(f"Number of filtered scenarios: {len(filtered_scenarios)}")
                
                # Calculate the average time spent for each functional area
                average_time_spent_seconds = filtered_scenarios.groupby('Functional area')['Time spent'].mean().reset_index()

                # Convert average time spent from seconds to minutes and seconds format
                average_time_spent_seconds['Time spent'] = pd.to_datetime(average_time_spent_seconds['Time spent'], unit='s').dt.strftime('%M:%S')

                # Group by functional area and get the start datetime for sorting
                start_datetime_group = filtered_scenarios.groupby('Functional area')['Start datetime'].min().reset_index()

                # Merge average_time_spent_seconds and start_datetime_group
                average_time_spent_seconds = average_time_spent_seconds.merge(start_datetime_group, on='Functional area')

                # Filter scenarios based on selected functional area
                if selected_status == 'Failed':
                    # Check if Failed Step column exists
                    if 'Failed Step' in filtered_scenarios.columns:
                        grouped_filtered_scenarios = filtered_scenarios.groupby('Functional area')[['Scenario Name', 'Error Message', 'Failed Step', 'Time spent(m:s)']].apply(lambda x: x.reset_index(drop=True))
                    else:
                        grouped_filtered_scenarios = filtered_scenarios.groupby('Functional area')[['Scenario Name', 'Error Message', 'Time spent(m:s)']].apply(lambda x: x.reset_index(drop=True))
                elif selected_status == 'Passed':
                    grouped_filtered_scenarios = filtered_scenarios.groupby('Functional area')[['Scenario Name', 'Time spent(m:s)']].apply(lambda x: x.reset_index(drop=True))
                else:  
                    grouped_filtered_scenarios = None

                grouped_filtered_scenarios.reset_index(inplace=True)
                
                # Only drop 'level_1' if it exists in the DataFrame
                if 'level_1' in grouped_filtered_scenarios.columns:
                    grouped_filtered_scenarios.drop(columns=['level_1'], inplace=True)
                
                grouped_filtered_scenarios.index = grouped_filtered_scenarios.index + 1
                st.dataframe(grouped_filtered_scenarios)  
                # Sort the average time spent table by start datetime
                average_time_spent_seconds = average_time_spent_seconds.sort_values(by='Start datetime')

               # Display average time spent on each functional area in a table
                st.markdown("### Average Time Spent on Each Functional Area")
                average_time_spent_seconds.index = average_time_spent_seconds.index + 1
                st.dataframe(average_time_spent_seconds)

                # Check if selected_status is 'Failed' and grouped_filtered_scenarios length is less than or equal to 400
                if selected_status != 'Passed' and len(grouped_filtered_scenarios) <= 400:
                    # Create and display bar graph of errors by functional area
                    st.write(f"### Bar graph showing number of '{selected_status}' scenarios in each functional area:")
                    error_counts = grouped_filtered_scenarios['Functional area'].value_counts()
                    
                    # Only create the graph if there are errors to display
                    if not error_counts.empty:
                        plt.figure(figsize=(10, 6))
                        plt.bar(error_counts.index, error_counts.values)
                        plt.xlabel('Functional Area')
                        plt.ylabel('Number of Failures')
                        plt.title(f"Number of '{selected_status}' scenarios by Functional Area")
                        plt.xticks(rotation=45, ha='right')

                        # Set y-axis limits and ticks for consistent interval of 1
                        y_max = max(error_counts.values) + 1
                        plt.ylim(0, y_max)
                        plt.yticks(range(0, y_max, 1))

                        # Display individual numbers on y-axis
                        for i, count in enumerate(error_counts.values):
                            plt.text(i, count, str(count), ha='center', va='bottom')

                        plt.tight_layout()  # Add this line to adjust layout
                        st.pyplot(plt)
                    else:
                        st.info(f"No '{selected_status}' scenarios found to display in the graph.")
        else:
            st.write("### No scenarios with status 'failed' found.")  
    pass



def main():
    add_app_description()

    # --- Centralized Sidebar Initialization ---
    # Initialize session state for Jira and sprint data if they don't exist
    if 'jira_server' not in st.session_state:
        st.session_state.jira_server = JIRA_SERVER
    if 'is_authenticated' not in st.session_state:
        st.session_state.is_authenticated = False # Start as not authenticated
    if 'jira_client' not in st.session_state:
        st.session_state.jira_client = None
    if 'sprint_data_initialized' not in st.session_state:
        st.session_state.sprint_data_initialized = False
    if 'force_sprint_refresh' not in st.session_state:
        st.session_state.force_sprint_refresh = False
    if 'sprint_data_cache' not in st.session_state:
        st.session_state.sprint_data_cache = None
    if 'last_sprint_fetch' not in st.session_state:
        st.session_state.last_sprint_fetch = None

    # Initialize session state for mode if it doesn't exist
    if "mode" not in st.session_state:
        st.session_state["mode"] = "multi"
    
    # --- Sidebar Rendering --- 
    with st.sidebar:
        # Mode Selection (kept in sidebar)
        selected_mode = st.selectbox(
            "Select Mode", 
            ["Multi", "Compare", "Weekly", "Multi-Env Compare", "Auto Environment Loader"],
            index=["Multi", "Compare", "Weekly", "Multi-Env Compare", "Auto Environment Loader"].index(st.session_state.get("selected_mode", "Multi"))
        )
        # Update the session state with the new selection
        st.session_state["selected_mode"] = selected_mode
        st.session_state["mode"] = selected_mode.lower()
        mode_display = f'## Current mode: {st.session_state["mode"].title()} mode'
        st.markdown(mode_display)

        st.markdown("---") # Separator

        # Jira Login Expander (always shown)
        with st.expander("Jira Integration (Optional)", expanded=True):
            # Render login - function handles checking if already authenticated
            # It updates st.session_state.is_authenticated and st.session_state.jira_client
            st.session_state.is_authenticated = render_jira_login()
            
            # Sprint Progress Expander (shown only if authenticated)
            if st.session_state.is_authenticated and st.session_state.jira_client:
                st.markdown("---") # Separator inside the main expander
                with st.expander("Sprint Progress", expanded=True):
                    # Refresh button
                    if st.button("🔄 Refresh Sprint Data", key="refresh_sprint_sidebar_app"):
                        st.session_state.force_sprint_refresh = True
                    # Always call display (it handles caching), passing manual refresh flag
                    display_story_points_stats(force_refresh=st.session_state.force_sprint_refresh)
                    # Reset manual refresh flag after use
                    st.session_state.force_sprint_refresh = False

    # Initialize session state for the selectbox widget
    if "selected_mode" not in st.session_state:
        st.session_state["selected_mode"] = "Multi"
    
    # --- Main Page Content based on Mode --- 
    if st.session_state["mode"] == "multi":
        multiple_main()
    elif st.session_state["mode"] == "compare":
        st.sidebar.markdown("### Upload Files for Comparison")
        # Move file uploaders to main page area if needed, or keep in sidebar below Jira?
        # For now, keeping in sidebar as it was.
        upload_option = st.sidebar.radio("Upload method", ["Single uploader", "Two separate uploaders"], key="compare_upload_method")
        
        if upload_option == "Single uploader":
            uploaded_files = st.sidebar.file_uploader("Upload CSV or XLSX files for comparison", type=["csv", "xlsx"], accept_multiple_files=True)
            if uploaded_files:
                if len(uploaded_files) < 2:
                    st.warning("Please upload at least two files for comparison.")
                elif len(uploaded_files) > 2:
                    st.warning("More than two files uploaded. Only the first two will be used for comparison.")
                else:
                    with st.spinner('Processing...'):
                        double_main(uploaded_files[0], uploaded_files[1])
                    st.success('Comparison Complete!')
        else:
            col1, col2 = st.sidebar.columns(2)
            with col1:
                uploaded_file1 = st.file_uploader("Upload older CSV/XLSX file", type=["csv", "xlsx"], key="file1")
            with col2:
                uploaded_file2 = st.file_uploader("Upload newer CSV/XLSX file", type=["csv", "xlsx"], key="file2")
            
            if uploaded_file1 is not None and uploaded_file2 is not None:
                with st.spinner('Processing...'):
                    double_main(uploaded_file1, uploaded_file2)
                st.success('Comparison Complete!')
            elif uploaded_file1 is not None or uploaded_file2 is not None:
                st.warning("Please upload both files for comparison.")
    elif st.session_state["mode"] == "weekly":
        uploaded_files = st.sidebar.file_uploader("Upload CSV or XLSX files for Weekly Report", type=["csv", "xlsx"], accept_multiple_files=True)
        if uploaded_files:
            generate_weekly_report(uploaded_files)
    elif st.session_state["mode"] == "multi-env compare":
        multi_env_compare_main()
    elif st.session_state["mode"] == "auto environment loader":
        # Launch the auto environment loader workflow
        multiple_env_loader.main()

if __name__ == "__main__":
    main()