app.py

"""
ADME-Fabric Control Plane
Streamlit application entry point
"""
import streamlit as st
from pathlib import Path
import sys
import os

# Add project root to path
sys.path.insert(0, str(Path(__file__).parent))

from config.logging_config import configure_logging
from database.db import init_database
from components.service_health import render_service_health_compact

# Import settings dynamically to reload from .env
def get_settings():
    """Get fresh settings from .env (reloads on each call)"""
    from config.settings import Settings
    return Settings()

settings = get_settings()
configure_logging(settings.LOG_LEVEL)

# Page configuration
st.set_page_config(
    page_title=settings.APP_NAME,
    page_icon="🔄",
    layout="wide",
    initial_sidebar_state="expanded",
    menu_items={
        "Get Help": "https://github.com/mhadaily/adme-fabric-control-plane",
        "Report a bug": "https://github.com/mhadaily/adme-fabric-control-plane/issues",
        "About": f"# {settings.APP_NAME}\nCreate, publish, and consume ADME data products via Microsoft Fabric"
    }
)

# Initialize database on first run
@st.cache_resource
def setup_database():
    """Initialize database (runs once per session)"""
    init_database()
    return True

@st.cache_resource
def setup_scheduler():
    """Initialize background scheduler (runs once per session)"""
    from services.scheduler_runner import start_scheduler
    start_scheduler()
    return True

setup_database()
setup_scheduler()


def main():
    """Main application entry point"""
    
    # Sidebar navigation
    with st.sidebar:
        st.image("https://img.icons8.com/fluency/96/data-configuration.png", width=80)
        st.title(settings.APP_NAME)
        st.divider()
        
        # Navigation info
        st.caption("Navigate using the pages in the sidebar above ☝️")
        
        st.divider()
        
        # Quick stats
        try:
            from services.connection_service import connection_service
            from services.job_service import job_service
            envs = connection_service.list_environments()
            jobs = job_service.list_jobs(limit=100)
            
            col1, col2 = st.columns(2)
            with col1:
                st.metric("Environments", len(envs))
            with col2:
                st.metric("Data Products", len(jobs))
        except Exception:
            col1, col2 = st.columns(2)
            with col1:
                st.metric("Environments", "0")
            with col2:
                st.metric("Data Products", "0")
        
        # Scheduled jobs quick view
        try:
            from services.scheduler_service import scheduler_service
            active_schedules = scheduler_service.list_scheduled_jobs(status="active")
            if active_schedules:
                st.divider()
                st.caption(f"⏰ **{len(active_schedules)}** active schedule(s)")
                next_job = min(active_schedules, key=lambda x: x.next_run_at if x.next_run_at else float('inf'))
                if next_job and next_job.next_run_at:
                    from datetime import datetime, timezone
                    now = datetime.now(timezone.utc)
                    next_run = next_job.next_run_at
                    if next_run.tzinfo is None:
                        next_run = next_run.replace(tzinfo=timezone.utc)
                    delta = next_run - now
                    if delta.total_seconds() > 0:
                        if delta.total_seconds() < 3600:
                            st.caption(f"Next: {int(delta.total_seconds() / 60)}m")
                        else:
                            st.caption(f"Next: {int(delta.total_seconds() / 3600)}h")
        except Exception:
            pass  # Silent fail if scheduler not ready
        
        st.divider()
        
        # App info
        current_settings = get_settings()  # Reload from .env
        st.caption(f"Version: 1.0.0")
        st.caption(f"Mode: {'🧪 Mock' if current_settings.MOCK_MODE else '🔴 Live'}")
        
        st.divider()
        
        # Service health status
        render_service_health_compact()

    # Main content
    st.title("🏠 ADME-Fabric Control Plane")
    
    st.markdown("""
    ### The Control Plane demonstrates **Create, Publish & Consume** of Data Products
    
    Seamlessly move data between **Azure Data Manager for Energy (ADME)** instances 
    through **Microsoft Fabric Lakehouses**.
    """)
    
    # Data Products overview - the three pillars
    st.subheader("📦 Data Product Lifecycle")
    
    col1, col2, col3 = st.columns(3)
    
    with col1:
        st.success("**📝 Create**\n\nDefine data product definitions by selecting kinds, partitions, and LUCENE queries from your ADME source")
    
    with col2:
        st.info("**🚀 Publish**\n\nExport data products to Fabric Lakehouse via notebooks, ready for sharing across organizations")
    
    with col3:
        st.warning("**📥 Consume**\n\nAccept shared data products and ingest them into your target ADME instance")
    
    st.divider()
    
    # Quick actions
    st.subheader("🚀 Quick Actions")
    
    col1, col2, col3, col4, col5, col6 = st.columns(6)
    
    with col1:
        if st.button("🔗 Connections", use_container_width=True):
            st.switch_page("pages/1_🔗_Connections.py")
    
    with col2:
        if st.button("📝 Create Definition", use_container_width=True, type="primary"):
            st.switch_page("pages/2_📝_Data_Product_Definitions.py")
    
    with col3:
        if st.button("🚀 Publish", use_container_width=True):
            st.switch_page("pages/3_🚀_Publish.py")
    
    with col4:
        if st.button("⏰ Schedules", use_container_width=True):
            st.switch_page("pages/8_⏰_Scheduled_Jobs.py")
    
    with col5:
        if st.button("📥 Consume", use_container_width=True):
            st.switch_page("pages/4_📥_Consume.py")
    
    with col6:
        if st.button("📊 Dashboard", use_container_width=True):
            st.switch_page("pages/5_📊_Dashboard.py")
    
    st.divider()
    
    # Getting started guide
    with st.expander("📖 Getting Started Guide", expanded=True):
        st.markdown("""
        ### Step 1: Configure Connections
        Set up your ADME-Fabric environment pairs in the **Connections** page.
        Each environment links an ADME instance with its associated Fabric workspace.
        
        ### Step 2: Create a Data Product Definition
        Use the **Data Product Definitions** page to define what data to bundle:
        - Select source environment and data partition
        - Choose record types (kinds) to include
        - Apply LUCENE query filters
        
        ### Step 3: Publish Your Data Product
        Use the **Publish** page to export your data to Fabric:
        - Data is exported via ADME Search & Storage APIs
        - Fabric notebooks process and store the data
        - Results are saved to Delta Lake tables
        
        ### Step 4: Consume Data Products
        Use the **Consume** page to ingest shared data:
        - Create external data shares for your published products
        - Accept shares from other organizations
        - Pull data into your target ADME instance
        
        ### Step 5: Monitor Progress
        Track your data products on the **Dashboard**:
        - View active publishing jobs
        - Monitor logs and API calls
        - Check for errors
        """)
    
    # Recent activity - show actual data products
    st.subheader("📈 Recent Activity")
    
    try:
        from services.job_service import job_service
        from database.models import JobStatus
        
        # Get recent jobs
        recent_jobs = job_service.list_jobs(limit=5)
        
        if recent_jobs:
            # Show data products first
            st.markdown("**Recent Data Products:**")
            for job in recent_jobs[:5]:
                status_icons = {
                    "pending": "⏳",
                    "running": "🔄",
                    "completed": "✅",
                    "failed": "❌",
                    "partial": "⚠️",
                    "cancelled": "🚫",
                }
                icon = status_icons.get(str(job.status).lower(), "❓")
                
                col1, col2, col3 = st.columns([3, 1, 1])
                with col1:
                    st.markdown(f"{icon} **{job.name}** - {job.kind[:30] if job.kind else 'N/A'}...")
                with col2:
                    st.caption(f"{job.records_exported or 0} records")
                with col3:
                    created = job.created_at.strftime("%m/%d %H:%M") if job.created_at else "Unknown"
                    st.caption(created)
        else:
            st.info("No recent activity. Start by creating your first data product definition!")
    except Exception as e:
        st.info("No recent activity. Start by creating your first data product definition!")


if __name__ == "__main__":
    main()