import 'package:flux/core/enums_and_consts/consts.dart';
import 'package:flux/features/master_data/providers/models/provider_model.dart';
import 'package:flux/features/master_data/staff/models/staff_member_model.dart';
import 'package:get_it/get_it.dart';
import 'package:supabase_flutter/supabase_flutter.dart';
import '../models/store_model.dart';

class StoreRepository {
  final SupabaseClient _supabase = GetIt.I.get<SupabaseClient>();

  /// Crea un nuovo negozio associato alla compagnia dell'utente
  /* Future<void> createStore(StoreModel store) async {
    try {
      await _supabase.from(Tables.stores).insert(store.toMap());
    } on PostgrestException catch (e) {
      // Intercettiamo errori specifici del database
      throw e.message;
    } catch (e) {
      throw 'Errore imprevisto durante la creazione del negozio: $e';
    }
  } */

  Future<StoreModel> saveStore(StoreModel store) async {
    try {
      final response = await _supabase
          .from(Tables.stores)
          .upsert(store.toMap())
          .select()
          .single();
      return StoreModel.fromMap(response);
    } on PostgrestException catch (e) {
      throw e.message;
    } catch (e) {
      throw 'Errore imprevisto durante il salvataggio del negozio: $e';
    }
  }

  Future<void> syncStoreProviders(
    String storeId,
    List<ProviderModel> providers,
  ) async {
    try {
      // 1. Eliminiamo tutte le associazioni correnti per questo negozio
      await _supabase
          .from(Tables.providersInStores)
          .delete()
          .eq('store_id', storeId);

      // 2. Se ci sono nuovi provider da associare, li inseriamo
      if (providers.isNotEmpty) {
        final inserts = providers
            .map((p) => {'store_id': storeId, 'provider_id': p.id})
            .toList();

        await _supabase.from(Tables.providersInStores).insert(inserts);
      }
    } catch (e) {
      throw 'Errore durante la sincronizzazione provider: $e';
    }
  }

  Future<void> syncStoreStaff(
    String storeId,
    List<StaffMemberModel> staffMembers,
  ) async {
    try {
      // 1. Eliminiamo tutte le associazioni correnti per questo negozio
      await _supabase
          .from(Tables.staffInStores)
          .delete()
          .eq('store_id', storeId);

      // 2. Se ci sono nuovi dipendenti da associare, li inseriamo
      if (staffMembers.isNotEmpty) {
        final inserts = staffMembers
            .map((s) => {'store_id': storeId, 'staff_id': s.id})
            .toList();

        await _supabase.from(Tables.staffInStores).insert(inserts);
      }
    } catch (e) {
      throw 'Errore durante la sincronizzazione staff: $e';
    }
  }

  /// Recupera tutti i negozi di una determinata compagnia
  Future<List<StoreModel>> fetchAllCompanyStores(String companyId) async {
    try {
      final response = await _supabase
          .from(Tables.stores)
          .select('''
          *,
          associated_providers:${Tables.providersInStores} (
            ${Tables.providers} (
              *
            )
          )
          associated_staff:${Tables.staffInStores} (
            ${Tables.staffMembers} (
              *
            )
          )
        ''')
          .eq('company_id', companyId)
          .order('name');

      return (response as List).map((m) => StoreModel.fromMap(m)).toList();
    } catch (e) {
      throw 'Errore nel recupero dei negozi: $e';
    }
  }

  Future<void> associateStoreToProvider({
    required String storeId,
    required String providerId,
  }) async {
    try {
      await _supabase.from(Tables.providersInStores).insert({
        'store_id': storeId,
        'provider_id': providerId,
      });
    } catch (e) {
      throw 'Errore durante l\'associazione del negozio al provider: $e';
    }
  }

  Future<void> removeStoreFromProvider({
    required String storeId,
    required String providerId,
  }) async {
    try {
      await _supabase
          .from(Tables.providersInStores)
          .delete()
          .eq('store_id', storeId)
          .eq('provider_id', providerId);
    } catch (e) {
      throw 'Errore durante la rimozione del negozio dal provider: $e';
    }
  }
}
