EM2_ERP/em2rp/lib/views/calendar_page.dart

import 'package:em2rp/providers/local_user_provider.dart';
import 'package:em2rp/providers/event_provider.dart';
import 'package:flutter/material.dart';
import 'package:em2rp/views/widgets/custom_app_bar.dart';
import 'package:em2rp/views/widgets/nav/main_drawer.dart';
import 'package:provider/provider.dart';
import 'package:table_calendar/table_calendar.dart';
import 'package:em2rp/models/event_model.dart';
import 'package:em2rp/views/widgets/calendar_widgets/event_details.dart';
import 'package:intl/date_symbol_data_local.dart';
import 'package:em2rp/views/widgets/calendar_widgets/month_view.dart';
import 'package:em2rp/views/widgets/calendar_widgets/week_view.dart';
import 'package:em2rp/views/pages/event_add_page.dart';

class CalendarPage extends StatefulWidget {
  const CalendarPage({super.key});

  @override
  State<CalendarPage> createState() => _CalendarPageState();
}

class _CalendarPageState extends State<CalendarPage> {
  CalendarFormat _calendarFormat = CalendarFormat.month;
  DateTime _focusedDay = DateTime.now();
  DateTime? _selectedDay;
  EventModel? _selectedEvent;

  @override
  void initState() {
    super.initState();
    initializeDateFormatting('fr_FR', null);
    Future.microtask(() => _loadEvents());
  }

  Future<void> _loadEvents() async {
    final localAuthProvider =
        Provider.of<LocalUserProvider>(context, listen: false);
    final eventProvider = Provider.of<EventProvider>(context, listen: false);
    final userId = localAuthProvider.uid;
    print('Permissions utilisateur: ${localAuthProvider.permissions}');
    final canViewAllEvents = localAuthProvider.hasPermission('view_all_events');
    print('canViewAllEvents: $canViewAllEvents');

    if (userId != null) {
      await eventProvider.loadUserEvents(userId,
          canViewAllEvents: canViewAllEvents);
    }
  }

  void _changeWeek(int delta) {
    setState(() {
      _focusedDay = _focusedDay.add(Duration(days: 7 * delta));
    });
  }

  @override
  Widget build(BuildContext context) {
    final eventProvider = Provider.of<EventProvider>(context);
    final localUserProvider = Provider.of<LocalUserProvider>(context);
    final isAdmin = localUserProvider.role == 'ADMIN';
    final isMobile = MediaQuery.of(context).size.width < 600;

    if (eventProvider.isLoading) {
      return const Scaffold(
        body: Center(
          child: CircularProgressIndicator(),
        ),
      );
    }

    return Scaffold(
      appBar: const CustomAppBar(
        title: 'Calendrier',
      ),
      drawer: const MainDrawer(currentPage: '/calendar'),
      body: isMobile ? _buildMobileLayout() : _buildDesktopLayout(),
      floatingActionButton: isAdmin
          ? FloatingActionButton(
              backgroundColor: Colors.white,
              onPressed: () {
                Navigator.of(context).push(
                  MaterialPageRoute(
                    builder: (context) => const EventAddPage(),
                  ),
                );
              },
              child: const Icon(Icons.add, color: Colors.red),
              tooltip: 'Ajouter un événement',
            )
          : null,
    );
  }

  Widget _buildDesktopLayout() {
    final eventProvider = Provider.of<EventProvider>(context);
    return Row(
      children: [
        // Calendrier (65% de la largeur)
        Expanded(
          flex: 65,
          child: _buildCalendar(),
        ),
        // Détails de l'événement (35% de la largeur)
        Expanded(
          flex: 35,
          child: _selectedEvent != null
              ? EventDetails(
                  event: _selectedEvent!,
                  selectedDate: _selectedDay,
                  events: eventProvider.events,
                  onSelectEvent: (event, date) {
                    setState(() {
                      _selectedEvent = event;
                      _selectedDay = date;
                    });
                  },
                )
              : Center(
                  child: _selectedDay != null
                      ? Text('Aucun événement ne démarre à cette date')
                      : const Text(
                          'Sélectionnez un événement pour voir les détails'),
                ),
        ),
      ],
    );
  }

  Widget _buildMobileLayout() {
    final eventProvider = Provider.of<EventProvider>(context);
    return Column(
      children: [
        // Calendrier
        Expanded(
          child: _buildCalendar(),
        ),
        // Détails de l'événement
        if (_selectedEvent != null)
          Expanded(
            child: EventDetails(
              event: _selectedEvent!,
              selectedDate: _selectedDay,
              events: eventProvider.events,
              onSelectEvent: (event, date) {
                setState(() {
                  _selectedEvent = event;
                  _selectedDay = date;
                });
              },
            ),
          ),
        if (_selectedEvent == null && _selectedDay != null)
          Expanded(
            child: Center(
              child: Text('Aucun événement ne démarre à cette date'),
            ),
          ),
      ],
    );
  }

  Widget _buildCalendar() {
    final eventProvider = Provider.of<EventProvider>(context);

    if (_calendarFormat == CalendarFormat.week) {
      return WeekView(
        focusedDay: _focusedDay,
        events: eventProvider.events,
        onWeekChange: _changeWeek,
        onEventSelected: (event) {
          setState(() {
            _selectedEvent = event;
            _selectedDay = event.startDateTime;
          });
        },
        onSwitchToMonth: () {
          setState(() {
            _calendarFormat = CalendarFormat.month;
          });
        },
        onDaySelected: (selectedDay) {
          final eventsForDay = eventProvider.events
              .where((e) =>
                  e.startDateTime.year == selectedDay.year &&
                  e.startDateTime.month == selectedDay.month &&
                  e.startDateTime.day == selectedDay.day)
              .toList();
          eventsForDay
              .sort((a, b) => a.startDateTime.compareTo(b.startDateTime));
          setState(() {
            _selectedDay = selectedDay;
            if (eventsForDay.isNotEmpty) {
              _selectedEvent = eventsForDay.first;
            } else {
              _selectedEvent = null;
            }
          });
          if (eventsForDay.isEmpty) {
            ScaffoldMessenger.of(context).showSnackBar(
              const SnackBar(
                content: Text("Aucun événement ne démarre à cette date."),
                duration: Duration(seconds: 2),
              ),
            );
          }
        },
        selectedEvent: _selectedEvent,
      );
    } else {
      return MonthView(
        focusedDay: _focusedDay,
        selectedDay: _selectedDay,
        calendarFormat: _calendarFormat,
        events: eventProvider.events,
        onDaySelected: (selectedDay, focusedDay) {
          final eventsForDay = eventProvider.events
              .where((event) =>
                  event.startDateTime.year == selectedDay.year &&
                  event.startDateTime.month == selectedDay.month &&
                  event.startDateTime.day == selectedDay.day)
              .toList()
            ..sort((a, b) => a.startDateTime.compareTo(b.startDateTime));
          setState(() {
            _selectedDay = selectedDay;
            _focusedDay = focusedDay;
            if (eventsForDay.isNotEmpty) {
              _selectedEvent = eventsForDay.first;
            } else {
              _selectedEvent = null;
            }
          });
        },
        onFormatChanged: (format) {
          setState(() {
            _calendarFormat = format;
          });
        },
        onPageChanged: (focusedDay) {
          setState(() {
            _focusedDay = focusedDay;
          });
        },
        onEventSelected: (event) {
          setState(() {
            _selectedEvent = event;
          });
        },
      );
    }
  }
}