flux/lib/features/services/data/services_repository.dart

import 'package:file_picker/file_picker.dart';
import 'package:flutter/material.dart';
import 'package:flux/core/blocs/session/session_cubit.dart';
import 'package:flux/core/utils/string_extensions.dart';
import 'package:flux/features/customers/data/customer_repository.dart';
import 'package:flux/features/customers/models/customer_file_model.dart';
import 'package:flux/features/services/models/service_file_model.dart';
import 'package:get_it/get_it.dart';
import 'package:supabase_flutter/supabase_flutter.dart';
import '../models/service_model.dart';

class ServicesRepository {
  final _supabase = Supabase.instance.client;
  final companyId = GetIt.I.get<SessionCubit>().state.company!.id;
  final CustomerRepository _customerRepository = GetIt.I<CustomerRepository>();

  // --- RECUPERO SINGOLO SERVIZIO CON JOIN COMPLETO ---
  Future<ServiceModel> fetchServiceById(String id) async {
    try {
      final response = await _supabase
          .from('service')
          .select('''
            *,
            customer(nome), 
            energy_service(*),
            fin_service(*),
            entertainment_service(*),
            service_file(*)
          ''')
          .eq('id', id)
          .single();

      return ServiceModel.fromMap(response);
    } catch (e) {
      throw Exception('Errore nel caricamento del servizio: $e');
    }
  }

  // --- RECUPERO PAGINATO CON FILTRI E JOIN ---
  Future<List<ServiceModel>> fetchServices({
    required String companyId,
    required int offset,
    int limit = 50,
    String? searchTerm,
    DateTimeRange? dateRange,
  }) async {
    try {
      // Nota: 'customer(name, surname)' serve per il display name nella card
      var query = _supabase
          .from('service')
          .select('''
            *,
            customer(nome), 
            energy_service(*),
            fin_service(*),
            entertainment_service(*),
            service_file(*)
          ''')
          .eq('company_id', companyId);

      // Filtro Range Date
      if (dateRange != null) {
        query = query
            .gte('created_at', dateRange.start.toIso8601String())
            .lte('created_at', dateRange.end.toIso8601String());
      }

      if (searchTerm != null && searchTerm.isNotEmpty) {
        // Filtra sui campi della tabella principale O su quelli della tabella joinata
        query = query.or(
          'number.ilike.%$searchTerm%,note.ilike.%$searchTerm%,customer.nome.ilike.%$searchTerm%',
        );
      }

      final response = await query
          .order('created_at', ascending: false)
          .range(offset, offset + limit - 1);

      return (response as List)
          .map((map) => ServiceModel.fromMap(map))
          .toList();
    } catch (e) {
      throw Exception('Errore nel caricamento servizi: $e');
    }
  }

  Stream<List<ServiceModel>> getLastStoreServicesStream({
    required String storeId,
    required int limit,
  }) {
    return _supabase
        .from('service')
        .stream(primaryKey: ['id'])
        .eq('store_id', storeId)
        .order('created_at', ascending: false)
        .limit(limit)
        .map(
          (listOfMaps) =>
              listOfMaps.map((map) => ServiceModel.fromMap(map)).toList(),
        );
  }

  // --- SALVATAGGIO COMPLETO (PRIMA PADRE, POI FIGLI) ---
  Future<ServiceModel> saveFullService(ServiceModel service) async {
    try {
      // 1. Upsert del record principale
      final serviceData = await _supabase
          .from('service')
          .upsert(service.toMap())
          .select()
          .single();

      final String newId = serviceData['id'];

      // 2. MODIFICA: Pulizia atomica dei figli
      // Se stiamo modificando (id != null), resettiamo le tabelle collegate
      if (service.id != null) {
        await Future.wait([
          _supabase.from('energy_service').delete().eq('service_id', newId),
          _supabase.from('fin_service').delete().eq('service_id', newId),
          _supabase
              .from('entertainment_service')
              .delete()
              .eq('service_id', newId),
          // Aggiungi qui eventuali altre tabelle pivot o file
        ]);
      }

      // 3. Inserimento dei moduli in parallelo per velocità
      final List<Future> insertTasks = [];

      if (service.energyServices.isNotEmpty) {
        insertTasks.add(
          _supabase
              .from('energy_service')
              .insert(
                service.energyServices
                    .map((item) => item.copyWith(serviceId: newId).toMap())
                    .toList(),
              ),
        );
      }

      if (service.finServices.isNotEmpty) {
        insertTasks.add(
          _supabase
              .from('fin_service')
              .insert(
                service.finServices
                    .map((item) => item.copyWith(serviceId: newId).toMap())
                    .toList(),
              ),
        );
      }

      if (service.entertainmentServices.isNotEmpty) {
        insertTasks.add(
          _supabase
              .from('entertainment_service')
              .insert(
                service.entertainmentServices
                    .map((item) => item.copyWith(serviceId: newId).toMap())
                    .toList(),
              ),
        );
      }

      if (insertTasks.isNotEmpty) {
        await Future.wait(insertTasks);
      }

      // 4. UPLOAD DEI FILE LOCALI (Nuovi)
      // Filtriamo solo i file che non hanno ancora un ID (quindi sono locali)
      final localFilesToUpload = service.files
          .where((f) => f.id == null)
          .toList();

      if (localFilesToUpload.isNotEmpty) {
        final List<Future> uploadTasks = [];

        for (var file in localFilesToUpload) {
          final storagePath =
              '$companyId/services/$newId/${DateTime.now().millisecondsSinceEpoch}_${file.name}.${file.extension}';
          final String mimeType = file.extension.toLowerCase() == 'pdf'
              ? 'application/pdf'
              : 'image/${file.extension}';

          final fileToSave = file.copyWith(
            serviceId: newId,
            storagePath: storagePath,
          );

          // Creiamo una funzione asincrona per caricare file e scrivere nel DB
          Future<void> uploadAndLink() async {
            // A. Upload nel Bucket Storage (usiamo i bytes così funziona anche su Web!)
            await _supabase.storage
                .from('documents')
                .uploadBinary(
                  storagePath,
                  fileToSave.localBytes!,
                  fileOptions: FileOptions(contentType: mimeType, upsert: true),
                );

            // B. Inserimento riga nel DB relazionale
            await _supabase.from('service_file').insert(fileToSave.toMap());
          }

          uploadTasks.add(uploadAndLink());
        }

        // Eseguiamo tutti gli upload in parallelo per la massima velocità
        await Future.wait(uploadTasks);
      }

      // 5. GRAN FINALE: RECUPERO DEL MODELLO COMPLETO E AGGIORNATO
      // Interroghiamo Supabase per farci restituire la pratica con TUTTI gli ID generati
      // (inclusi quelli della tabella service_file appena inseriti)
      final updatedServiceData = await _supabase
          .from('service')
          .select('''
            *,
            energy_service(*),
            fin_service(*),
            entertainment_service(*),
            service_file(*)
          ''')
          .eq('id', newId)
          .single();

      return ServiceModel.fromMap(updatedServiceData);
    } catch (e) {
      // Qui potresti aggiungere una logica di "rollback manuale" se necessario
      throw Exception('Errore durante il salvataggio corazzato: $e');
    }
  }

  // --- ELIMINAZIONE ---
  Future<void> deleteService(String id) async {
    try {
      await _supabase.from('service').delete().eq('id', id);
    } catch (e) {
      throw Exception('Errore durante l\'eliminazione: $e');
    }
  }

  // --- RECUPERO TIPI CONTENUTI PIÙ FREQUENTI PER AUTOCOMPLETE ---
  Future<List<String>> fetchTopEntertainmentTypes(String companyId) async {
    try {
      // Cerchiamo i tipi più frequenti associati ai servizi di questa company
      // Nota: dobbiamo passare attraverso la tabella 'service' per filtrare per company_id
      final response = await _supabase
          .from('entertainment_service')
          .select('type, service!inner(store!inner(company_id))')
          .eq('service.store.company_id', companyId)
          .limit(100); // Prendiamo un campione

      // Logica rapida per contare le occorrenze e prendere i primi 5
      final Map<String, int> counts = {};
      for (var item in (response as List)) {
        final type = item['type'] as String;
        counts[type] = (counts[type] ?? 0) + 1;
      }

      var sortedKeys = counts.keys.toList()
        ..sort((a, b) => counts[b]!.compareTo(counts[a]!));

      return sortedKeys.take(5).toList();
    } catch (e) {
      return [
        "Netflix",
        "DAZN",
        "Disney+",
        "Sky",
      ]; // Fallback se non c'è ancora storia
    }
  }

  /// Ascolta in tempo reale i file caricati per una pratica
  Stream<List<ServiceFileModel>> getServiceFilesStream(String serviceId) {
    return _supabase
        .from('service_file')
        .stream(primaryKey: ['id'])
        .eq('service_id', serviceId)
        .order('created_at', ascending: false)
        .map(
          (listOfMaps) =>
              listOfMaps.map((map) => ServiceFileModel.fromMap(map)).toList(),
        );
  }

  Future<ServiceFileModel> uploadAndRegisterServiceFile({
    required String serviceId,
    required PlatformFile pickedFile,
  }) async {
    final cleanFileName = pickedFile.name.replaceAll(
      RegExp(r'[^a-zA-Z0-9\.\-]'),
      '_',
    );
    final storagePath =
        '$companyId/services/$serviceId/${DateTime.now().millisecondsSinceEpoch}_$cleanFileName';
    final int fileSize = pickedFile.size;
    final fileToSave = ServiceFileModel(
      serviceId: serviceId,
      name: cleanFileName.fileNameWithoutExtension(),
      extension: cleanFileName.fileExtension(),
      storagePath: storagePath,
      fileSize: fileSize,
    );
    final String mimeType = fileToSave.extension.toLowerCase() == 'pdf'
        ? 'application/pdf'
        : 'image/${fileToSave.extension}';
    try {
      // Usiamo bytes invece del path per massima compatibilità
      if (pickedFile.bytes == null && pickedFile.path == null) {
        throw 'Impossibile leggere il contenuto del file';
      }

      // Se siamo su desktop/mobile abbiamo il path, su web abbiamo i bytes
      if (pickedFile.bytes != null) {
        await _supabase.storage
            .from('documents')
            .uploadBinary(
              storagePath,
              pickedFile.bytes!,
              fileOptions: FileOptions(contentType: mimeType, upsert: true),
            );
      }

      final response = await _supabase
          .from('service_file')
          .insert(fileToSave.toMap())
          .select()
          .single();

      return ServiceFileModel.fromMap(response);
    } catch (e) {
      throw 'Errore durante l\'upload: $e';
    }
  }

  Future<void> copyFileToCustomer({
    required ServiceFileModel file,
    required String customerId,
  }) async {
    CustomerFileModel fileToCopy = CustomerFileModel(
      customerId: customerId,
      name: file.name,
      storagePath: file.storagePath,
      extension: file.extension,
      fileSize: file.fileSize,
    );
    await _customerRepository.saveFileReference(fileToCopy);
  }

  Future<void> deleteServiceFiles(List<ServiceFileModel> files) async {
    if (files.isEmpty) return;
    // 1. Prepariamo le liste di ID e di Percorsi
    final List<String> idsToDelete = files.map((f) => f.id!).toList();
    final List<String> storagePaths = files.map((f) => f.storagePath).toList();

    try {
      await _supabase.from('service_file').delete().inFilter('id', idsToDelete);

      await _supabase.storage.from('documents').remove(storagePaths);

      debugPrint("Eliminati con successo ${files.length} file.");
    } on PostgrestException catch (e) {
      debugPrint("Errore DB: ${e.message}");
      throw 'Errore database: ${e.message}';
    } catch (e) {
      debugPrint("Errore generico: $e");
      throw 'Errore durante l\'eliminazione dei file: $e';
    }
  }
}