streamlitplot.py

import streamlit as st
import pandas as pd
import plotly.graph_objects as go
import plotly.express as px
from datetime import datetime
import time
import json

# Import your main classes (assuming they're in production_twin.py)
# from production_twin import ProductionLine, IntelligentAnalyzer

# For this demo, we'll include simplified versions here
# You can import from your main file once it's saved

st.set_page_config(
    page_title="Production Line Digital Twin",
    page_icon="🏭",
    layout="wide"
)

# Initialize session state
if 'production_line' not in st.session_state:
    st.session_state.production_line = None
    st.session_state.analyzer = None
    st.session_state.simulation_running = False

def main():
    st.title("🏭 AI-Powered Production Line Digital Twin")
    st.markdown("*Intelligent Manufacturing Monitoring & Analysis*")
    
    # Sidebar controls
    with st.sidebar:
        st.header("⚙️ Control Panel")
        
        # Simulation controls
        num_machines = st.slider("Number of Machines", 3, 10, 5)
        simulation_duration = st.slider("Simulation Duration", 10, 200, 50)
        
        if st.button("🚀 Start New Simulation", type="primary"):
            with st.spinner("Initializing production line..."):
                # Import here to avoid issues if file doesn't exist yet
                try:
                    from production_twin import ProductionLine, IntelligentAnalyzer
                    st.session_state.production_line = ProductionLine(num_machines=num_machines)
                    st.session_state.analyzer = IntelligentAnalyzer(st.session_state.production_line)
                    
                    # Run simulation
                    st.session_state.production_line.start_production(duration=simulation_duration)
                    st.session_state.simulation_running = True
                    st.success("✅ Simulation completed!")
                    st.rerun()
                except ImportError:
                    st.error("Please make sure production_twin.py is in the same directory!")
                except Exception as e:
                    st.error(f"Error: {str(e)}")
        
        if st.button("🔄 Refresh Data"):
            if st.session_state.production_line:
                st.rerun()
    
    # Main content
    if not st.session_state.simulation_running:
        st.info("👆 Start a simulation using the control panel to begin monitoring!")
        
        # Show demo info
        st.subheader("🎯 Project Features")
        col1, col2, col3 = st.columns(3)
        
        with col1:
            st.markdown("""
            **🤖 Intelligent Analysis**
            - Real-time anomaly detection
            - Predictive maintenance alerts
            - Performance optimization suggestions
            """)
        
        with col2:
            st.markdown("""
            **📊 Advanced Monitoring**
            - Multi-machine dashboard
            - Historical trend analysis
            - Quality control metrics
            """)
        
        with col3:
            st.markdown("""
            **💬 Natural Language Interface**
            - Ask questions in plain English
            - Get detailed explanations
            - Interactive troubleshooting
            """)
        
        return
    
    # Dashboard tabs
    tab1, tab2, tab3, tab4 = st.tabs(["📊 Dashboard", "🤖 AI Assistant", "📈 Analytics", "🔧 Maintenance"])
    
    with tab1:
        show_dashboard()
    
    with tab2:
        show_ai_assistant()
    
    with tab3:
        show_analytics()
    
    with tab4:
        show_maintenance()

def show_dashboard():
    st.header("📊 Real-Time Production Dashboard")
    
    if not st.session_state.production_line:
        st.warning("No simulation running!")
        return
    
    # Get current status
    status = st.session_state.production_line.get_current_status()
    analysis = st.session_state.production_line.analyze_performance()
    
    # Key metrics row
    col1, col2, col3, col4 = st.columns(4)
    
    with col1:
        total_production = analysis["overview"]["total_production"]
        st.metric("Total Production", f"{total_production:,}", delta="units")
    
    with col2:
        avg_efficiency = analysis["overview"]["average_efficiency"]
        st.metric("Average Efficiency", avg_efficiency, delta=None)
    
    with col3:
        avg_quality = analysis["overview"]["average_quality"]
        st.metric("Average Quality", avg_quality, delta=None)
    
    with col4:
        issues = analysis["overview"]["machines_with_issues"]
        st.metric("Machines with Issues", issues, delta=None)
    
    st.divider()
    
    # Machine status grid
    st.subheader("🏭 Machine Status Overview")
    
    machines_data = []
    for machine_id, machine_status in status["machines"].items():
        machines_data.append({
            "Machine": machine_id,
            "Status": machine_status["status"],
            "Efficiency": machine_status["efficiency"],
            "Temperature": machine_status["temperature"],
            "Quality": machine_status["quality_score"],
            "Output": machine_status["output_count"]
        })
    
    df_machines = pd.DataFrame(machines_data)
    
    # Color-code the status
    def style_status(val):
        color = 'green' if val == 'running' else 'red'
        return f'color: {color}'
    
    styled_df = df_machines.style.applymap(style_status, subset=['Status'])
    st.dataframe(styled_df, use_container_width=True)
    
    # Efficiency chart
    col1, col2 = st.columns(2)
    
    with col1:
        fig_efficiency = px.bar(
            df_machines, 
            x="Machine", 
            y="Efficiency",
            title="Machine Efficiency Comparison",
            color="Efficiency",
            color_continuous_scale="RdYlGn"
        )
        fig_efficiency.update_layout(showlegend=False)
        st.plotly_chart(fig_efficiency, use_container_width=True)
    
    with col2:
        fig_temp = px.bar(
            df_machines,
            x="Machine",
            y="Temperature", 
            title="Temperature Monitoring",
            color="Temperature",
            color_continuous_scale="Reds"
        )
        fig_temp.update_layout(showlegend=False)
        st.plotly_chart(fig_temp, use_container_width=True)

def show_ai_assistant():
    st.header("🤖 AI Production Assistant")
    st.markdown("*Ask me anything about your production line!*")
    
    if not st.session_state.analyzer:
        st.warning("No simulation running!")
        return
    
    # AI Insights
    with st.expander("💡 Current AI Insights", expanded=True):
        insights = st.session_state.analyzer.generate_insights()
        for insight in insights:
            st.markdown(f"• {insight}")
    
    st.divider()
    
    # Question & Answer Interface
    st.subheader("💬 Ask the AI Assistant")
    
    # Pre-defined quick questions
    st.markdown("**Quick Questions:**")
    col1, col2, col3 = st.columns(3)
    
    with col1:
        if st.button("What's the current efficiency?"):
            answer = st.session_state.analyzer.answer_question("What's the current efficiency?")
            st.info(answer)
    
    with col2:
        if st.button("Any temperature issues?"):
            answer = st.session_state.analyzer.answer_question("Are there any temperature problems?")
            st.info(answer)
    
    with col3:
        if st.button("How's the quality?"):
            answer = st.session_state.analyzer.answer_question("How is the quality?")
            st.info(answer)
    
    # Custom question input
    st.markdown("**Ask a Custom Question:**")
    user_question = st.text_input("Type your question here...")
    
    if st.button("Get Answer") and user_question:
        with st.spinner("AI is analyzing..."):
            answer = st.session_state.analyzer.answer_question(user_question)
            st.success(f"🤖 **AI Response:** {answer}")
    
    # Chat history (simplified)
    if 'chat_history' not in st.session_state:
        st.session_state.chat_history = []
    
    if user_question and st.button("💾 Save to Chat History"):
        answer = st.session_state.analyzer.answer_question(user_question)
        st.session_state.chat_history.append({
            "question": user_question,
            "answer": answer,
            "timestamp": datetime.now().strftime("%H:%M:%S")
        })
        st.rerun()
    
    if st.session_state.chat_history:
        st.subheader("📝 Chat History")
        for i, chat in enumerate(reversed(st.session_state.chat_history[-5:])):  # Show last 5
            with st.expander(f"[{chat['timestamp']}] {chat['question'][:50]}..."):
                st.markdown(f"**Q:** {chat['question']}")
                st.markdown(f"**A:** {chat['answer']}")

def show_analytics():
    st.header("📈 Advanced Analytics")
    
    if not st.session_state.production_line:
        st.warning("No simulation running!")
        return
    
    # Get metrics dataframe
    df = st.session_state.production_line.get_metrics_dataframe()
    
    if df.empty:
        st.info("No metrics data available yet.")
        return
    
    # Time series charts
    st.subheader("⏱️ Performance Over Time")
    
    # Convert timestamp to datetime if it's not already
    if 'timestamp' in df.columns:
        df['timestamp'] = pd.to_datetime(df['timestamp'])
    
    col1, col2 = st.columns(2)
    
    with col1:
        fig_efficiency_time = px.line(
            df, 
            x='timestamp', 
            y='efficiency', 
            color='machine_id',
            title='Efficiency Trends Over Time'
        )
        st.plotly_chart(fig_efficiency_time, use_container_width=True)
    
    with col2:
        fig_quality_time = px.line(
            df,
            x='timestamp',
            y='quality_score',
            color='machine_id', 
            title='Quality Score Trends'
        )
        st.plotly_chart(fig_quality_time, use_container_width=True)
    
    # Correlation analysis
    st.subheader("🔗 Performance Correlations")
    
    numeric_cols = ['efficiency', 'temperature', 'vibration', 'quality_score']
    correlation_matrix = df[numeric_cols].corr()
    
    fig_corr = px.imshow(
        correlation_matrix,
        title="Correlation Matrix: Performance Metrics",
        color_continuous_scale="RdBu"
    )
    st.plotly_chart(fig_corr, use_container_width=True)
    
    # Statistical summary
    st.subheader("📊 Statistical Summary")
    st.dataframe(df[numeric_cols].describe(), use_container_width=True)

def show_maintenance():
    st.header("🔧 Predictive Maintenance")
    
    if not st.session_state.production_line:
        st.warning("No simulation running!")
        return
    
    analysis = st.session_state.production_line.analyze_performance()
    
    # Maintenance alerts
    st.subheader("⚠️ Maintenance Alerts")
    
    col1, col2 = st.columns(2)
    
    with col1:
        st.markdown("**🌡️ Temperature Alerts**")
        temp_alerts = analysis["trends"]["temperature_alerts"]
        if temp_alerts:
            for machine in temp_alerts:
                st.error(f"🔥 {machine}: Overheating detected!")
        else:
            st.success("✅ All temperatures normal")
    
    with col2:
        st.markdown("**🔧 Vibration Alerts**")
        vib_alerts = analysis["trends"]["vibration_alerts"]
        if vib_alerts:
            for machine in vib_alerts:
                st.warning(f"⚡ {machine}: High vibration!")
        else:
            st.success("✅ All vibrations normal")
    
    # Maintenance schedule suggestions
    st.subheader("📅 Suggested Maintenance Schedule")
    
    maintenance_suggestions = []
    
    for machine_id, perf in analysis["machine_performance"].items():
        efficiency = float(perf["current_efficiency"].replace("%", ""))
        temp = float(perf["current_temperature"].replace("°C", ""))
        
        priority = "Low"
        action = "Regular inspection"
        
        if efficiency < 80:
            priority = "High"
            action = "Immediate maintenance required"
        elif temp > 50:
            priority = "Medium"
            action = "Cooling system check"
        
        maintenance_suggestions.append({
            "Machine": machine_id,
            "Priority": priority,
            "Action": action,
            "Current Efficiency": perf["current_efficiency"],
            "Status": perf["status"]
        })
    
    df_maintenance = pd.DataFrame(maintenance_suggestions)
    
    # Color code by priority
    def highlight_priority(val):
        if val == "High":
            return "background-color: #ffcccc"
        elif val == "Medium":
            return "background-color: #ffffcc"
        else:
            return "background-color: #ccffcc"
    
    styled_maintenance = df_maintenance.style.applymap(
        highlight_priority, 
        subset=['Priority']
    )
    
    st.dataframe(styled_maintenance, use_container_width=True)

if __name__ == "__main__":
    main()