app.py

import streamlit as st
import pandas as pd
import random
from datetime import datetime, timedelta
import folium
from streamlit_folium import folium_static
import groq

# --- 📂 Load Bus Data ---
data_path = "pdp.csv"
df = pd.read_csv(data_path)

# --- 🔐 Dummy User Credentials ---
USER_CREDENTIALS = {
    "Muthuraja": "virat",
    "Praveen": "dhoni",
    "Pandi": "kabadi",
    "admin": "password123",
    "user": "buspass2025"
}

# --- 🔑 Groq API Key ---
GROQ_API_KEY = "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"
groq.api_key = GROQ_API_KEY


# --- 🔓 Authenticate User ---
def authenticate(username, password):
    """Authenticate user."""
    if username in USER_CREDENTIALS and USER_CREDENTIALS[username] == password:
        return True
    return False


# --- 🔮 Predict Bus Status using Groq API ---
def predict_bus_status(bus_number, city, source_area, destination_area):
    """Predict bus arrival and status with Groq API."""
    prompt = f"Predict the status, route, and arrival time for bus {bus_number} from {source_area} to {destination_area} in {city}."
    try:
        client = groq.Client(api_key=GROQ_API_KEY)
        response = client.chat.completions.create(
            model="llama3-70b-8192",
            messages=[{"role": "system", "content": prompt}]
        )
        return response.choices[0].message.content.strip()
    except Exception as e:
        return f"Error: {e}"


# --- 🕰️ Add Random Delay to Predicted Time ---
def add_random_delay(arrival_time_str):
    """Add 1 to 10 minutes delay to arrival time."""
    try:
        # Handle 'DD-MM-YYYY HH:MM' format
        arrival_time = datetime.strptime(arrival_time_str, "%d-%m-%Y %H:%M")
    except ValueError:
        # Fallback to 'YYYY-MM-DD HH:MM:SS' if needed
        arrival_time = datetime.strptime(arrival_time_str, "%Y-%m-%d %H:%M:%S")

    delay_minutes = random.randint(1, 10)  # Add random delay of 1 to 10 minutes
    new_arrival_time = arrival_time + timedelta(minutes=delay_minutes)
    return new_arrival_time.strftime("%Y-%m-%d %H:%M:%S")


# --- 🚌 Predict Upcoming Bus with Same Route ---
def predict_upcoming_buses(bus_number, city, area_df):
    """Predict upcoming buses on the same route."""
    same_route_df = area_df[area_df["same_route_return"] == bus_number]
    
    if not same_route_df.empty:
        upcoming_buses = []
        for _, row in same_route_df.iterrows():
            upcoming_time = row['upcoming_arrival_time']
            delayed_time = add_random_delay(upcoming_time)
            upcoming_buses.append(f"🚌 Bus {row['upcoming_bus_number']} → {row['bus_route']} arriving at {delayed_time}")
        return "\n".join(upcoming_buses)
    return "⚠️ No upcoming buses available on the same route."


# --- 🗺️ Plot Bus Route Map ---
def plot_bus_route(source_area, destination_area, area_df):
    """Plot bus route between source and destination with real-time location."""
    source_df = area_df[area_df["area"] == source_area]
    dest_df = area_df[area_df["area"] == destination_area]

    if source_df.empty or dest_df.empty:
        st.warning("❌ Invalid source or destination. Please try again.")
        return

    source_lat, source_lon = source_df.iloc[0]["latitude"], source_df.iloc[0]["longitude"]
    dest_lat, dest_lon = dest_df.iloc[0]["latitude"], dest_df.iloc[0]["longitude"]

    m = folium.Map(location=[(source_lat + dest_lat) / 2, (source_lon + dest_lon) / 2], zoom_start=12)

    # Mark Source & Destination
    folium.Marker([source_lat, source_lon], popup=f"🚌 Source: {source_area}", icon=folium.Icon(color="green")).add_to(m)
    folium.Marker([dest_lat, dest_lon], popup=f"🏁 Destination: {destination_area}", icon=folium.Icon(color="red")).add_to(m)

    # Draw Route Line
    folium.PolyLine([(source_lat, source_lon), (dest_lat, dest_lon)], color="blue", weight=5, opacity=0.8).add_to(m)

    folium_static(m)


# --- 🚀 Streamlit App Interface ---
st.title("🚍 Tamil Nadu Bus Tracking & Prediction System")

# --- 🔐 Login System ---
if "authenticated" not in st.session_state:
    st.session_state.authenticated = False

if not st.session_state.authenticated:
    username = st.text_input("Username")
    password = st.text_input("Password", type="password")
    if st.button("Login"):
        if authenticate(username, password):
            st.session_state.authenticated = True
            st.success("✅ Login successful!")
            st.rerun()
        else:
            st.error("❌ Invalid username or password")

# --- 🗺️ Main Content after Login ---
if st.session_state.authenticated:
    st.sidebar.header("🌆 City, Source & Destination Selection")
    
    city = st.sidebar.selectbox("Select City", df["city"].unique())
    area_df = df[df["city"] == city]

    # Select Source & Destination Area
    source_area = st.sidebar.selectbox("Select Source Area", area_df["area"].unique())
    destination_area = st.sidebar.selectbox("Select Destination Area", area_df["area"].unique())

    # --- 🚌 Show Bus Details ---
    st.subheader(f"🚌 Bus Details for Route: {source_area} ➡️ {destination_area} in {city}")
    filtered_df = area_df[(area_df["area"] == source_area) | (area_df["area"] == destination_area)]
    st.dataframe(filtered_df)

    # --- 🗺️ Show Live Route Map ---
    st.subheader("🗺️ Live Bus Route Map")
    plot_bus_route(source_area, destination_area, area_df)

    # --- 🔮 Predict Bus and Same Route Buses ---
    st.subheader("🔮 Bus Prediction & Same Route Upcoming Buses")
    if not filtered_df.empty:
        for _, row in filtered_df.iterrows():
            bus_number = row['bus_number']
            prediction = predict_bus_status(bus_number, city, source_area, destination_area)
            st.success(f"🔮 Prediction for Bus {bus_number}: {prediction}")

            # Predict upcoming buses for same route
            upcoming_buses_info = predict_upcoming_buses(bus_number, city, area_df)
            st.info(upcoming_buses_info)

    # --- 🔓 Logout Option ---
    if st.button("Logout"):
        st.session_state.authenticated = False
        st.rerun()