flux/lib/features/customers/data/customer_repository.dart

import 'package:file_picker/file_picker.dart';
import 'package:flux/core/blocs/session/session_bloc.dart';
import 'package:flux/core/utils/string_extensions.dart';
import 'package:flux/features/customers/models/customer_file_model.dart';
import 'package:get_it/get_it.dart';
import 'package:supabase_flutter/supabase_flutter.dart';
import '../models/customer_model.dart';

class CustomerRepository {
  final SupabaseClient _supabase = GetIt.I<SupabaseClient>();
  final String companyId = GetIt.I.get<SessionBloc>().state.company!.id;

  // Crea un nuovo cliente
  Future<CustomerModel> saveCustomer(CustomerModel customer) async {
    try {
      final response = await _supabase
          .from('customer')
          .upsert(customer.toJson())
          .select()
          .single();
      return CustomerModel.fromMap(response);
    } catch (e) {
      throw 'Errore durante il salvataggio del cliente: $e';
    }
  }

  Future<CustomerModel> updateCustomer(CustomerModel customer) async {
    try {
      final response = await _supabase
          .from('customer')
          .update(customer.toJson())
          .eq('id', customer.id!)
          .select()
          .single();
      return CustomerModel.fromMap(response);
    } catch (e) {
      throw 'Errore durante la modifica del cliente: $e';
    }
  }

  // Recupera tutti i clienti dell'azienda
  Future<List<CustomerModel>> getCustomers(String companyId) async {
    try {
      final response = await _supabase
          .from('customer')
          .select('''
            *,
            customer_file(*)
            ''')
          .eq('company_id', companyId)
          .eq('is_active', true)
          .order('nome');

      return (response as List).map((c) => CustomerModel.fromMap(c)).toList();
    } catch (e) {
      throw 'Errore nel recupero clienti';
    }
  }

  // Ricerca clienti per nome o telefono (fondamentale per la UX)
  Future<List<CustomerModel>> searchCustomers(
    String companyId,
    String query,
  ) async {
    try {
      final response = await _supabase
          .from('customer')
          .select()
          .eq('company_id', companyId)
          .or('nome.ilike.%$query%,telefono.ilike.%$query%')
          .limit(10);

      return (response as List).map((c) => CustomerModel.fromMap(c)).toList();
    } catch (e) {
      return [];
    }
  }

  /// Recupera i file di un cliente specifico
  Future<List<CustomerFileModel>> getCustomerFiles(String customerId) async {
    try {
      final response = await _supabase
          .from('customer_file')
          .select()
          .eq('customer_id', customerId);

      return (response as List)
          .map((f) => CustomerFileModel.fromMap(f))
          .toList();
    } catch (e) {
      throw 'Errore recupero file: $e';
    }
  }

  /// Salva il riferimento del file nel DB
  Future<void> saveCustomerFile(CustomerFileModel file) async {
    await _supabase.from('customer_file').insert(file.toMap());
  }

  /// Carica un file e salva il riferimento nel database
  Future<CustomerFileModel> uploadAndRegisterFile({
    required String customerId,
    required PlatformFile pickedFile,
  }) async {
    final cleanFileName = pickedFile.name.replaceAll(
      RegExp(r'[^a-zA-Z0-9\.\-]'),
      '_',
    );
    final storagePath =
        '$companyId/customers/${DateTime.now().millisecondsSinceEpoch}_$cleanFileName';
    final int fileSize = pickedFile.size;
    final fileToSave = CustomerFileModel(
      customerId: customerId,
      name: cleanFileName.fileNameWithoutExtension(),
      extension: cleanFileName.fileExtension(),
      url: 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('customer_file')
          .insert(fileToSave.toMap())
          .select()
          .single();

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

  Future<void> saveFileReference(CustomerFileModel file) async {
    await _supabase.from('customer_file').upsert(file.toMap());
  }

  /// Aggiorna la lista degli URL nel database
  Future<void> updateCustomerDocuments(int id, List<String> urls) async {
    await _supabase
        .from('customer')
        .update({'document_urls': urls})
        .eq('id', id);
  }

  /// Elimina un file dallo storage
  Future<void> deleteDocument(String fullPath) async {
    // Il path dovrebbe essere ricavato dall'URL
    final path = fullPath.split('documents/').last;
    await _supabase.storage.from('documents').remove([path]);
  }
}