"""
MY Network - Main Application Entry Point
Точка входа для приложения с поддержкой MY Network
"""

import asyncio
import logging
from pathlib import Path

# Настройка логирования
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

logger = logging.getLogger(__name__)

# Определить режим запуска
def get_app_mode():
    """Определить режим запуска приложения."""
    import os
    
    # Проверить переменные окружения
    if os.getenv('USE_FASTAPI', '').lower() == 'true':
        return 'fastapi'
    
    # Проверить наличие FastAPI зависимостей
    try:
        import fastapi
        import uvicorn
        return 'fastapi'
    except ImportError:
        pass
    
    # Проверить наличие Sanic
    try:
        import sanic
        return 'sanic'
    except ImportError:
        pass
    
    # Fallback к минимальному серверу
    return 'minimal'


def create_fastapi_app():
    """Создать FastAPI приложение с MY Network."""
    try:
        from fastapi import FastAPI
        from fastapi.middleware.cors import CORSMiddleware
        
        app = FastAPI(
            title="MY Network",
            description="Distributed Content Protocol v2.0",
            version="2.0.0"
        )
        
        # CORS middleware
        app.add_middleware(
            CORSMiddleware,
            allow_origins=["*"],
            allow_credentials=True,
            allow_methods=["*"],
            allow_headers=["*"],
        )
        
        # Добавить MY Network маршруты
        try:
            from app.api.routes.my_network_routes import router as my_network_router
            from app.api.routes.monitor_routes import router as monitoring_router
            
            app.include_router(my_network_router)
            app.include_router(monitoring_router)
            
            logger.info("MY Network routes added to FastAPI")
            
        except ImportError as e:
            logger.warning(f"Could not import MY Network routes: {e}")
        
        # Базовые маршруты
        @app.get("/")
        async def root():
            return {"message": "MY Network v2.0 - Distributed Content Protocol"}
        
        @app.get("/health")
        async def health():
            return {"status": "healthy", "service": "MY Network"}
        
        return app
        
    except Exception as e:
        logger.error(f"Failed to create FastAPI app: {e}")
        raise


def create_sanic_app():
    """Создать Sanic приложение с MY Network."""
    try:
        # Импортировать существующее Sanic приложение
        from app.api import create_app
        return create_app()
        
    except Exception as e:
        logger.error(f"Failed to create Sanic app: {e}")
        raise


async def start_my_network_service():
    """Запустить MY Network сервис."""
    try:
        from app.core.my_network.node_service import MyNetworkNodeService
        
        logger.info("Starting MY Network service...")
        
        # Создать и запустить сервис
        node_service = MyNetworkNodeService()
        await node_service.start()
        
        logger.info("MY Network service started successfully")
        
        # Вернуть задачу для поддержания сервиса
        async def keep_service_running():
            try:
                while node_service.is_running:
                    await asyncio.sleep(30)  # Проверять каждые 30 секунд
            except asyncio.CancelledError:
                logger.info("MY Network service shutdown requested")
                await node_service.stop()
                raise
            except Exception as e:
                logger.error(f"MY Network service error: {e}")
                await node_service.stop()
                raise
        
        return keep_service_running()
        
    except ImportError as e:
        logger.info(f"MY Network service not available: {e}")
        return None
    except Exception as e:
        logger.error(f"Failed to start MY Network service: {e}")
        return None


async def run_fastapi_server():
    """Запустить FastAPI сервер."""
    try:
        import uvicorn
        
        # Создать приложение
        app = create_fastapi_app()
        
        # Запустить MY Network сервис в фоне
        my_network_task = await start_my_network_service()
        
        # Конфигурация сервера
        config = uvicorn.Config(
            app,
            host="0.0.0.0",
            port=8000,
            log_level="info"
        )
        
        server = uvicorn.Server(config)
        
        # Запустить сервер и MY Network параллельно
        if my_network_task:
            await asyncio.gather(
                server.serve(),
                my_network_task,
                return_exceptions=True
            )
        else:
            await server.serve()
            
    except Exception as e:
        logger.error(f"FastAPI server error: {e}")
        raise


async def run_sanic_server():
    """Запустить Sanic сервер."""
    try:
        # Создать приложение
        app = create_sanic_app()
        
        # Запустить MY Network сервис в фоне
        my_network_task = await start_my_network_service()
        if my_network_task:
            app.add_background_task(my_network_task)
        
        # Запустить сервер
        await app.create_server(
            host="0.0.0.0",
            port=8000,
            debug=False,
            access_log=True
        )
        
    except Exception as e:
        logger.error(f"Sanic server error: {e}")
        raise


async def run_minimal_server():
    """Запустить минимальный HTTP сервер."""
    try:
        from start_my_network import main as start_minimal
        
        logger.info("Starting minimal MY Network server...")
        start_minimal()
        
    except Exception as e:
        logger.error(f"Minimal server error: {e}")
        raise


async def main():
    """Главная функция запуска."""
    
    print("""
    ╔══════════════════════════════════════════════════════════════════════════════╗
    ║                              MY NETWORK v2.0                                 ║
    ║                        Distributed Content Protocol                          ║
    ║                                                                              ║
    ║  Starting application with MY Network integration...                         ║
    ╚══════════════════════════════════════════════════════════════════════════════╝
    """)
    
    # Определить режим запуска
    app_mode = get_app_mode()
    logger.info(f"Application mode: {app_mode}")
    
    try:
        if app_mode == 'fastapi':
            logger.info("Starting FastAPI server with MY Network...")
            await run_fastapi_server()
            
        elif app_mode == 'sanic':
            logger.info("Starting Sanic server with MY Network...")
            await run_sanic_server()
            
        else:
            logger.info("Starting minimal MY Network server...")
            await run_minimal_server()
            
    except KeyboardInterrupt:
        logger.info("Received keyboard interrupt, shutting down...")
    except Exception as e:
        logger.error(f"Application error: {e}")
        raise


# FastAPI app для ASGI серверов (uvicorn, gunicorn)
try:
    app = create_fastapi_app()
    
    # Добавить startup event для MY Network
    @app.on_event("startup")
    async def startup_event():
        """Startup event для MY Network."""
        my_network_task = await start_my_network_service()
        if my_network_task:
            # Запустить как фоновую задачу
            import asyncio
            asyncio.create_task(my_network_task)
    
except Exception as e:
    logger.warning(f"Could not create FastAPI app instance: {e}")
    app = None


if __name__ == "__main__":
    # Запуск через python app/main.py
    asyncio.run(main())