import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:geolocator/geolocator.dart';

import '../../homes/providers/homes_providers.dart';
import '../../shared/providers/core_providers.dart';
import '../models/app_theme_preset.dart';
import '../models/geofence_system_state.dart';

final initialAppThemePresetProvider = Provider<AppThemePreset>(
  (ref) => AppThemePreset.fallback,
);

final appThemeProvider = NotifierProvider<AppThemeNotifier, AppThemePreset>(
  AppThemeNotifier.new,
);

class AppThemeNotifier extends Notifier<AppThemePreset> {
  @override
  AppThemePreset build() => ref.read(initialAppThemePresetProvider);

  Future<void> setTheme(AppThemePreset preset) async {
    if (state == preset) {
      return;
    }
    state = preset;
    await ref.read(settingsServiceProvider).setAppThemePreset(preset);
  }
}

abstract class GeofenceSystemStatusService {
  Future<GeofenceSystemState> inspect({
    required bool hasActiveHome,
    required bool hasCoordinates,
  });
}

class DeviceGeofenceSystemStatusService implements GeofenceSystemStatusService {
  @override
  Future<GeofenceSystemState> inspect({
    required bool hasActiveHome,
    required bool hasCoordinates,
  }) async {
    if (!hasActiveHome) {
      return const GeofenceSystemState(GeofenceSystemIssue.noActiveHome);
    }
    if (!hasCoordinates) {
      return const GeofenceSystemState(GeofenceSystemIssue.missingCoordinates);
    }
    if (!await Geolocator.isLocationServiceEnabled()) {
      return const GeofenceSystemState(
        GeofenceSystemIssue.locationServicesDisabled,
      );
    }

    final permission = await Geolocator.checkPermission();
    return switch (permission) {
      LocationPermission.denied => const GeofenceSystemState(
        GeofenceSystemIssue.permissionDenied,
      ),
      LocationPermission.deniedForever => const GeofenceSystemState(
        GeofenceSystemIssue.permissionDeniedForever,
      ),
      LocationPermission.whileInUse => const GeofenceSystemState(
        GeofenceSystemIssue.backgroundPermissionRequired,
      ),
      LocationPermission.always => const GeofenceSystemState(
        GeofenceSystemIssue.ready,
      ),
      _ => const GeofenceSystemState(GeofenceSystemIssue.permissionDenied),
    };
  }
}

final geofenceSystemStatusServiceProvider =
    Provider<GeofenceSystemStatusService>(
      (ref) => DeviceGeofenceSystemStatusService(),
    );

final geofenceSystemStatusProvider = FutureProvider<GeofenceSystemState>((
  ref,
) async {
  final currentHome = ref.watch(currentHomeProvider);
  return ref
      .watch(geofenceSystemStatusServiceProvider)
      .inspect(
        hasActiveHome: currentHome != null,
        hasCoordinates: currentHome?.hasCoordinates == true,
      );
});