import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:lottie/lottie.dart';

import '../../../../core/constants/intent_keys.dart';
import '../../../../core/services/user_state_service.dart';
import '../../../../data/local/local_storage.dart';
import '../../../../data/local/user_preferences_storage.dart';
import '../../../routes/app_pages.dart';
import '../../activity_burn_report/controllers/activity_burn_report_logic.dart';
import '../../activity_burn_report/views/activity_burn_report_view.dart';
import '../../app_review_prompt/logic/app_review_prompt_logic.dart';
import '../../home/widgets/trend/trend_type_tab_bar.dart';
import '../../hrv_report/controllers/hrv_report_logic.dart';
import '../../hrv_report/views/hrv_report_view.dart';
import '../../report_common/models/health_report_query.dart';
import '../../report_common/models/report_period.dart';
import '../../report_common/widgets/health_report_subject_scope.dart';
import '../../sleep_report/controllers/sleep_report_logic.dart';
import '../../sleep_report/views/sleep_report_view.dart';

class HealthTrendContent extends StatefulWidget {
  const HealthTrendContent({
    super.key,
    required this.query,
    required this.selectedTypeIndex,
    this.refreshToken = 0,
    this.allowTabSwipe = false,
    required this.onTypeChanged,
    required this.onQueryChanged,
    this.queryForType,
  });

  final HealthReportQuery query;
  final int selectedTypeIndex;
  final int refreshToken;

  /// Whether users can switch trend types by horizontally swiping the content.
  /// Tapping a tab remains available when this is false.
  final bool allowTabSwipe;
  final ValueChanged<int> onTypeChanged;
  final void Function(ReportPeriod period, DateTime date) onQueryChanged;
  final HealthReportQuery Function(int typeIndex)? queryForType;

  @override
  State<HealthTrendContent> createState() => _HealthTrendContentState();
}

class _HealthTrendContentState extends State<HealthTrendContent>
    with SingleTickerProviderStateMixin {
  static const _typeCount = 3;

  late final TabController _tabController;

  @override
  void initState() {
    super.initState();
    final initialIndex = _normalizedTypeIndex(widget.selectedTypeIndex);
    _tabController = TabController(
      length: _typeCount,
      vsync: this,
      initialIndex: initialIndex,
    );
    _tabController.addListener(() {
      if (!_tabController.indexIsChanging) {
        widget.onTypeChanged(_tabController.index);
      }
    });
    _correctInvalidTypeIndex(widget.selectedTypeIndex, initialIndex);
  }

  @override
  void didUpdateWidget(covariant HealthTrendContent oldWidget) {
    super.didUpdateWidget(oldWidget);
    if (oldWidget.selectedTypeIndex != widget.selectedTypeIndex) {
      final nextIndex = _normalizedTypeIndex(widget.selectedTypeIndex);
      if (_tabController.index != nextIndex) {
        _tabController.animateTo(nextIndex);
      }
      _correctInvalidTypeIndex(widget.selectedTypeIndex, nextIndex);
    }
  }

  int _normalizedTypeIndex(int index) {
    return index >= 0 && index < _typeCount ? index : 0;
  }

  void _correctInvalidTypeIndex(int requestedIndex, int normalizedIndex) {
    if (requestedIndex == normalizedIndex) return;
    WidgetsBinding.instance.addPostFrameCallback((_) {
      if (mounted) widget.onTypeChanged(normalizedIndex);
    });
  }

  @override
  void dispose() {
    _tabController.dispose();
    super.dispose();
  }

  HealthReportQuery _queryForType(int typeIndex) {
    return widget.queryForType?.call(typeIndex) ?? widget.query;
  }

  @override
  Widget build(BuildContext context) {
    final userPrefs = Get.find<UserPreferencesStorage>();
    return Obx(() {
      final preferences = userPrefs.preferences.value;
      final vipInfo = preferences.vipInfo;
      final isVip = vipInfo?.isVip ?? false;
      void openPurchase(String channelType) => Get.toNamed(
            Routes.PURCHASE,
            arguments: {IntentKeys.channelType: channelType},
          );

      return HealthReportSubjectScope(
        isSelf: widget.query.isSelf,
        child: Column(
          children: [
            TrendTypeTabBar(tabController: _tabController),
            Expanded(
              child: TabBarView(
                controller: _tabController,
                physics: widget.allowTabSwipe
                    ? null
                    : const NeverScrollableScrollPhysics(),
                children: [
                  _KeepAliveWrapper(
                    child: _HrvTrendSection(
                      query: _queryForType(0),
                      refreshToken: widget.refreshToken,
                      isSelected: widget.selectedTypeIndex == 0,
                      isVip: isVip,
                      onSubscribe: openPurchase,
                      onQueryChanged: widget.onQueryChanged,
                    ),
                  ),
                  _KeepAliveWrapper(
                    child: _ActivityBurnTrendSection(
                      query: _queryForType(1),
                      refreshToken: widget.refreshToken,
                      isSelected: widget.selectedTypeIndex == 1,
                      isVip: isVip,
                      onSubscribe: openPurchase,
                      onQueryChanged: widget.onQueryChanged,
                    ),
                  ),
                  _KeepAliveWrapper(
                    child: _SleepTrendSection(
                      query: _queryForType(2),
                      refreshToken: widget.refreshToken,
                      isSelected: widget.selectedTypeIndex == 2,
                      isVip: isVip,
                      onSubscribe: openPurchase,
                      onQueryChanged: widget.onQueryChanged,
                    ),
                  ),
                ],
              ),
            ),
          ],
        ),
      );
    });
  }
}

class _HealthTrendLoadingIndicator extends StatelessWidget {
  const _HealthTrendLoadingIndicator();

  static const _width = 130.0;
  static const _height = 90.0;
  static const _headerCenterOffset = Offset(0, -46);
  static const _visualCenterOffset = Offset(0, -8);

  @override
  Widget build(BuildContext context) {
    return Center(
      child: Transform.translate(
        offset: _headerCenterOffset,
        child: SizedBox(
          width: _width,
          height: _height,
          child: Transform.translate(
            offset: _visualCenterOffset,
            child: Lottie.asset(
              'assets/lottie/loading.json',
              width: _width,
              height: _height,
              repeat: true,
              animate: true,
            ),
          ),
        ),
      ),
    );
  }
}

class _HrvTrendSection extends StatefulWidget {
  const _HrvTrendSection({
    required this.query,
    required this.refreshToken,
    required this.isSelected,
    required this.isVip,
    required this.onSubscribe,
    required this.onQueryChanged,
  });

  final HealthReportQuery query;
  final int refreshToken;
  final bool isSelected;
  final bool isVip;
  final ValueChanged<String> onSubscribe;
  final void Function(ReportPeriod period, DateTime date) onQueryChanged;

  @override
  State<_HrvTrendSection> createState() => _HrvTrendSectionState();
}

class _HrvTrendSectionState extends State<_HrvTrendSection> {
  static const _hrvTrendLogMarker = '[OHOS_HRV_TREND_PROFILE]';

  late final HrvReportLogic _logic;
  late final Worker _periodWorker;
  late final Worker _dateWorker;
  var _syncingExternalQuery = false;
  var _queryNotificationScheduled = false;

  @override
  void initState() {
    super.initState();
    _logic = HrvReportLogic(initialTargetUserId: widget.query.targetUserId);
    _logic.initializeQuery(widget.query.period, widget.query.date);
    _periodWorker = ever(_logic.selectedPeriod, (period) {
      _scheduleQueryNotification();
    });
    _dateWorker = ever(_logic.selectedDate, (date) {
      _scheduleQueryNotification();
    });
    if (widget.isVip) {
      _logic.loadReport();
    }
  }

  @override
  void didUpdateWidget(covariant _HrvTrendSection oldWidget) {
    super.didUpdateWidget(oldWidget);
    if (oldWidget.query != widget.query) {
      _syncExternalQuery();
    } else if (oldWidget.refreshToken != widget.refreshToken &&
        widget.isSelected) {
      if (widget.isVip) {
        _logic.loadReport();
      }
    } else if (!oldWidget.isVip && widget.isVip) {
      _logic.loadReport();
    }
  }

  Future<void> _syncExternalQuery() async {
    _syncingExternalQuery = true;
    _logic.targetUserId.value = widget.query.targetUserId;
    _logHrvTrend(
      'section_syncExternalQuery_start period=${widget.query.period.name} '
      'date=${widget.query.date} targetUserId=${widget.query.targetUserId} '
      'isVip=${widget.isVip}',
    );
    try {
      if (widget.isVip) {
        await _logic.selectQuery(
          widget.query.period,
          widget.query.date,
          forceRefresh: false,
        );
      } else {
        _logic.initializeQuery(widget.query.period, widget.query.date);
      }
    } finally {
      _syncingExternalQuery = false;
      _logHrvTrend(
        'section_syncExternalQuery_finish period=${widget.query.period.name} '
        'date=${widget.query.date}',
      );
    }
  }

  void _scheduleQueryNotification() {
    if (_syncingExternalQuery ||
        !widget.isSelected ||
        _queryNotificationScheduled) {
      return;
    }
    _queryNotificationScheduled = true;
    Future.microtask(() {
      _queryNotificationScheduled = false;
      if (!mounted || _syncingExternalQuery || !widget.isSelected) return;
      _logHrvTrend(
        'section_notifyParentQueryChanged '
        'period=${_logic.selectedPeriod.value.name} '
        'date=${_logic.selectedDate.value}',
      );
      widget.onQueryChanged(
        _logic.selectedPeriod.value,
        _logic.selectedDate.value,
      );
    });
  }

  void _logHrvTrend(String message) {
    debugPrint('$_hrvTrendLogMarker $message');
  }

  @override
  void dispose() {
    _periodWorker.dispose();
    _dateWorker.dispose();
    _logic.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) => HrvReportView(
        logic: _logic,
        isVip: widget.isVip,
        onSubscribe: widget.onSubscribe,
        loadingIndicator: const _HealthTrendLoadingIndicator(),
      );
}

class _ActivityBurnTrendSection extends StatefulWidget {
  const _ActivityBurnTrendSection({
    required this.query,
    required this.refreshToken,
    required this.isSelected,
    required this.isVip,
    required this.onSubscribe,
    required this.onQueryChanged,
  });

  final HealthReportQuery query;
  final int refreshToken;
  final bool isSelected;
  final bool isVip;
  final ValueChanged<String> onSubscribe;
  final void Function(ReportPeriod period, DateTime date) onQueryChanged;

  @override
  State<_ActivityBurnTrendSection> createState() =>
      _ActivityBurnTrendSectionState();
}

class _ActivityBurnTrendSectionState extends State<_ActivityBurnTrendSection> {
  late final ActivityBurnReportLogic _logic;
  late final Worker _periodWorker;
  late final Worker _dateWorker;
  var _syncingExternalQuery = false;
  var _queryNotificationScheduled = false;

  @override
  void initState() {
    super.initState();
    _logic = ActivityBurnReportLogic(
      initialTargetUserId: widget.query.targetUserId,
    );
    _logic.initializeQuery(widget.query.period, widget.query.date);
    _periodWorker = ever(_logic.selectedPeriod, (period) {
      _scheduleQueryNotification();
    });
    _dateWorker = ever(_logic.selectedDate, (date) {
      _scheduleQueryNotification();
    });
    _logic.loadReport();
  }

  @override
  void didUpdateWidget(covariant _ActivityBurnTrendSection oldWidget) {
    super.didUpdateWidget(oldWidget);
    if (oldWidget.query != widget.query) {
      _syncExternalQuery();
    } else if (oldWidget.refreshToken != widget.refreshToken &&
        widget.isSelected) {
      _logic.loadReport();
    }
  }

  Future<void> _syncExternalQuery() async {
    _syncingExternalQuery = true;
    _logic.targetUserId.value = widget.query.targetUserId;
    try {
      await _logic.selectQuery(widget.query.period, widget.query.date);
    } finally {
      _syncingExternalQuery = false;
    }
  }

  void _scheduleQueryNotification() {
    if (_syncingExternalQuery ||
        !widget.isSelected ||
        _queryNotificationScheduled) {
      return;
    }
    _queryNotificationScheduled = true;
    Future.microtask(() {
      _queryNotificationScheduled = false;
      if (!mounted || _syncingExternalQuery || !widget.isSelected) return;
      widget.onQueryChanged(
        _logic.selectedPeriod.value,
        _logic.selectedDate.value,
      );
    });
  }

  @override
  void dispose() {
    _periodWorker.dispose();
    _dateWorker.dispose();
    _logic.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) => ActivityBurnReportView(
        logic: _logic,
        isVip: widget.isVip,
        onSubscribe: widget.onSubscribe,
        loadingIndicator: const _HealthTrendLoadingIndicator(),
        tooltipDismissDelayMs: 4000,
      );
}

class _SleepTrendSection extends StatefulWidget {
  const _SleepTrendSection({
    required this.query,
    required this.refreshToken,
    required this.isSelected,
    required this.isVip,
    required this.onSubscribe,
    required this.onQueryChanged,
  });

  final HealthReportQuery query;
  final int refreshToken;
  final bool isSelected;
  final bool isVip;
  final ValueChanged<String> onSubscribe;
  final void Function(ReportPeriod period, DateTime date) onQueryChanged;

  @override
  State<_SleepTrendSection> createState() => _SleepTrendSectionState();
}

class _SleepTrendSectionState extends State<_SleepTrendSection> {
  late final SleepReportLogic _logic;
  late final AppReviewPromptLogic _appReviewPromptLogic;
  late final Worker _periodWorker;
  late final Worker _dateWorker;
  var _syncingExternalQuery = false;
  var _queryNotificationScheduled = false;

  @override
  void initState() {
    super.initState();
    _logic = SleepReportLogic(
      initialTargetUserId: widget.query.targetUserId,
    );
    _appReviewPromptLogic = AppReviewPromptLogic(
      storage: Get.find<LocalStorage>(),
      userIdProvider: () => Get.find<UserStateService>().userId,
    );
    _logic.initializeQuery(widget.query.period, widget.query.date);
    _periodWorker = ever(_logic.selectedPeriod, (period) {
      _scheduleQueryNotification();
    });
    _dateWorker = ever(_logic.selectedDate, (date) {
      _scheduleQueryNotification();
    });
    _logic.loadReport();
  }

  @override
  void didUpdateWidget(covariant _SleepTrendSection oldWidget) {
    super.didUpdateWidget(oldWidget);
    if (oldWidget.query != widget.query) {
      _syncExternalQuery();
    } else if (oldWidget.refreshToken != widget.refreshToken &&
        widget.isSelected) {
      _logic.loadReport();
    }
  }

  Future<void> _syncExternalQuery() async {
    _syncingExternalQuery = true;
    _logic.targetUserId.value = widget.query.targetUserId;
    try {
      await _logic.selectQuery(widget.query.period, widget.query.date);
    } finally {
      _syncingExternalQuery = false;
    }
  }

  void _scheduleQueryNotification() {
    if (_syncingExternalQuery ||
        !widget.isSelected ||
        _queryNotificationScheduled) {
      return;
    }
    _queryNotificationScheduled = true;
    Future.microtask(() {
      _queryNotificationScheduled = false;
      if (!mounted || _syncingExternalQuery || !widget.isSelected) return;
      widget.onQueryChanged(
        _logic.selectedPeriod.value,
        _logic.selectedDate.value,
      );
    });
  }

  @override
  void dispose() {
    _periodWorker.dispose();
    _dateWorker.dispose();
    _logic.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) => SleepReportView(
        logic: _logic,
        isVip: widget.isVip,
        onSubscribe: widget.onSubscribe,
        onReportViewed: widget.isSelected
            ? _appReviewPromptLogic.recordPromptEligibility
            : null,
        loadingIndicator: const _HealthTrendLoadingIndicator(),
      );
}

class _KeepAliveWrapper extends StatefulWidget {
  const _KeepAliveWrapper({required this.child});

  final Widget child;

  @override
  State<_KeepAliveWrapper> createState() => _KeepAliveWrapperState();
}

class _KeepAliveWrapperState extends State<_KeepAliveWrapper>
    with AutomaticKeepAliveClientMixin {
  @override
  bool get wantKeepAlive => true;

  @override
  Widget build(BuildContext context) {
    super.build(context);
    return widget.child;
  }
}