import 'package:doublefeel_flutter/core/services/user_state_service.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:get/get.dart';
import 'package:permission_handler/permission_handler.dart';

import '../../../../core/services/health_kit_upload_service.dart';
import '../../../../core/util/platform.dart';
import '../../../routes/app_pages.dart';

class UserOnboardingController extends GetxController {
  int totalPages = 9;

  final currentPageIndex = 0.obs;
  final selections = <int, Set<int>>{}.obs;
  final selectionVersion = 0.obs;

  bool hasSelection(int pageIndex) =>
      selections[pageIndex]?.isNotEmpty ?? false;

  bool isSelected(int pageIndex, int optionIndex) =>
      selections[pageIndex]?.contains(optionIndex) ?? false;

  bool canContinue(int pageIndex) {
    if (Get.arguments?['type'] == 'MembershipOfferPage') {
      return true;
    }
    return switch (pageIndex) {
      1 || 2 || 3 => hasSelection(pageIndex),
      _ => true,
    };
  }

  @override
  void onInit() {
    totalPages = Get.arguments?['type'] == 'MembershipOfferPage'
        ? (Get.arguments?['needBindSuccessGuide'] == true ? 2 : 1)
        : 9;
    super.onInit();
  }

  void toggleOption({
    required int pageIndex,
    required int optionIndex,
    required bool multiple,
    bool exclusive = false,
    Set<int> exclusiveOptionIndexes = const {},
  }) {
    final next = Set<int>.of(selections[pageIndex] ?? const <int>{});

    if (multiple) {
      if (next.contains(optionIndex)) {
        next.remove(optionIndex);
      } else if (exclusive) {
        next
          ..clear()
          ..add(optionIndex);
      } else {
        next.removeAll(exclusiveOptionIndexes);
        next.add(optionIndex);
      }
    } else {
      next
        ..clear()
        ..add(optionIndex);
    }

    if (next.isEmpty) {
      selections.remove(pageIndex);
    } else {
      selections[pageIndex] = next;
    }
    selectionVersion.value++;
    selections.refresh();
  }

  void goBack() {
    if (currentPageIndex.value > 0) {
      currentPageIndex.value--;
      return;
    }
    if (Get.key.currentState?.canPop() ?? false) {
      Get.back();
    } else {
      SystemNavigator.pop();
    }
  }

  Future<void> goNext() async {
    final pageIndex = currentPageIndex.value;
    if (!await prepareContinue(pageIndex)) {
      return;
    }
    if (pageIndex >= totalPages - 1) {
      finishOnboarding();
      return;
    }
    currentPageIndex.value++;
  }

  Future<bool> prepareContinue(int pageIndex) async {
    if (!canContinue(pageIndex)) {
      return false;
    }

    if (pageIndex == 7) {
      await requestHealthAuthorization();
    } else if (pageIndex == 8) {
      await requestNotificationAuthorization();
    }

    return true;
  }

  void finishOnboarding() {
    if (Get.arguments?['type'] == 'MembershipOfferPage') {
      Get.offAllNamed(AppRoutes.home);
    } else {
      final userStateService = Get.find<UserStateService>();
      if (userStateService.isBound) {
        Get.offAllNamed(AppRoutes.home);
      } else {
        Get.offAllNamed(AppRoutes.bindPartner);
      }
    }
  }

  Future<void> requestHealthAuthorization() async {
    if (isAndroid) {
      return;
    }
    try {
      await Get.find<HealthKitUploadService>().requestClientAuthorization();
    } catch (error) {
      debugPrint('Health authorization skipped: $error');
    }
  }

  Future<void> requestNotificationAuthorization() async {
    try {
      final result = await Permission.notification.request();
      if (result.isGranted) {
        debugPrint('Notification authorization granted');
      } else {
        debugPrint('Notification authorization skipped');
      }
    } catch (error) {
      debugPrint('Notification authorization skipped: $error');
    }
  }
}