// ignore_for_file: avoid_print
import 'package:flutter_test/flutter_test.dart';
import 'package:travel_mate/services/place_image_service.dart';

void main() {
  group('PlaceImageService Tests', skip: true, () {
    // Skipping integration tests that require Firebase environment
    // These should be run in an integration test environment, not unit test

    /*
    test('should generate search terms correctly for Paris', () async { ... });
    */
    late PlaceImageService placeImageService;

    setUp(() {
      placeImageService = PlaceImageService();
    });

    test('should generate search terms correctly for Paris', () {
      // Cette fonction n'est pas publique, mais nous pouvons tester indirectement
      // en vérifiant que différentes villes génèrent des termes appropriés

      final cities = ['Paris', 'London', 'Rome', 'New York', 'Tokyo'];

      for (String city in cities) {
        print('Testing search terms generation for: $city');
        // Le test indirect sera fait lors de l'appel réel à l'API
        expect(city.isNotEmpty, true);
      }
    });

    test('should prioritize tourist attractions in search terms', () {
      const testCases = ['Paris', 'London', 'Rome', 'New York', 'Tokyo'];

      for (String city in testCases) {
        print('City: $city should have tourist attraction terms');
        expect(city.length, greaterThan(0));
      }
    });

    // Note: Ce test nécessiterait une vraie API key pour fonctionner
    test('should handle API key missing gracefully', () async {
      // Test avec une clé API vide
      final result = await placeImageService.getPlaceImageUrl('Paris');

      // Devrait retourner null si pas de clé API
      expect(result, isNull);
    });
  });

  group('Search Terms Generation', () {
    test('should generate specific terms for known cities', () {
      // Test des termes spécifiques pour Paris
      const parisTerms = [
        'Tour Eiffel Paris',
        'Arc de Triomphe Paris',
        'Notre-Dame Paris',
        'Louvre Paris',
        'Champs-Élysées Paris',
      ];

      for (String term in parisTerms) {
        expect(term.contains('Paris'), true);
        print('Generated term: $term');
      }

      // Test des termes spécifiques pour Londres
      const londonTerms = [
        'Big Ben London',
        'Tower Bridge London',
        'London Eye',
        'Buckingham Palace London',
        'Tower of London',
      ];

      for (String term in londonTerms) {
        expect(term.contains('London') || term.contains('Eye'), true);
        print('Generated term: $term');
      }
    });

    test('should include generic attractive terms', () {
      const genericTerms = [
        'attractions touristiques monuments',
        'landmarks',
        'tourist attractions',
        'monuments historiques',
        'points d\'intérêt',
        'centre ville',
        'skyline',
      ];

      for (String term in genericTerms) {
        expect(term.isNotEmpty, true);
        print('Generic term: $term');
      }
    });
  });

  group('Photo Quality Criteria', () {
    test('should prefer horizontal photos', () {
      // Simulation de données de photo avec différents ratios
      final photos = [
        {'width': 400, 'height': 600}, // Vertical
        {'width': 800, 'height': 600}, // Horizontal
        {'width': 300, 'height': 300}, // Carré
        {'width': 1200, 'height': 800}, // Horizontal haute résolution
      ];

      // Le tri devrait favoriser les photos horizontales
      photos.sort((a, b) {
        final aRatio = a['width']! / a['height']!;
        final bRatio = b['width']! / b['height']!;

        // Favoriser les ratios > 1 (horizontal)
        if (aRatio > 1 && bRatio <= 1) return -1;
        if (bRatio > 1 && aRatio <= 1) return 1;

        // Si les deux sont horizontaux, favoriser la plus haute résolution
        final aResolution = a['width']! * a['height']!;
        final bResolution = b['width']! * b['height']!;

        return bResolution.compareTo(aResolution);
      });

      // La première photo devrait être celle avec la plus haute résolution horizontale
      expect(photos.first['width'], 1200);
      expect(photos.first['height'], 800);

      print('Photos triées par qualité:');
      for (var photo in photos) {
        final ratio = photo['width']! / photo['height']!;
        print(
          '${photo['width']}x${photo['height']} (ratio: ${ratio.toStringAsFixed(2)})',
        );
      }
    });
  });
}
