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

class RentalcarsAsyncClient:
    def __init__(self, api_key: str, redis_url: str = "redis://localhost"):
        self.api_key = api_key
        self.base_url = "https://demandapi.booking.com/3.1/cars/"
        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-RentalcarsTracker/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_car_details(
        self,
        car_id: str,
        use_cache: bool = True,
        max_retries: int = 3
    ) -> Dict[Any, Any]:
        """
        Récupère les détails d'une voiture avec gestion du cache et retry automatique

        Args:
            car_id: ID de la voiture (ex: 'CAR1234')
            use_cache: Utiliser le cache Redis
            max_retries: Nombre maximum de tentatives

        Returns:
            Dict contenant les données de la voiture

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

        # 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 voiture {car_id}")
                    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,
                    'car_id': car_id
                }

                async with self.session.get(
                    f"{self.base_url}/cars",
                    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"Aucune voiture trouvée pour {car_id}")

                    # 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"Voiture {car_id} récupérée 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_cars(car_ids: list):
    """Surveille une liste de voitures de manière asynchrone"""
    async with RentalcarsAsyncClient(
        api_key=os.getenv('RENTALCARS_API_KEY')
    ) as client:

        tasks = []
        for car_id in car_ids:
            task = client.get_car_details(car_id)
            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 {car_ids[i]}: {result}")
            else:
                car = result['data'][0]
                print(f"Voiture {car['car']['id']}: {car['car_status']}")

# Utilisation
# asyncio.run(monitor_cars(['CAR1234', 'CAR5678', 'CAR9101']))

-- php --

namespace App\Services;

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

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

    public function __construct()
    {
        $this->apiKey = config('services.rentalcars.key');
        $this->baseUrl = 'https://demandapi.booking.com/3.1/cars/';
        $this->timeout = config('services.rentalcars.timeout', 10);
        $this->maxRetries = config('services.rentalcars.max_retries', 3);

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

    /**
     * Récupère les détails d'une voiture avec gestion complète des erreurs
     */
    public function getCarDetails(string $carId, bool $useCache = true): array
    {
        $cacheKey = "rentalcars.car.{$carId}";

        // Vérification du cache Laravel
        if ($useCache && Cache::has($cacheKey)) {
            Log::info("Cache hit pour voiture {$carId}");
            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-RentalcarsTracker/1.0',
                        'Accept' => 'application/json'
                    ])
                    ->get("{$this->baseUrl}/cars", [
                        'access_key' => $this->apiKey,
                        'car_id' => $carId
                    ]);

                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("Aucune voiture trouvée pour {$carId}");
                }

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

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

                return $data;

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

                Log::warning("Tentative {$attempt} échouée pour voiture {$carId}", [
                    '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 voiture {$carId}", [
            'attempts' => $this->maxRetries,
            'last_error' => $lastException?->getMessage()
        ]);

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

    /**
     * Recherche de voitures avec filtres avancés
     */
    public function searchCars(array $filters = []): array
    {
        $validFilters = [
            'location_id', 'pickup_date', 'dropoff_date',
            'car_type', 'supplier_id', 'car_id'
        ];

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

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

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

        } catch (RequestException $e) {
            Log::error('Erreur recherche de voitures', [
                '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}/locations", [
                    '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
/*
'rentalcars' => [
    'key' => env('RENTALCARS_API_KEY'),
    'timeout' => env('RENTALCARS_TIMEOUT', 10),
    'max_retries' => env('RENTALCARS_MAX_RETRIES', 3),
],
*/

// Utilisation dans un Controller
/*
class CarController extends Controller
{
    public function show(string $carId, RentalcarsService $rentalcars)
    {
        try {
            $carData = $rentalcars->getCarDetails($carId);
            return response()->json($carData);

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.RestTemplate;

import java.util.HashMap;
import java.util.Map;

@Service
public class RentalcarsService {

    @Value("${rentalcars.api.key}")
    private String apiKey;

    @Value("${rentalcars.api.url}")
    private String baseUrl;

    private final RestTemplate restTemplate;

    @Autowired
    public RentalcarsService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Cacheable(value = "carCache", key = "#carId")
    @Retryable(value = {HttpClientErrorException.TooManyRequests.class},
               maxAttempts = 3,
               backoff = @Backoff(delay = 1000, multiplier = 2))
    public Map getCarDetails(String carId) {
        String url = baseUrl + "/cars?car_id={carId}&access_key={apiKey}";

        HttpHeaders headers = new HttpHeaders();
        headers.set("User-Agent", "Java-RentalcarsTracker/1.0");

        Map params = new HashMap<>();
        params.put("carId", carId);
        params.put("apiKey", apiKey);

        ResponseEntity

require 'faraday'
require 'faraday_middleware'
require 'redis'
require 'json'

class RentalcarsClient
  def initialize(api_key, redis_url = 'redis://localhost:6379/0')
    @api_key = api_key
    @base_url = 'https://demandapi.booking.com/3.1/cars/'
    @redis = Redis.new(url: redis_url)
    setup_connection
  end

  def setup_connection
    @conn = Faraday.new(url: @base_url) do |faraday|
      faraday.request :url_encoded
      faraday.response :json, content_type: 'application/json'
      faraday.adapter Faraday.default_adapter
      faraday.headers['User-Agent'] = 'Ruby-RentalcarsTracker/1.0'
    end
  end

  def get_car_details(car_id, use_cache = true)
    cache_key = "car:#{car_id}"

    if use_cache
      cached_data = @redis.get(cache_key)
      return JSON.parse(cached_data) if cached_data
    end

    response = @conn.get('/cars', { car_id: car_id, access_key: @api_key })

    if response.status == 429
      retry_after = response.headers['retry-after'] || 60
      warn "Rate limit atteint. Retry dans #{retry_after}s"
      sleep retry_after.to_i
      return get_car_details(car_id, use_cache)
    end

    unless response.success?
      raise "Erreur Rentalcars.com: #{response.body['message']}"
    end

    data = response.body

    if use_cache && data['data'] && !data['data'].empty?
      @redis.setex(cache_key, 300, data.to_json)
    end

    data
  end
end

# Utilisation recommandée
client = RentalcarsClient.new(ENV['RENTALCARS_API_KEY'])

begin
  car_data = client.get_car_details('CAR1234')

  if car_data['data'].empty?
    raise "Voiture CAR1234 non trouvée"
  end

  car = car_data['data'][0]
  puts "Voiture #{car['car']['id']}: #{car['car']['status']}"
rescue => e
  puts "Erreur lors du suivi: #{e.message}"
end