import asyncio
from contextlib import asynccontextmanager
from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.staticfiles import StaticFiles
from fastapi.responses import FileResponse
from pathlib import Path
import time

from server.logger import logger
from server.websocket_manager import WebSocketManager
from server.game_state import GameState
from server.economy import EconomyEngine
from server.database import Database

# Global instances
game_state = GameState()
ws_manager = WebSocketManager(game_state)
economy_engine = EconomyEngine(game_state)
database = Database()

TICK_INTERVAL = 10  # seconds

# --- FIX: Reverting to a simple, reliable 10-second loop ---
async def economy_loop():
    """A simple loop that runs the economy tick every 10 seconds."""
    while True:
        await asyncio.sleep(TICK_INTERVAL)
        
        logger.info("Triggering scheduled economy tick.")
        start_time = time.perf_counter()

        # 1. Process one economy tick
        economy_engine.tick()
        
        # 2. Broadcast updates concurrently
        update_tasks = []
        for player_id, player in game_state.players.items():
            if player_id in ws_manager.active_connections:
                task = ws_manager.send_to_player(player_id, {
                    "type": "player_stats_update",
                    "player": player.to_dict()
                })
                update_tasks.append(task)
        
        if update_tasks:
            await asyncio.gather(*update_tasks)
        
        # 3. Save the new state
        database.save_game_state(game_state)
        
        duration = time.perf_counter() - start_time
        logger.info(f"Economy tick cycle completed in {duration:.4f} seconds.")

@asynccontextmanager
async def lifespan(app: FastAPI):
    """Startup and shutdown events."""
    logger.info("Server starting up...")
    database.init_db()
    game_state.load_state(database.load_game_state())
    
    # Start the simple economy loop
    task = asyncio.create_task(economy_loop())
    logger.info(f"Economy loop started with a {TICK_INTERVAL}-second interval.")
    
    yield
    
    logger.info("Server shutting down...")
    task.cancel()
    database.save_game_state(game_state)
    logger.info("Final game state saved.")

app = FastAPI(lifespan=lifespan)

app.mount("/static", StaticFiles(directory="static"), name="static")

@app.get("/")
async def root():
    return FileResponse("static/index.html")

@app.websocket("/ws/{nickname}")
async def websocket_endpoint(websocket: WebSocket, nickname: str):
    await ws_manager.connect(websocket, nickname)
    try:
        player_id = await ws_manager.get_player_id(websocket)
        if player_id:
            player = game_state.get_or_create_player(nickname, player_id)
            await websocket.send_json({
                "type": "init",
                "player": player.to_dict(),
                "game_state": game_state.get_state()
            })
            while True:
                data = await websocket.receive_json()
                await handle_message(websocket, data)
    except WebSocketDisconnect:
        await ws_manager.disconnect(websocket)
    except Exception as e:
        player_id = await ws_manager.get_player_id(websocket)
        logger.error(f"An error occurred in the websocket endpoint for player {player_id}: {e}", exc_info=True)


async def handle_message(websocket: WebSocket, data: dict):
    """Handle incoming WebSocket messages."""
    msg_type = data.get("type")
    player_id = await ws_manager.get_player_id(websocket)

    if not player_id:
        logger.warning("Received message from an unknown player, ignoring.")
        return

    logger.debug(f"Received '{msg_type}' from player {player_id}")
    
    if msg_type == "cursor_move":
        await ws_manager.broadcast({"type": "cursor_move", "player_id": player_id, "x": data["x"], "y": data["y"]}, exclude=websocket)
    
    elif msg_type == "place_building":
        result = game_state.place_building(player_id, data["building_type"], data["x"], data["y"])
        if result["success"]:
            await ws_manager.broadcast({"type": "building_placed", "building": result["building"]})
            # --- CHANGE: Action now only saves, economy is handled by the loop ---
            database.save_game_state(game_state)
        else:
            await websocket.send_json({"type": "error", "message": result["error"]})
    
    elif msg_type == "remove_building":
        result = game_state.remove_building(player_id, data["x"], data["y"])
        if result["success"]:
            await ws_manager.broadcast({"type": "building_removed", "x": data["x"], "y": data["y"]})
            # --- CHANGE: Action now only saves, economy is handled by the loop ---
            database.save_game_state(game_state)
        else:
            await websocket.send_json({"type": "error", "message": result["error"]})

    elif msg_type == "edit_building":
        result = game_state.edit_building_name(player_id, data["x"], data["y"], data["name"])
        if result["success"]:
            await ws_manager.broadcast({"type": "building_updated", "x": data["x"], "y": data["y"], "name": data["name"]})
            database.save_game_state(game_state)
    
    elif msg_type == "chat":
        nickname = await ws_manager.get_nickname(websocket)
        await ws_manager.broadcast({"type": "chat", "nickname": nickname, "message": data["message"], "timestamp": data["timestamp"]})