import asyncio
import aiohttp
import aioredis
import json
import logging
from typing import Optional, Dict, Any
from datetime import datetime, timedelta

class IATAOpenAPIAsyncClient:
    def __init__(self, api_key: str, redis_url: str = "redis://localhost"):
        self.api_key = api_key
        self.base_url = "https://api.iata.org/v1"
        self.redis_url = redis_url
        self.session = None
        self.redis = None

        # Configuration du logging
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)

    async def __aenter__(self):
        """Initialisation du context manager"""
        timeout = aiohttp.ClientTimeout(total=10)
        self.session = aiohttp.ClientSession(
            timeout=timeout,
            headers={'User-Agent': 'Production-IATATracker/2.0'}
        )
        self.redis = await aioredis.from_url(self.redis_url)
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        """Nettoyage des ressources"""
        if self.session:
            await self.session.close()
        if self.redis:
            await self.redis.close()

    async def get_flight_details(
        self,
        flight_iata: str,
        use_cache: bool = True,
        max_retries: int = 3
    ) -> Dict[Any, Any]:
        """
        Récupère les détails d'un vol avec gestion du cache et retry automatique

        Args:
            flight_iata: Code IATA du vol (ex: 'AF1234')
            use_cache: Utiliser le cache Redis
            max_retries: Nombre maximum de tentatives

        Returns:
            Dict contenant les données du vol

        Raises:
            Exception: En cas d'erreur après tous les retries
        """
        cache_key = f"flight:{flight_iata}"

        # Vérification du cache
        if use_cache and self.redis:
            try:
                cached_data = await self.redis.get(cache_key)
                if cached_data:
                    self.logger.info(f"Cache hit pour vol {flight_iata}")
                    return json.loads(cached_data)
            except Exception as e:
                self.logger.warning(f"Erreur cache Redis: {e}")

        # Appel API avec retry
        for attempt in range(max_retries):
            try:
                params = {
                    'access_key': self.api_key,
                    'flight_iata': flight_iata
                }

                async with self.session.get(
                    f"{self.base_url}/flights",
                    params=params
                ) as response:

                    if response.status == 429:
                        # Rate limiting
                        retry_after = int(response.headers.get('Retry-After', 60))
                        self.logger.warning(f"Rate limit. Attente {retry_after}s")
                        await asyncio.sleep(retry_after)
                        continue

                    response.raise_for_status()
                    data = await response.json()

                    # Validation des données
                    if not data.get('data'):
                        raise ValueError(f"Aucun vol trouvé pour {flight_iata}")

                    # Mise en cache (5 minutes)
                    if use_cache and self.redis:
                        try:
                            await self.redis.setex(
                                cache_key,
                                300,
                                json.dumps(data)
                            )
                        except Exception as e:
                            self.logger.warning(f"Erreur mise en cache: {e}")

                    self.logger.info(f"Vol {flight_iata} récupéré avec succès")
                    return data

            except aiohttp.ClientError as e:
                self.logger.error(f"Tentative {attempt + 1} échouée: {e}")
                if attempt == max_retries - 1:
                    raise Exception(f"Échec après {max_retries} tentatives: {e}")
                await asyncio.sleep(2 ** attempt)  # Backoff exponentiel

        raise Exception("Nombre maximum de tentatives atteint")

# Exemple d'utilisation en production
async def monitor_flights(flight_codes: list):
    """Surveille une liste de vols de manière asynchrone"""
    async with IATAOpenAPIAsyncClient(
        api_key=os.getenv('IATA_OPEN_API_KEY')
    ) as client:

        tasks = []
        for code in flight_codes:
            task = client.get_flight_details(code)
            tasks.append(task)

        # Exécution parallèle
        results = await asyncio.gather(*tasks, return_exceptions=True)

        for i, result in enumerate(results):
            if isinstance(result, Exception):
                print(f"Erreur pour {flight_codes[i]}: {result}")
            else:
                flight = result['data'][0]
                print(f"Vol {flight['flight']['iata']}: {flight['flight_status']}")

# Utilisation
# asyncio.run(monitor_flights(['AF1234', 'BA456', 'LH789']))

-- php --

namespace App\Services;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Log;
use GuzzleHttp\Exception\RequestException;

/**
 * Service IATA Open API pour Laravel
 *
 * Gestion complète de l'API avec cache, retry et monitoring
 */
class IATAOpenAPIService
{
    private string $apiKey;
    private string $baseUrl;
    private int $timeout;
    private int $maxRetries;

    public function __construct()
    {
        $this->apiKey = config('services.iata_open_api.key');
        $this->baseUrl = 'https://api.iata.org/v1';
        $this->timeout = config('services.iata_open_api.timeout', 10);
        $this->maxRetries = config('services.iata_open_api.max_retries', 3);

        if (empty($this->apiKey)) {
            throw new \InvalidArgumentException('Clé API IATA Open API requise');
        }
    }

    /**
     * Récupère les détails d'un vol avec gestion complète des erreurs
     */
    public function getFlightDetails(string $flightIata, bool $useCache = true): array
    {
        $cacheKey = "iata_open_api.flight.{$flightIata}";

        // Vérification du cache Laravel
        if ($useCache && Cache::has($cacheKey)) {
            Log::info("Cache hit pour vol {$flightIata}");
            return Cache::get($cacheKey);
        }

        $attempt = 0;
        $lastException = null;

        while ($attempt < $this->maxRetries) {
            try {
                $response = Http::timeout($this->timeout)
                    ->retry(3, 100) // 3 tentatives avec 100ms d'intervalle
                    ->withHeaders([
                        'User-Agent' => 'Laravel-IATATracker/1.0',
                        'Accept' => 'application/json'
                    ])
                    ->get("{$this->baseUrl}/flights", [
                        'access_key' => $this->apiKey,
                        'flight_iata' => $flightIata
                    ]);

                if ($response->status() === 429) {
                    $retryAfter = $response->header('Retry-After', 60);
                    Log::warning("Rate limit atteint. Attente {$retryAfter}s");
                    sleep((int)$retryAfter);
                    $attempt++;
                    continue;
                }

                $response->throw(); // Lance une exception si erreur HTTP

                $data = $response->json();

                // Validation des données
                if (empty($data['data'])) {
                    throw new \Exception("Aucun vol trouvé pour {$flightIata}");
                }

                // Mise en cache pour 5 minutes
                if ($useCache) {
                    Cache::put($cacheKey, $data, now()->addMinutes(5));
                }

                Log::info("Vol {$flightIata} récupéré avec succès", [
                    'attempt' => $attempt + 1,
                    'flights_count' => count($data['data'])
                ]);

                return $data;

            } catch (RequestException $e) {
                $lastException = $e;
                $attempt++;

                Log::warning("Tentative {$attempt} échouée pour vol {$flightIata}", [
                    'error' => $e->getMessage(),
                    'status_code' => $e->getResponse()?->getStatusCode()
                ]);

                if ($attempt < $this->maxRetries) {
                    // Backoff exponentiel
                    sleep(pow(2, $attempt));
                }
            }
        }

        // Toutes les tentatives ont échoué
        Log::error("Échec définitif pour vol {$flightIata}", [
            'attempts' => $this->maxRetries,
            'last_error' => $lastException?->getMessage()
        ]);

        throw new \Exception(
            "Impossible de récupérer le vol {$flightIata} après {$this->maxRetries} tentatives: " .
            $lastException?->getMessage()
        );
    }

    /**
     * Recherche de vols avec filtres avancés
     */
    public function searchFlights(array $filters = []): array
    {
        $validFilters = [
            'dep_iata', 'arr_iata', 'flight_date',
            'flight_status', 'airline_iata', 'flight_iata'
        ];

        $params = array_merge(
            ['access_key' => $this->apiKey],
            array_intersect_key($filters, array_flip($validFilters))
        );

        try {
            $response = Http::timeout($this->timeout)
                ->get("{$this->baseUrl}/flights", $params);

            $response->throw();
            return $response->json();

        } catch (RequestException $e) {
            Log::error('Erreur recherche de vols', [
                'filters' => $filters,
                'error' => $e->getMessage()
            ]);
            throw $e;
        }
    }

    /**
     * Obtient les statistiques de santé de l'API
     */
    public function getHealthStatus(): array
    {
        $startTime = microtime(true);

        try {
            $response = Http::timeout(5)
                ->get("{$this->baseUrl}/airports", [
                    'access_key' => $this->apiKey,
                    'limit' => 1
                ]);

            $responseTime = round((microtime(true) - $startTime) * 1000);

            return [
                'status' => $response->successful() ? 'healthy' : 'degraded',
                'response_time_ms' => $responseTime,
                'http_status' => $response->status(),
                'timestamp' => now()->toISOString()
            ];

        } catch (\Exception $e) {
            return [
                'status' => 'unhealthy',
                'error' => $e->getMessage(),
                'timestamp' => now()->toISOString()
            ];
        }
    }
}

// Configuration dans config/services.php
/*
'iata_open_api' => [
    'key' => env('IATA_OPEN_API_KEY'),
    'timeout' => env('IATA_OPEN_API_TIMEOUT', 10),
    'max_retries' => env('IATA_OPEN_API_MAX_RETRIES', 3),
],
*/

// Utilisation dans un Controller
/*
class FlightController extends Controller
{
    public function show(string $flightCode, IATAOpenAPIService $iataOpenAPI)
    {
        try {
            $flightData = $iataOpenAPI->getFlightDetails($flightCode);
            return response()->json($flightData);

        } catch (\Exception $e) {
            return response()->json([
                'error' => 'Vol non trouvé',
                'message' => $e->getMessage()
            ], 404);
        }
    }
}
*/