import 'dart:convert';

import 'package:flutter_test/flutter_test.dart';
import 'package:pluriwave/modelos/emisora.dart';
import 'package:pluriwave/servicios/emisoras_destacadas.dart';
import 'package:shared_preferences/shared_preferences.dart';

/// Free-tier featured set (fix/auto-quality-guidelines, item 6).
///
/// The whole compliance story rests on this: a Play reviewer on a fresh
/// install is ALWAYS free tier, has no network catalogue snapshot, no
/// favourites, no custom stations and no `ultima_emisora_v1` — so the free
/// root's single folder MUST still resolve to real, playable stations from
/// nothing but the binary itself.
void main() {
  TestWidgetsFlutterBinding.ensureInitialized();

  const ultima = Emisora(
    uuid: 'uuid-ultima',
    nombre: 'Ultima escuchada',
    url: 'https://ultima.example/stream',
  );

  group('resolverEmisorasDestacadas', () {
    test('cold bind: sin red, sin EstadoRadio y con prefs vacías devuelve '
        '>= 3 emisoras reales', () async {
      SharedPreferences.setMockInitialValues({});

      final destacadas = await resolverEmisorasDestacadas();

      expect(destacadas.length, greaterThanOrEqualTo(3));
      expect(
        destacadas.every((e) => e.uuid.isNotEmpty),
        isTrue,
        reason: 'un uuid vacío no se puede resolver desde emisora:<uuid>',
      );
      expect(
        destacadas.every(
          (e) => e.url.startsWith('http://') || e.url.startsWith('https://'),
        ),
        isTrue,
      );
      expect(
        destacadas.map((e) => e.uuid).toSet().length,
        destacadas.length,
        reason: 'uuids duplicados romperían porUuid',
      );
    });

    test('con ultima_emisora_v1 presente: va PRIMERA y no se duplica',
        () async {
      SharedPreferences.setMockInitialValues({
        claveUltimaEmisora: jsonEncode(ultima.toMap()),
      });

      final destacadas = await resolverEmisorasDestacadas();

      expect(destacadas.first.uuid, ultima.uuid);
      expect(
        destacadas.where((e) => e.uuid == ultima.uuid).length,
        1,
        reason: 'la última escuchada no puede aparecer dos veces',
      );
      expect(destacadas.length, emisorasDestacadas.length + 1);
    });

    test('la última escuchada YA curada no añade una segunda fila', () async {
      final yaCurada = emisorasDestacadas.first;
      SharedPreferences.setMockInitialValues({
        claveUltimaEmisora: jsonEncode(yaCurada.toMap()),
      });

      final destacadas = await resolverEmisorasDestacadas();

      expect(destacadas.first.uuid, yaCurada.uuid);
      expect(destacadas.length, emisorasDestacadas.length);
    });

    test('ultima_emisora_v1 corrupta degrada al set curado, nunca lanza',
        () async {
      SharedPreferences.setMockInitialValues({
        claveUltimaEmisora: 'no-es-json{{',
      });

      final destacadas = await resolverEmisorasDestacadas();

      expect(destacadas.length, emisorasDestacadas.length);
    });
  });

  group('esEmisoraGratuitaPorUuid', () {
    test('un uuid curado es gratuito', () async {
      SharedPreferences.setMockInitialValues({});

      expect(
        await esEmisoraGratuitaPorUuid(emisorasDestacadas.first.uuid),
        isTrue,
      );
    });

    test('la última escuchada es gratuita aunque no esté curada', () async {
      SharedPreferences.setMockInitialValues({
        claveUltimaEmisora: jsonEncode(ultima.toMap()),
      });

      expect(await esEmisoraGratuitaPorUuid(ultima.uuid), isTrue);
    });

    test('un uuid del catálogo Radio Browser NO es gratuito', () async {
      SharedPreferences.setMockInitialValues({});

      expect(await esEmisoraGratuitaPorUuid('uuid-del-catalogo'), isFalse);
    });

    test('uuid vacío nunca es gratuito', () async {
      SharedPreferences.setMockInitialValues({});

      expect(await esEmisoraGratuitaPorUuid(''), isFalse);
    });
  });

  test('claveUltimaEmisora coincide con la que persiste EstadoRadio', () {
    expect(claveUltimaEmisora, 'ultima_emisora_v1');
  });
}