import 'package:flisp_app/models/reminder.dart';
import 'package:flisp_app/provider/reminder_provider.dart';
import 'package:flisp_app/service/reminder_service.dart';
import 'package:flisp_app/utils/notify_utils.dart';
import 'package:flisp_app/widgets/awesome_dialog.dart';
import 'package:flisp_app/widgets/reminder_form.dart';
import 'package:flisp_app/widgets/reminder_widget.dart';
import 'package:flutter/material.dart';
import 'package:flutter_form_builder/flutter_form_builder.dart';
import 'package:provider/provider.dart';
import 'package:flisp_app/widgets/common.dart';

class RemindersPage extends StatefulWidget {
  final VoidCallback? onAddPressed;

  const RemindersPage({super.key, this.onAddPressed});

  @override
  State<RemindersPage> createState() => ReminderPageState();
}

class ReminderPageState extends State<RemindersPage> {
  final ReminderService reminderService = ReminderService();
  final NotifyService notifyService = NotifyService();

  List<Reminder> _reminders = [];

  void showAddDialog() {
    _showDialog(false, null);
  }

  @override
  void initState() {
    super.initState();
    _loadReminders();
  }

  Future<void> _loadReminders() async {
    final reminders = await updateReminders();
    if (mounted) {
      setState(() {
        _reminders = reminders;
      });
    }
  }

  Future<List<Reminder>> updateReminders() async {
    // 获取flutter_local_notifications中所有的通知ID
    final pendingNotifications = await notifyService.getPendingNotifications();
    print("notifyService: ${pendingNotifications.length}");
    final notificationIds = pendingNotifications.map((n) => n.id).toSet();

    // 获取Hive中所有的提醒
    final hiveReminders = reminderService.getAllReminders();
    print("hiveReminders: ${hiveReminders.length}");
    final hiveReminderIds = hiveReminders.map((r) => r.id).toSet();

    // 情况1：删除Hive中存在但通知中不存在的提醒（已触发或已取消）
    final remindersToDeleteFromHive =
        hiveReminders.where((reminder) {
          return !notificationIds.contains(reminder.id);
        }).toList();

    for (final reminder in remindersToDeleteFromHive) {
      await reminderService.deleteReminder(reminder);
    }

    // 情况2：对于通知中存在但Hive中不存在的提醒，重新创建（保留时间等完整信息）
    final remindersToRecreate =
        pendingNotifications.where((notification) {
          return !hiveReminderIds.contains(notification.id);
        }).toList();

    for (final notification in remindersToRecreate) {
      final newReminder = Reminder(
        id: notification.id,
        title: notification.title ?? '新提醒',
        content: notification.body ?? '',
        scheduledTime: DateTime.now().add(const Duration(days: 1)),
      );
      await reminderService.addReminder(newReminder);
    }

    // 更新本地列表
    _reminders = reminderService.getAllReminders();

    return _reminders;
  }

  @override
  Widget build(BuildContext context) {
    return buildBody(
      child: Column(
        children: [
          Expanded(
            child: buildReminderList(
              reminders: _reminders,
              onEditReminder: (reminder) {
                _showDialog(true, reminder);
              },
            ),
          ),
        ],
      ),
    );
  }

  // 显示对话框
  void _showDialog(bool isEditing, Reminder? reminder) {
    final reminderProvider = Provider.of<ReminderProvider>(
      context,
      listen: false,
    );

    if (isEditing) {
      reminderProvider.initForm(reminder!);
    } else {
      reminderProvider.resetForm();
    }

    final formKey = GlobalKey<FormBuilderState>();

    showAwesomeDialog(
      context: context,
      body: ReminderForm(
        formKey: formKey,
        isEditing: isEditing,
        initialReminder: reminder,
      ),
      onOk: () {
        if (formKey.currentState!.saveAndValidate()) {
          Navigator.of(context).pop();
          _saveOrUpdateReminder(isEditing, reminderProvider.formItem);
        }
      },
      onCancel: () {
        reminderProvider.resetForm();
      },
    );
  }

  // 保存提醒事项
  void _saveOrUpdateReminder(bool isEditing, Reminder reminder) async {
    late bool isSuccess;

    if (isEditing) {
      // 先删除
      await notifyService.cancelNotification(reminder.id);
      await reminderService.deleteReminder(reminder);
      // 在重新新建
      reminder.id = DateTime.now().millisecondsSinceEpoch ~/ 1000;
    }

    isSuccess = await reminderService.addReminder(reminder);

    await notifyService.scheduleNotification(
      id: reminder.id,
      title: reminder.title,
      body: reminder.content,
      scheduledTime: reminder.scheduledTime,
    );

    await _loadReminders();

    if (isSuccess) {
      showSuccessDialog(context, isEditing ? '更新成功' : '添加成功');
    } else {
      showErrorDialog(context, isEditing ? '更新失败' : '添加失败');
    }
  }
}