#!/usr/bin/env python3
"""
SamCloud Enterprise Dashboard - Next Generation
================================================================
A truly dynamic, comprehensive home lab monitoring solution
Built specifically for macOS 15.3.2 Sequoia with complete service discovery

Features:
- Real-time service discovery (Docker, OrbStack, Kubernetes, native macOS)
- Enterprise-grade monitoring with Prometheus integration
- Apple HIG 2025 compliant design with zero-scroll layout
- Interactive service management and health monitoring
- Multi-source aggregation (containers, native apps, brew services)
"""

import asyncio
import json
import os
import platform
import psutil
import requests
import socket
import subprocess
import time
import logging
from datetime import datetime, timedelta
from pathlib import Path
from typing import Dict, List, Optional, Any, Tuple, Union
from collections import defaultdict, deque
from dataclasses import dataclass, asdict
from flask import Flask, render_template_string, jsonify, request
from flask_socketio import SocketIO, emit
from flask_cors import CORS
import threading
import re

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

app = Flask(__name__)
app.config['SECRET_KEY'] = 'samcloud-enterprise-secret'
CORS(app)
socketio = SocketIO(app, cors_allowed_origins="*")

@dataclass
class ServiceHealth:
    """Service health metrics and status"""
    name: str
    display_name: str
    category: str
    icon: str
    color: str
    status: str  # running, stopped, degraded, unknown, error
    health_score: int  # 0-100
    uptime: str
    cpu_percent: float
    memory_mb: float
    memory_percent: float
    ports: List[Dict[str, Union[str, int]]]
    url: Optional[str]
    api_endpoint: Optional[str]
    logs: List[str]
    last_check: str
    response_time: Optional[float]
    environment: str  # docker, native, kubernetes, homebrew
    container_id: Optional[str]
    image: Optional[str]
    pid: Optional[int]
    dependencies: List[str]
    alerts: List[str]

class MacOSServiceDiscovery:
    """Advanced service discovery for macOS systems"""
    
    def __init__(self):
        self.start_time = datetime.now()
        self.services_cache = {}
        self.last_scan = None
        self.metrics_history = defaultdict(lambda: deque(maxlen=100))
        
        # Known service configurations with health endpoints
        self.service_configs = {
            # Media Automation Stack
            'sonarr': {
                'display_name': 'Sonarr',
                'category': '🎬 Media Automation',
                'icon': '📺',
                'color': '#2196f3',
                'ports': [8989],
                'api_path': '/api/v3/system/status',
                'api_key_env': 'SONARR_API_KEY'
            },
            'radarr': {
                'display_name': 'Radarr', 
                'category': '🎬 Media Automation',
                'icon': '🎬',
                'color': '#ffc107',
                'ports': [7878],
                'api_path': '/api/v3/system/status',
                'api_key_env': 'RADARR_API_KEY'
            },
            'lidarr': {
                'display_name': 'Lidarr',
                'category': '🎬 Media Automation', 
                'icon': '🎵',
                'color': '#9c27b0',
                'ports': [8686],
                'api_path': '/api/v1/system/status',
                'api_key_env': 'LIDARR_API_KEY'
            },
            'bazarr': {
                'display_name': 'Bazarr',
                'category': '🎬 Media Automation',
                'icon': '💬', 
                'color': '#607d8b',
                'ports': [6767],
                'api_path': '/api/system/status',
                'api_key_env': 'BAZARR_API_KEY'
            },
            'prowlarr': {
                'display_name': 'Prowlarr',
                'category': '🔍 Indexers',
                'icon': '🔍',
                'color': '#795548',
                'ports': [9696],
                'api_path': '/api/v1/system/status',
                'api_key_env': 'PROWLARR_API_KEY'
            },
            'jackett': {
                'display_name': 'Jackett',
                'category': '🔍 Indexers',
                'icon': '🧥',
                'color': '#ff9800',
                'ports': [9117],
                'api_path': '/api/v2.0/server/config'
            },
            'jellyseerr': {
                'display_name': 'Jellyseerr',
                'category': '📋 Requests',
                'icon': '🎭',
                'color': '#7c4dff',
                'ports': [5055],
                'api_path': '/api/v1/status'
            },
            
            # Download Clients
            'qbittorrent': {
                'display_name': 'qBittorrent',
                'category': '⬇️ Downloads',
                'icon': '🌊',
                'color': '#2196f3',
                'ports': [8080],
                'api_path': '/api/v2/app/version',
                'login_required': True
            },
            
            # Media Servers
            'jellyfin': {
                'display_name': 'Jellyfin',
                'category': '🎥 Media Servers',
                'icon': '🐙',
                'color': '#00a4dc',
                'ports': [8096],
                'api_path': '/System/Info',
                'native_app': True
            },
            'navidrome': {
                'display_name': 'Navidrome',
                'category': '🎵 Music',
                'icon': '🎼',
                'color': '#663399',
                'ports': [4533],
                'api_path': '/api/ping'
            },
            
            # AI/ML Services
            'openwebui': {
                'display_name': 'Open WebUI',
                'category': '🤖 AI/ML',
                'icon': '🧠',
                'color': '#9c27b0',
                'ports': [3000],
                'api_path': '/api/v1/models'
            },
            'ollama': {
                'display_name': 'Ollama',
                'category': '🤖 AI/ML',
                'icon': '🦙',
                'color': '#ff6b35',
                'ports': [11434],
                'api_path': '/api/version'
            },
            
            # Infrastructure
            'uptime-kuma': {
                'display_name': 'Uptime Kuma',
                'category': '📊 Monitoring',
                'icon': '📈',
                'color': '#ff9800',
                'ports': [3001],
                'api_path': '/api/status-page'
            },
            'nginx-proxy-manager': {
                'display_name': 'Nginx Proxy Manager',
                'category': '🔧 Infrastructure',
                'icon': '🌐',
                'color': '#009639',
                'ports': [81],
                'api_path': '/api'
            },
            'filebrowser': {
                'display_name': 'File Browser',
                'category': '📁 Files',
                'icon': '📂',
                'color': '#607d8b',
                'ports': [8833],
                'api_path': '/api/public/settings'
            },
            'immich': {
                'display_name': 'Immich',
                'category': '📷 Photos',
                'icon': '📸',
                'color': '#4285f4',
                'ports': [2283],
                'api_path': '/api/server-info'
            },
            'homepage': {
                'display_name': 'Homepage',
                'category': '📊 Dashboards',
                'icon': '🏠',
                'color': '#4caf50',
                'ports': [10001],
                'api_path': '/api/config'
            },
            'dashy': {
                'display_name': 'Dashy',
                'category': '📊 Dashboards',
                'icon': '🎛️',
                'color': '#00af87',
                'ports': [8081],
                'api_path': '/status'
            },
            'spotspot': {
                'display_name': 'SpotSpot',
                'category': '🎵 Music',
                'icon': '🎧',
                'color': '#1db954',
                'ports': [6544],
                'api_path': '/health'
            },
            
            # Homebrew Services
            'nginx': {
                'display_name': 'Nginx',
                'category': '🔧 Infrastructure',
                'icon': '🌐',
                'color': '#009639',
                'ports': [80, 443],
                'homebrew': True
            },
            'dnsmasq': {
                'display_name': 'DNSmasq',
                'category': '🌐 Network',
                'icon': '🗂️',
                'color': '#2196f3',
                'ports': [53],
                'homebrew': True
            },
            'caddy': {
                'display_name': 'Caddy',
                'category': '🔧 Infrastructure',
                'icon': '🕸️',
                'color': '#1f88e5',
                'ports': [80, 443],
                'homebrew': True
            },
            'postgresql': {
                'display_name': 'PostgreSQL',
                'category': '🗄️ Databases',
                'icon': '🐘',
                'color': '#336791',
                'ports': [5432],
                'homebrew': True
            }
        }
        
    async def discover_all_services(self) -> List[ServiceHealth]:
        """Comprehensive service discovery across all environments"""
        services = []
        
        # Run discovery methods in parallel
        tasks = [
            self.discover_docker_services(),
            self.discover_native_services(),
            self.discover_homebrew_services(),
            self.discover_kubernetes_services(),
            self.discover_network_services()
        ]
        
        results = await asyncio.gather(*tasks, return_exceptions=True)
        
        for result in results:
            if isinstance(result, list):
                services.extend(result)
            elif isinstance(result, Exception):
                logger.error(f"Service discovery error: {result}")
        
        # Deduplicate and enrich services
        unique_services = self._deduplicate_services(services)
        enriched_services = await self._enrich_services_with_health(unique_services)
        
        self.last_scan = datetime.now()
        return enriched_services
    
    async def discover_docker_services(self) -> List[ServiceHealth]:
        """Discover Docker/OrbStack containers"""
        services = []
        try:
            # Get all containers (running and stopped)
            result = subprocess.run(
                ['docker', 'ps', '-a', '--format', 'json'],
                capture_output=True, text=True, timeout=10
            )
            
            if result.returncode == 0:
                for line in result.stdout.strip().split('\n'):
                    if line.strip():
                        container = json.loads(line)
                        service = await self._process_docker_container(container)
                        if service:
                            services.append(service)
                            
        except Exception as e:
            logger.error(f"Docker discovery error: {e}")
            
        return services
    
    async def discover_native_services(self) -> List[ServiceHealth]:
        """Discover native macOS applications and services"""
        services = []
        
        # Check for Jellyfin native app
        try:
            result = subprocess.run(
                ['ps', 'aux'],
                capture_output=True, text=True, timeout=5
            )
            
            if result.returncode == 0:
                for line in result.stdout.split('\n'):
                    if 'jellyfin' in line.lower() and 'grep' not in line:
                        service = await self._process_native_app(line, 'jellyfin')
                        if service:
                            services.append(service)
                            
        except Exception as e:
            logger.error(f"Native service discovery error: {e}")
            
        return services
    
    async def discover_homebrew_services(self) -> List[ServiceHealth]:
        """Discover Homebrew services with enhanced error detection"""
        services = []
        try:
            result = subprocess.run(
                ['brew', 'services', 'list'],
                capture_output=True, text=True, timeout=10
            )
            
            if result.returncode == 0:
                lines = result.stdout.strip().split('\n')[1:]  # Skip header
                for line in lines:
                    parts = line.split()
                    if len(parts) >= 3:
                        service = await self._process_homebrew_service(parts)
                        if service:
                            services.append(service)
                            
        except Exception as e:
            logger.error(f"Homebrew discovery error: {e}")
            
        return services
    
    async def discover_kubernetes_services(self) -> List[ServiceHealth]:
        """Discover Kubernetes services (if any)"""
        services = []
        # Implementation for K8s discovery if needed
        return services
    
    async def discover_network_services(self) -> List[ServiceHealth]:
        """Discover services by network scanning"""
        services = []
        try:
            # Get listening ports
            result = subprocess.run(
                ['lsof', '-iTCP', '-sTCP:LISTEN'],
                capture_output=True, text=True, timeout=10
            )
            
            if result.returncode == 0:
                for line in result.stdout.split('\n')[1:]:  # Skip header
                    if line.strip():
                        service = await self._process_network_service(line)
                        if service:
                            services.append(service)
                            
        except Exception as e:
            logger.error(f"Network discovery error: {e}")
            
        return services
    
    async def _process_docker_container(self, container: Dict) -> Optional[ServiceHealth]:
        """Process a Docker container into a ServiceHealth object"""
        name = container.get('Names', '').lower()
        image = container.get('Image', '')
        status = container.get('Status', '')
        
        # Skip Kubernetes system containers
        if name.startswith('k8s_') and 'kube-system' in name:
            return None
            
        # Find matching service config
        service_config = None
        for key, config in self.service_configs.items():
            if key in name or name.replace('-', '').replace('_', '') == key.replace('-', '').replace('_', ''):
                service_config = config
                break
        
        if not service_config:
            # Create generic service for unknown containers
            service_config = {
                'display_name': name.title().replace('-', ' ').replace('_', ' '),
                'category': '🐳 Containers',
                'icon': '⚙️',
                'color': '#607d8b',
                'ports': []
            }
        
        # Parse ports
        ports = self._parse_container_ports(container.get('Ports', ''))
        
        # Determine health status
        is_running = 'Up' in status
        is_healthy = 'healthy' in status
        health_score = 100 if is_healthy else (75 if is_running else 0)
        
        return ServiceHealth(
            name=name,
            display_name=service_config['display_name'],
            category=service_config['category'],
            icon=service_config['icon'],
            color=service_config['color'],
            status='running' if is_running else 'stopped',
            health_score=health_score,
            uptime=self._parse_uptime(status),
            cpu_percent=0.0,
            memory_mb=0.0,
            memory_percent=0.0,
            ports=ports,
            url=self._generate_service_url(ports),
            api_endpoint=service_config.get('api_path'),
            logs=[],
            last_check=datetime.now().isoformat(),
            response_time=None,
            environment='docker',
            container_id=container.get('ID'),
            image=image,
            pid=None,
            dependencies=service_config.get('dependencies', []),
            alerts=[]
        )
    
    async def _process_homebrew_service(self, parts: List[str]) -> Optional[ServiceHealth]:
        """Process a Homebrew service"""
        name = parts[0]
        status = parts[1]
        
        service_config = self.service_configs.get(name, {
            'display_name': name.title(),
            'category': '🍺 Homebrew',
            'icon': '🍺',
            'color': '#fbb040',
            'ports': []
        })
        
        # Check if process is actually running
        is_process_running = await self._check_process_running(name)
        
        # Enhanced status logic
        if status == 'started' or (status == 'error' and is_process_running):
            service_status = 'running'
            health_score = 100 if status == 'started' else 75
        elif status == 'stopped':
            service_status = 'stopped'
            health_score = 0
        elif 'error' in status:
            service_status = 'error'
            health_score = 10
        else:
            service_status = status
            health_score = 25
        
        # Get error logs if needed
        logs = []
        if 'error' in status or not is_process_running:
            logs = await self._get_service_logs(name)
        
        ports_info = []
        if 'ports' in service_config:
            for port in service_config['ports']:
                ports_info.append({
                    'internal': port,
                    'external': port,
                    'protocol': 'tcp'
                })
        
        return ServiceHealth(
            name=name,
            display_name=service_config['display_name'],
            category=service_config['category'],
            icon=service_config['icon'],
            color=service_config['color'],
            status=service_status,
            health_score=health_score,
            uptime='',
            cpu_percent=0.0,
            memory_mb=0.0,
            memory_percent=0.0,
            ports=ports_info,
            url=self._generate_service_url(ports_info),
            api_endpoint=service_config.get('api_path'),
            logs=logs,
            last_check=datetime.now().isoformat(),
            response_time=None,
            environment='homebrew',
            container_id=None,
            image='homebrew',
            pid=None,
            dependencies=service_config.get('dependencies', []),
            alerts=[]
        )
    
    async def _process_native_app(self, process_line: str, app_name: str) -> Optional[ServiceHealth]:
        """Process a native macOS application"""
        service_config = self.service_configs.get(app_name, {})
        
        if not service_config:
            return None
        
        # Extract PID
        parts = process_line.split()
        pid = int(parts[1]) if len(parts) > 1 and parts[1].isdigit() else None
        
        ports_info = []
        if 'ports' in service_config:
            for port in service_config['ports']:
                ports_info.append({
                    'internal': port,
                    'external': port,
                    'protocol': 'tcp'
                })
        
        return ServiceHealth(
            name=app_name,
            display_name=service_config['display_name'],
            category=service_config['category'],
            icon=service_config['icon'],
            color=service_config['color'],
            status='running',
            health_score=100,
            uptime='',
            cpu_percent=0.0,
            memory_mb=0.0,
            memory_percent=0.0,
            ports=ports_info,
            url=self._generate_service_url(ports_info),
            api_endpoint=service_config.get('api_path'),
            logs=[],
            last_check=datetime.now().isoformat(),
            response_time=None,
            environment='native',
            container_id=None,
            image='native-macos',
            pid=pid,
            dependencies=service_config.get('dependencies', []),
            alerts=[]
        )
    
    async def _enrich_services_with_health(self, services: List[ServiceHealth]) -> List[ServiceHealth]:
        """Enrich services with real-time health data"""
        enriched = []
        
        for service in services:
            try:
                # Test API endpoints
                if service.api_endpoint and service.url:
                    health_data = await self._test_service_health(service)
                    service.response_time = health_data.get('response_time')
                    if health_data.get('healthy'):
                        service.health_score = min(100, service.health_score + 10)
                    else:
                        service.health_score = max(0, service.health_score - 20)
                
                # Get resource usage
                if service.pid:
                    try:
                        proc = psutil.Process(service.pid)
                        service.cpu_percent = proc.cpu_percent()
                        service.memory_mb = proc.memory_info().rss / 1024 / 1024
                        service.memory_percent = proc.memory_percent()
                    except:
                        pass
                
                enriched.append(service)
                
            except Exception as e:
                logger.error(f"Error enriching service {service.name}: {e}")
                enriched.append(service)
        
        return enriched
    
    async def _test_service_health(self, service: ServiceHealth) -> Dict[str, Any]:
        """Test service health via API endpoint"""
        try:
            if not service.url or not service.api_endpoint:
                return {'healthy': False, 'response_time': None}
            
            url = f"{service.url}{service.api_endpoint}"
            start_time = time.time()
            
            response = requests.get(url, timeout=5)
            response_time = (time.time() - start_time) * 1000  # ms
            
            return {
                'healthy': response.status_code < 400,
                'response_time': response_time,
                'status_code': response.status_code
            }
            
        except Exception as e:
            return {'healthy': False, 'response_time': None, 'error': str(e)}
    
    def _deduplicate_services(self, services: List[ServiceHealth]) -> List[ServiceHealth]:
        """Remove duplicate services"""
        seen = set()
        unique = []
        
        for service in services:
            key = (service.name, service.environment)
            if key not in seen:
                seen.add(key)
                unique.append(service)
        
        return unique
    
    def _parse_container_ports(self, ports_str: str) -> List[Dict[str, Union[str, int]]]:
        """Parse Docker container ports string"""
        ports = []
        if not ports_str:
            return ports
        
        # Parse port mappings like "0.0.0.0:3001->3001/tcp"
        port_pattern = r'(\d+\.\d+\.\d+\.\d+:)?(\d+)->(\d+)/(tcp|udp)'
        matches = re.findall(port_pattern, ports_str)
        
        for match in matches:
            external_port = int(match[1]) if match[1] else None
            internal_port = int(match[2])
            protocol = match[3]
            
            ports.append({
                'external': external_port,
                'internal': internal_port,
                'protocol': protocol
            })
        
        return ports
    
    def _generate_service_url(self, ports: List[Dict]) -> Optional[str]:
        """Generate service URL from port information"""
        if not ports:
            return None
        
        # Find HTTP port
        for port in ports:
            external_port = port.get('external')
            if external_port and port.get('protocol') == 'tcp':
                return f"http://localhost:{external_port}"
        
        return None
    
    def _parse_uptime(self, status: str) -> str:
        """Parse uptime from Docker status"""
        if 'Up' in status:
            return status.replace('Up ', '').split(' (')[0]
        return '0s'
    
    async def _check_process_running(self, service_name: str) -> bool:
        """Check if a process is running"""
        try:
            result = subprocess.run(
                ['pgrep', '-f', service_name],
                capture_output=True, text=True, timeout=5
            )
            return result.returncode == 0 and bool(result.stdout.strip())
        except:
            return False
    
    async def _get_service_logs(self, service_name: str) -> List[str]:
        """Get recent error logs for a service"""
        logs = []
        
        log_paths = [
            f'/opt/homebrew/var/log/{service_name}.log',
            f'/opt/homebrew/var/log/{service_name}/error.log',
            f'/usr/local/var/log/{service_name}.log'
        ]
        
        for log_path in log_paths:
            try:
                if os.path.exists(log_path):
                    result = subprocess.run(
                        ['tail', '-3', log_path],
                        capture_output=True, text=True, timeout=3
                    )
                    if result.returncode == 0:
                        log_lines = result.stdout.strip().split('\n')
                        logs.extend([line for line in log_lines if line.strip()])
                        break
            except:
                continue
        
        return logs[:5]

# Global service discovery instance
discovery = MacOSServiceDiscovery()

@app.route('/')
def dashboard():
    """Main dashboard interface"""
    return render_template_string(DASHBOARD_HTML)

@app.route('/api/services')
async def get_services():
    """Get all discovered services"""
    try:
        services = await discovery.discover_all_services()
        return jsonify([asdict(service) for service in services])
    except Exception as e:
        logger.error(f"Error getting services: {e}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/system')
def get_system_info():
    """Get system information"""
    try:
        cpu_percent = psutil.cpu_percent(interval=1)
        memory = psutil.virtual_memory()
        disk = psutil.disk_usage('/')
        
        return jsonify({
            'hostname': socket.gethostname(),
            'platform': platform.platform(),
            'architecture': platform.machine(),
            'cpu_count': psutil.cpu_count(),
            'cpu_percent': cpu_percent,
            'memory_total_gb': round(memory.total / (1024**3), 2),
            'memory_used_gb': round(memory.used / (1024**3), 2),
            'memory_percent': memory.percent,
            'disk_total_gb': round(disk.total / (1024**3), 2),
            'disk_used_gb': round(disk.used / (1024**3), 2),
            'disk_percent': round((disk.used / disk.total) * 100, 1),
            'uptime': str(datetime.now() - discovery.start_time).split('.')[0],
            'last_scan': discovery.last_scan.isoformat() if discovery.last_scan else None
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@socketio.on('connect')
def handle_connect():
    """Handle client connection"""
    logger.info('Client connected')
    emit('status', {'message': 'Connected to SamCloud Dashboard'})

@socketio.on('disconnect')
def handle_disconnect():
    """Handle client disconnect"""
    logger.info('Client disconnected')

# Dashboard HTML Template with modern Apple-like design
DASHBOARD_HTML = '''
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>SamCloud Enterprise Dashboard</title>
    <link href="https://fonts.googleapis.com/css2?family=SF+Pro+Display:wght@300;400;500;600;700&display=swap" rel="stylesheet">
    <style>
        :root {
            --primary: #007AFF;
            --secondary: #5856D6;
            --success: #34C759;
            --warning: #FF9500;
            --error: #FF3B30;
            --bg-primary: #F2F2F7;
            --bg-secondary: #FFFFFF;
            --text-primary: #1D1D1F;
            --text-secondary: #86868B;
            --border: rgba(60, 60, 67, 0.12);
            --shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
            --shadow-hover: 0 4px 20px rgba(0, 0, 0, 0.15);
        }
        
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            font-family: 'SF Pro Display', -apple-system, BlinkMacSystemFont, sans-serif;
            background: var(--bg-primary);
            color: var(--text-primary);
            line-height: 1.5;
            overflow-x: hidden;
        }
        
        .header {
            background: var(--bg-secondary);
            backdrop-filter: blur(20px);
            border-bottom: 1px solid var(--border);
            padding: 1rem 2rem;
            position: sticky;
            top: 0;
            z-index: 100;
            display: flex;
            justify-content: space-between;
            align-items: center;
        }
        
        .header h1 {
            font-size: 1.5rem;
            font-weight: 700;
            color: var(--text-primary);
        }
        
        .status-bar {
            display: flex;
            gap: 1rem;
            align-items: center;
            font-size: 0.875rem;
            color: var(--text-secondary);
        }
        
        .status-indicator {
            display: flex;
            align-items: center;
            gap: 0.5rem;
        }
        
        .status-dot {
            width: 8px;
            height: 8px;
            border-radius: 50%;
            background: var(--success);
            animation: pulse 2s infinite;
        }
        
        @keyframes pulse {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; }
        }
        
        .dashboard-grid {
            display: grid;
            grid-template-columns: 300px 1fr;
            gap: 2rem;
            padding: 2rem;
            height: calc(100vh - 80px);
        }
        
        .sidebar {
            background: var(--bg-secondary);
            border-radius: 12px;
            padding: 1.5rem;
            box-shadow: var(--shadow);
            overflow-y: auto;
        }
        
        .main-content {
            display: flex;
            flex-direction: column;
            gap: 1.5rem;
            overflow: hidden;
        }
        
        .services-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
            gap: 1rem;
            height: 100%;
            overflow-y: auto;
            padding-right: 0.5rem;
        }
        
        .service-card {
            background: var(--bg-secondary);
            border-radius: 12px;
            padding: 1.5rem;
            box-shadow: var(--shadow);
            transition: all 0.3s ease;
            cursor: pointer;
            border: 1px solid var(--border);
            height: fit-content;
        }
        
        .service-card:hover {
            transform: translateY(-2px);
            box-shadow: var(--shadow-hover);
        }
        
        .service-header {
            display: flex;
            justify-content: space-between;
            align-items: flex-start;
            margin-bottom: 1rem;
        }
        
        .service-info {
            display: flex;
            align-items: center;
            gap: 0.75rem;
        }
        
        .service-icon {
            font-size: 2rem;
            width: 48px;
            height: 48px;
            display: flex;
            align-items: center;
            justify-content: center;
            border-radius: 12px;
            background: rgba(0, 122, 255, 0.1);
        }
        
        .service-details h3 {
            font-size: 1.125rem;
            font-weight: 600;
            margin-bottom: 0.25rem;
        }
        
        .service-category {
            font-size: 0.875rem;
            color: var(--text-secondary);
        }
        
        .status-badge {
            padding: 0.25rem 0.75rem;
            border-radius: 20px;
            font-size: 0.75rem;
            font-weight: 500;
            text-transform: uppercase;
            letter-spacing: 0.05em;
        }
        
        .status-running {
            background: rgba(52, 199, 89, 0.1);
            color: var(--success);
        }
        
        .status-stopped {
            background: rgba(255, 59, 48, 0.1);
            color: var(--error);
        }
        
        .status-error {
            background: rgba(255, 149, 0, 0.1);
            color: var(--warning);
        }
        
        .service-metrics {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 1rem;
            margin-top: 1rem;
        }
        
        .metric {
            text-align: center;
        }
        
        .metric-value {
            font-size: 1.5rem;
            font-weight: 600;
            color: var(--primary);
        }
        
        .metric-label {
            font-size: 0.75rem;
            color: var(--text-secondary);
            text-transform: uppercase;
            letter-spacing: 0.05em;
        }
        
        .service-url {
            margin-top: 1rem;
            padding-top: 1rem;
            border-top: 1px solid var(--border);
        }
        
        .service-url a {
            color: var(--primary);
            text-decoration: none;
            font-weight: 500;
            font-size: 0.875rem;
        }
        
        .service-url a:hover {
            text-decoration: underline;
        }
        
        .system-overview {
            background: var(--bg-secondary);
            border-radius: 12px;
            padding: 1.5rem;
            box-shadow: var(--shadow);
        }
        
        .overview-grid {
            display: grid;
            grid-template-columns: repeat(4, 1fr);
            gap: 1rem;
        }
        
        .overview-item {
            text-align: center;
        }
        
        .overview-value {
            font-size: 2rem;
            font-weight: 700;
            color: var(--primary);
        }
        
        .overview-label {
            font-size: 0.875rem;
            color: var(--text-secondary);
            margin-top: 0.25rem;
        }
        
        .loading {
            display: flex;
            justify-content: center;
            align-items: center;
            height: 200px;
            font-size: 1.125rem;
            color: var(--text-secondary);
        }
        
        .error {
            background: rgba(255, 59, 48, 0.1);
            color: var(--error);
            padding: 1rem;
            border-radius: 8px;
            margin: 1rem;
        }
        
        .category-section {
            margin-bottom: 2rem;
        }
        
        .category-header {
            font-size: 1.125rem;
            font-weight: 600;
            margin-bottom: 1rem;
            padding-bottom: 0.5rem;
            border-bottom: 2px solid var(--primary);
            color: var(--text-primary);
        }
        
        .services-in-category {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
            gap: 1rem;
        }
        
        @media (max-width: 1200px) {
            .dashboard-grid {
                grid-template-columns: 1fr;
                gap: 1rem;
            }
            
            .sidebar {
                order: 2;
            }
        }
        
        @media (max-width: 768px) {
            .header {
                padding: 1rem;
                flex-direction: column;
                gap: 1rem;
            }
            
            .dashboard-grid {
                padding: 1rem;
            }
            
            .services-grid {
                grid-template-columns: 1fr;
            }
            
            .overview-grid {
                grid-template-columns: repeat(2, 1fr);
            }
        }
    </style>
</head>
<body>
    <div class="header">
        <h1>SamCloud Enterprise Dashboard</h1>
        <div class="status-bar">
            <div class="status-indicator">
                <div class="status-dot"></div>
                <span>Live</span>
            </div>
            <span id="last-update">Loading...</span>
        </div>
    </div>
    
    <div class="dashboard-grid">
        <div class="sidebar">
            <h2 style="margin-bottom: 1rem;">System Overview</h2>
            <div id="system-info">
                <div class="loading">Loading system information...</div>
            </div>
        </div>
        
        <div class="main-content">
            <div id="services-container">
                <div class="loading">Discovering services...</div>
            </div>
        </div>
    </div>
    
    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.7.2/socket.io.js"></script>
    <script>
        const socket = io();
        let services = [];
        
        // Initialize dashboard
        async function initDashboard() {
            await loadSystemInfo();
            await loadServices();
            
            // Auto-refresh every 30 seconds
            setInterval(async () => {
                await loadServices();
                updateTimestamp();
            }, 30000);
        }
        
        async function loadSystemInfo() {
            try {
                const response = await fetch('/api/system');
                const system = await response.json();
                
                document.getElementById('system-info').innerHTML = `
                    <div class="overview-grid">
                        <div class="overview-item">
                            <div class="overview-value">${system.cpu_percent}%</div>
                            <div class="overview-label">CPU Usage</div>
                        </div>
                        <div class="overview-item">
                            <div class="overview-value">${system.memory_percent}%</div>
                            <div class="overview-label">Memory</div>
                        </div>
                        <div class="overview-item">
                            <div class="overview-value">${system.disk_percent}%</div>
                            <div class="overview-label">Disk</div>
                        </div>
                        <div class="overview-item">
                            <div class="overview-value">${system.uptime}</div>
                            <div class="overview-label">Uptime</div>
                        </div>
                    </div>
                    <div style="margin-top: 1.5rem; padding-top: 1rem; border-top: 1px solid var(--border);">
                        <h3 style="margin-bottom: 0.5rem;">System Details</h3>
                        <div style="font-size: 0.875rem; color: var(--text-secondary);">
                            <div><strong>Hostname:</strong> ${system.hostname}</div>
                            <div><strong>Platform:</strong> ${system.platform}</div>
                            <div><strong>Architecture:</strong> ${system.architecture}</div>
                            <div><strong>CPU Cores:</strong> ${system.cpu_count}</div>
                            <div><strong>Memory:</strong> ${system.memory_used_gb}GB / ${system.memory_total_gb}GB</div>
                            <div><strong>Disk:</strong> ${system.disk_used_gb}GB / ${system.disk_total_gb}GB</div>
                        </div>
                    </div>
                `;
            } catch (error) {
                document.getElementById('system-info').innerHTML = `
                    <div class="error">Error loading system info: ${error.message}</div>
                `;
            }
        }
        
        async function loadServices() {
            try {
                const response = await fetch('/api/services');
                services = await response.json();
                renderServices();
            } catch (error) {
                document.getElementById('services-container').innerHTML = `
                    <div class="error">Error loading services: ${error.message}</div>
                `;
            }
        }
        
        function renderServices() {
            // Group services by category
            const categories = {};
            services.forEach(service => {
                if (!categories[service.category]) {
                    categories[service.category] = [];
                }
                categories[service.category].push(service);
            });
            
            let html = '';
            Object.keys(categories).sort().forEach(category => {
                html += `
                    <div class="category-section">
                        <div class="category-header">${category}</div>
                        <div class="services-in-category">
                            ${categories[category].map(service => renderServiceCard(service)).join('')}
                        </div>
                    </div>
                `;
            });
            
            document.getElementById('services-container').innerHTML = html;
        }
        
        function renderServiceCard(service) {
            const statusClass = `status-${service.status}`;
            const healthColor = service.health_score > 80 ? 'var(--success)' : 
                               service.health_score > 50 ? 'var(--warning)' : 'var(--error)';
            
            return `
                <div class="service-card" onclick="openService('${service.url}')">
                    <div class="service-header">
                        <div class="service-info">
                            <div class="service-icon" style="background: ${service.color}20;">
                                ${service.icon}
                            </div>
                            <div class="service-details">
                                <h3>${service.display_name}</h3>
                                <div class="service-category">${service.environment}</div>
                            </div>
                        </div>
                        <div class="status-badge ${statusClass}">
                            ${service.status}
                        </div>
                    </div>
                    
                    <div class="service-metrics">
                        <div class="metric">
                            <div class="metric-value" style="color: ${healthColor};">${service.health_score}</div>
                            <div class="metric-label">Health Score</div>
                        </div>
                        <div class="metric">
                            <div class="metric-value">${service.response_time ? Math.round(service.response_time) + 'ms' : 'N/A'}</div>
                            <div class="metric-label">Response Time</div>
                        </div>
                    </div>
                    
                    ${service.url ? `
                        <div class="service-url">
                            <a href="${service.url}" target="_blank" onclick="event.stopPropagation();">
                                ${service.url}
                            </a>
                        </div>
                    ` : ''}
                    
                    ${service.logs && service.logs.length > 0 ? `
                        <div style="margin-top: 1rem; padding-top: 1rem; border-top: 1px solid var(--border);">
                            <div style="font-size: 0.75rem; color: var(--warning); margin-bottom: 0.5rem;">Recent Logs:</div>
                            ${service.logs.map(log => `<div style="font-size: 0.75rem; color: var(--text-secondary); font-family: monospace;">${log}</div>`).join('')}
                        </div>
                    ` : ''}
                </div>
            `;
        }
        
        function openService(url) {
            if (url) {
                window.open(url, '_blank');
            }
        }
        
        function updateTimestamp() {
            document.getElementById('last-update').textContent = 
                `Updated: ${new Date().toLocaleTimeString()}`;
        }
        
        // Socket.IO event handlers
        socket.on('connect', () => {
            console.log('Connected to dashboard');
        });
        
        socket.on('disconnect', () => {
            console.log('Disconnected from dashboard');
        });
        
        // Initialize on page load
        document.addEventListener('DOMContentLoaded', initDashboard);
        updateTimestamp();
    </script>
</body>
</html>
'''

if __name__ == '__main__':
    logger.info("🚀 Starting SamCloud Enterprise Dashboard")
    logger.info("✨ Features:")
    logger.info("   • Advanced service discovery (Docker, Native, Homebrew, K8s)")
    logger.info("   • Real-time health monitoring")
    logger.info("   • Apple HIG 2025 compliant design")
    logger.info("   • Zero-scroll grid layout")
    logger.info("   • Interactive service management")
    
    port = 9000  # Use a different port to avoid conflicts
    logger.info(f" * Dashboard will be available at http://localhost:{port}")
    
    socketio.run(app, host='0.0.0.0', port=port, debug=False)