import 'dart:async';
import 'dart:io';

import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:pluriwave/modelos/emisora.dart';
import 'package:pluriwave/servicios/servicio_grabacion_radio.dart';
import 'package:shared_preferences/shared_preferences.dart';

void main() {
  group('ServicioGrabacionRadio', () {
    test(
      'guarda el stream original en disco con extensión por codec',
      () async {
        final dir = await Directory.systemTemp.createTemp('pluriwave-rec-');
        final servicio = ServicioGrabacionRadio(
          cliente: MockClient((request) async {
            return http.Response.bytes(
              [1, 2, 3, 4, 5],
              200,
              headers: {'content-type': 'audio/mpeg'},
            );
          }),
          resolverDirectorioBase: () async => dir,
          reloj: () => DateTime(2026, 5, 21, 18, 30),
        );

        await servicio.iniciar(
          const Emisora(
            uuid: 'r1',
            nombre: 'Radio Prueba',
            url: 'https://stream.example/radio',
            codec: 'MP3',
          ),
        );
        await Future<void>.delayed(Duration.zero);

        final carpeta = Directory(
          '${dir.path}${Platform.pathSeparator}grabaciones',
        );
        final archivos = await carpeta.list().where((e) => e is File).toList();
        expect(archivos, hasLength(1));
        expect(archivos.single.path, endsWith('.mp3'));
        expect(await File(archivos.single.path).readAsBytes(), [1, 2, 3, 4, 5]);
        expect(servicio.estado.tipo, EstadoGrabacionRadioTipo.inactiva);

        await servicio.dispose();
      },
    );

    test('detiene una grabación activa bajo demanda', () async {
      final dir = await Directory.systemTemp.createTemp('pluriwave-rec-stop-');
      final controller = StreamController<List<int>>();
      final servicio = ServicioGrabacionRadio(
        cliente: _StreamClient(controller.stream),
        resolverDirectorioBase: () async => dir,
      );

      await servicio.iniciar(
        const Emisora(
          uuid: 'r2',
          nombre: 'Radio Larga',
          url: 'https://stream.example/live',
          codec: 'aac',
        ),
      );
      controller.add([10, 20, 30]);
      await Future<void>.delayed(Duration.zero);

      expect(servicio.estado.activa, isTrue);
      expect(servicio.estado.bytes, 3);

      await servicio.detener();

      expect(servicio.estado.tipo, EstadoGrabacionRadioTipo.inactiva);
      await controller.close();
      await servicio.dispose();
    });

    test('se detiene automáticamente al alcanzar el tamaño máximo', () async {
      SharedPreferences.setMockInitialValues({});
      final dir = await Directory.systemTemp.createTemp('pluriwave-rec-max-');
      final controller = StreamController<List<int>>();
      final servicio = ServicioGrabacionRadio(
        cliente: _StreamClient(controller.stream),
        resolverDirectorioBase: () async => dir,
      );

      await servicio.inicializar();
      await servicio.guardarMaxBytes(3);
      await servicio.iniciar(
        const Emisora(
          uuid: 'r3',
          nombre: 'Radio Corta',
          url: 'https://stream.example/short',
          codec: 'mp3',
        ),
      );
      controller.add([1, 2, 3]);
      await Future<void>.delayed(Duration.zero);
      await Future<void>.delayed(const Duration(milliseconds: 20));

      expect(servicio.estado.tipo, EstadoGrabacionRadioTipo.inactiva);
      await controller.close();
      await servicio.dispose();
    });

  });
}

class _StreamClient extends http.BaseClient {
  _StreamClient(this.stream);

  final Stream<List<int>> stream;

  @override
  Future<http.StreamedResponse> send(http.BaseRequest request) async {
    return http.StreamedResponse(
      stream,
      200,
      headers: {'content-type': 'audio/aac'},
    );
  }
}