import 'package:flutter_riverpod/flutter_riverpod.dart';

import '../../models/network/network_site.dart';
import '../../models/network/network_location.dart';
import '../supabase_provider.dart';

final networkSitesProvider = FutureProvider<List<NetworkSite>>((ref) async {
  final client = ref.watch(supabaseClientProvider);
  final rows = await client.from('network_sites').select().order('name');
  return (rows as List)
      .map((r) => NetworkSite.fromMap(r as Map<String, dynamic>))
      .toList();
});

final networkLocationsProvider = FutureProvider<List<NetworkLocation>>((ref) async {
  final client = ref.watch(supabaseClientProvider);
  final rows = await client.from('network_locations').select().order('name');
  return (rows as List)
      .map((r) => NetworkLocation.fromMap(r as Map<String, dynamic>))
      .toList();
});

final selectedSiteIdProvider = StateProvider<String?>((ref) => null);

class NetworkSitesController {
  NetworkSitesController(this.ref);
  final Ref ref;

  Future<NetworkSite> createSite({
    required String name,
    String? address,
    String? notes,
    String? createdBy,
  }) async {
    final client = ref.read(supabaseClientProvider);
    final inserted = await client
        .from('network_sites')
        .insert({
          'name': name,
          'address': ?address,
          'notes': ?notes,
          'created_by': ?createdBy,
        })
        .select()
        .single();
    ref.invalidate(networkSitesProvider);
    return NetworkSite.fromMap(inserted);
  }

  Future<void> updateSite(NetworkSite site) async {
    final client = ref.read(supabaseClientProvider);
    await client.from('network_sites').update(site.toUpdateMap()).eq('id', site.id);
    ref.invalidate(networkSitesProvider);
  }

  Future<void> deleteSite(String id) async {
    final client = ref.read(supabaseClientProvider);
    await client.from('network_sites').delete().eq('id', id);
    ref.invalidate(networkSitesProvider);
  }

  Future<NetworkLocation> createLocation({
    required String siteId,
    String? parentId,
    required String name,
    required NetworkLocationKind kind,
    String? positionLabel,
    String? notes,
  }) async {
    final client = ref.read(supabaseClientProvider);
    final inserted = await client
        .from('network_locations')
        .insert({
          'site_id': siteId,
          'parent_id': ?parentId,
          'name': name,
          'kind': kind.wire,
          'position_label': ?positionLabel,
          'notes': ?notes,
        })
        .select()
        .single();
    ref.invalidate(networkLocationsProvider);
    return NetworkLocation.fromMap(inserted);
  }

  /// Returns an existing root location for the site, or creates a "Main"
  /// location of kind=other if none exist. Used by the device assignment flow
  /// so admins can pick a site without having to think about location hierarchy.
  Future<NetworkLocation> ensureDefaultLocation(String siteId) async {
    final locations = await ref.read(networkLocationsProvider.future);
    for (final l in locations) {
      if (l.siteId == siteId) return l;
    }
    return createLocation(
      siteId: siteId,
      name: 'Main',
      kind: NetworkLocationKind.other,
    );
  }
}

final networkSitesControllerProvider =
    Provider<NetworkSitesController>((ref) => NetworkSitesController(ref));