app/services/brigade_simulator.py

# app/services/brigade_simulator.py - YANGI FAYL YARATING

"""

Brigade Simulator - Brigadalarning harakatini simulyatsiya qilish

Real-time koordinatalarni yangilash (A nuqtadan B nuqtaga)

"""

import random
import math
import asyncio
import logging
from typing import Dict, Tuple, Optional
from datetime import datetime

logger = logging.getLogger(__name__)

# Toshkent chegaralari
TASHKENT_BOUNDS = {
    "lat_min": 41.20,
    "lat_max": 41.35,
    "lon_min": 69.10,
    "lon_max": 69.35
}


def haversine_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    """

    Ikki nuqta orasidagi masofa (km)

    

    Returns:

        float: Masofa kilometrlarda

    """
    R = 6371  # Yer radiusi (km)
    
    lat1_rad = math.radians(lat1)
    lat2_rad = math.radians(lat2)
    delta_lat = math.radians(lat2 - lat1)
    delta_lon = math.radians(lon2 - lon1)
    
    a = math.sin(delta_lat / 2) ** 2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(delta_lon / 2) ** 2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
    
    return R * c


def calculate_new_position(

    current_lat: float,

    current_lon: float,

    target_lat: float,

    target_lon: float,

    speed_kmh: float = 60,

    time_step_seconds: int = 3

) -> Tuple[float, float]:
    """

    Yangi pozitsiyani hisoblash (A dan B ga)

    

    Args:

        current_lat: Joriy lat

        current_lon: Joriy lon

        target_lat: Maqsad lat

        target_lon: Maqsad lon

        speed_kmh: Tezlik (km/soat)

        time_step_seconds: Vaqt qadami (sekund)

    

    Returns:

        Tuple[float, float]: Yangi (lat, lon)

    """
    # Maqsadga yetgan bo'lsa
    distance = haversine_distance(current_lat, current_lon, target_lat, target_lon)
    
    if distance < 0.05:  # 50 metr
        return target_lat, target_lon
    
    # Harakat masofasi (km)
    distance_step = (speed_kmh / 3600) * time_step_seconds
    
    # Agar bir qadamda yetib borsa
    if distance_step >= distance:
        return target_lat, target_lon
    
    # Yo'nalish (bearing)
    fraction = distance_step / distance
    
    new_lat = current_lat + (target_lat - current_lat) * fraction
    new_lon = current_lon + (target_lon - current_lon) * fraction
    
    return new_lat, new_lon


def generate_random_target() -> Tuple[float, float]:
    """

    Tasodifiy maqsad nuqta (Toshkent ichida)

    

    Returns:

        Tuple[float, float]: (lat, lon)

    """
    lat = random.uniform(TASHKENT_BOUNDS["lat_min"], TASHKENT_BOUNDS["lat_max"])
    lon = random.uniform(TASHKENT_BOUNDS["lon_min"], TASHKENT_BOUNDS["lon_max"])
    
    return lat, lon


class BrigadeSimulator:
    """Brigade simulyatori - koordinatalarni yangilash"""
    
    def __init__(self, db):
        self.db = db
        self.is_running = False
        self.update_interval = 3  # 3 sekund
    
    async def start(self):
        """Simulyatorni ishga tushirish"""
        self.is_running = True
        logger.info("🚑 Brigade simulator ishga tushdi")
        
        while self.is_running:
            try:
                await self.update_all_brigades()
                await asyncio.sleep(self.update_interval)
            except Exception as e:
                logger.error(f"❌ Brigade simulator xatolik: {e}")
                await asyncio.sleep(5)
    
    def stop(self):
        """Simulyatorni to'xtatish"""
        self.is_running = False
        logger.info("🛑 Brigade simulator to'xtatildi")
    
    async def update_all_brigades(self):
        """Barcha brigadalarni yangilash"""
        from app.services.brigade_matcher import load_brigades
        
        brigades = load_brigades()
        
        for brigade in brigades:
            if brigade.get("current_status") == "busy":
                self.update_brigade_position(brigade)
    
    def update_brigade_position(self, brigade: Dict):
        """Bitta brigadaning pozitsiyasini yangilash"""
        brigade_id = brigade.get("brigade_id")
        
        # Joriy va maqsad koordinatalar
        current_lat = brigade.get("current_lat", brigade.get("base_lat"))
        current_lon = brigade.get("current_lon", brigade.get("base_lon"))
        target_lat = brigade.get("target_lat")
        target_lon = brigade.get("target_lon")
        
        # Agar maqsad yo'q bo'lsa, yangi maqsad yaratish
        if not target_lat or not target_lon:
            target_lat, target_lon = generate_random_target()
            self.db.update_brigade(brigade_id, {
                "target_lat": target_lat,
                "target_lon": target_lon
            })
        
        # Yangi pozitsiya hisoblash
        speed = brigade.get("speed_kmh", 60)
        new_lat, new_lon = calculate_new_position(
            current_lat, current_lon,
            target_lat, target_lon,
            speed, self.update_interval
        )
        
        # Maqsadga yetdimi?
        distance = haversine_distance(new_lat, new_lon, target_lat, target_lon)
        
        if distance < 0.05:  # 50 metr - yetdi
            # Yangi maqsad yaratish
            new_target_lat, new_target_lon = generate_random_target()
            
            self.db.update_brigade(brigade_id, {
                "current_lat": new_lat,
                "current_lon": new_lon,
                "target_lat": new_target_lat,
                "target_lon": new_target_lon
            })
            
            logger.info(f"🚑 {brigade.get('name')} maqsadga yetdi, yangi yo'nalish")
        else:
            # Oddiy yangilash
            self.db.update_brigade(brigade_id, {
                "current_lat": new_lat,
                "current_lon": new_lon
            })


# Global instance
simulator_instance: Optional[BrigadeSimulator] = None


def get_simulator(db):
    """Simulator instanceni olish"""
    global simulator_instance
    
    if simulator_instance is None:
        simulator_instance = BrigadeSimulator(db)
    
    return simulator_instance