import asyncio
import json
import logging
import os
import tempfile
import time

import uvicorn
from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
from fastapi.responses import JSONResponse

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = FastAPI(
    title="STT GPU Service Python v5 - Minimal",
    description="Minimal Speech-to-Text service for testing",
    version="1.0.0"
)

class ConnectionManager:
    def __init__(self):
        self.active_connections: list[WebSocket] = []
        self.max_connections = 2
    
    async def connect(self, websocket: WebSocket) -> bool:
        if len(self.active_connections) >= self.max_connections:
            return False
        await websocket.accept()
        self.active_connections.append(websocket)
        logger.info(f"WebSocket connected. Active connections: {len(self.active_connections)}")
        return True
    
    def disconnect(self, websocket: WebSocket):
        if websocket in self.active_connections:
            self.active_connections.remove(websocket)
        logger.info(f"WebSocket disconnected. Active connections: {len(self.active_connections)}")

manager = ConnectionManager()

@app.on_event("startup")
async def startup_event():
    """Startup event - minimal setup"""
    logger.info("Starting STT GPU Service Python v5 - Minimal version...")
    logger.info("Model loading will be implemented after successful deployment")

@app.get("/health")
async def health_check():
    """Health check endpoint"""
    return {
        "status": "healthy",
        "model_loaded": False,  # Will be True when model is loaded
        "service": "minimal",
        "active_connections": len(manager.active_connections),
        "max_connections": manager.max_connections,
        "timestamp": time.time()
    }

@app.post("/transcribe")
async def transcribe_file():
    """REST endpoint - placeholder"""
    return JSONResponse(content={
        "message": "Transcription endpoint - model not loaded yet",
        "status": "placeholder",
        "timestamp": time.time()
    })

@app.websocket("/ws/stream")
async def websocket_endpoint(websocket: WebSocket):
    """WebSocket endpoint - placeholder"""
    
    if not await manager.connect(websocket):
        await websocket.close(code=1013, reason="Maximum connections reached")
        return
    
    try:
        await websocket.send_text(json.dumps({
            "type": "connection_established",
            "message": "Connected to minimal STT service",
            "status": "placeholder - model not loaded",
            "timestamp": time.time()
        }))
        
        while True:
            try:
                data = await asyncio.wait_for(websocket.receive_text(), timeout=30)
                
                # Echo back for testing
                response = {
                    "type": "placeholder_response",
                    "message": "Received data, model not loaded yet",
                    "received_length": len(data),
                    "timestamp": time.time()
                }
                
                await websocket.send_text(json.dumps(response))
                
            except asyncio.TimeoutError:
                await websocket.send_text(json.dumps({
                    "type": "keepalive",
                    "timestamp": time.time()
                }))
                
    except WebSocketDisconnect:
        logger.info("WebSocket disconnected normally")
    except Exception as e:
        logger.error(f"WebSocket error: {e}")
    finally:
        manager.disconnect(websocket)

@app.get("/")
async def root():
    """Root endpoint"""
    return {
        "service": "STT GPU Service Python v5 - Minimal",
        "status": "running",
        "model": "not loaded - placeholder version",
        "endpoints": {
            "health": "/health",
            "transcribe": "/transcribe (placeholder)",
            "stream": "/ws/stream (placeholder)"
        },
        "note": "This is a minimal version for testing deployment"
    }

if __name__ == "__main__":
    uvicorn.run(
        "app_minimal:app",
        host="0.0.0.0",
        port=7860,
        log_level="info",
        access_log=True
    )