use chrono::{Local, NaiveDate};
use serde::Serialize;
use sqlx::SqlitePool;
use waterlevel::WaterlevelDay;

use crate::AMOUNT_DAYS_TO_SHOW_TRIPS_AHEAD;

use self::{
    event::{Event, EventWithUserAndTriptype},
    trip::{Trip, TripWithUserAndType},
    waterlevel::Waterlevel,
    weather::Weather,
};
use boatreservation::{BoatReservation, BoatReservationWithDetails};
use std::collections::HashMap;

pub mod event;
pub mod log;
pub mod notification;
pub mod personal;
pub mod role;
pub mod trip;
pub mod tripdetails;
pub mod triptype;
pub mod user;
pub mod usertrip;
pub mod waterlevel;
pub mod weather;

#[derive(Serialize, Debug)]
pub struct Day {
    day: NaiveDate,
    events: Vec<EventWithUserAndTriptype>,
    trips: Vec<TripWithUserAndType>,
    is_pinned: bool,
    regular_sees_this_day: bool,
    max_waterlevel: Option<WaterlevelDay>,
    weather: Option<Weather>,
    boat_reservations: HashMap<String, Vec<BoatReservationWithDetails>>,
}

impl Day {
    pub async fn new(db: &SqlitePool, day: NaiveDate, is_pinned: bool) -> Self {
        let today = Local::now().date_naive();
        let day_diff = (day - today).num_days() + 1;
        let regular_sees_this_day = day_diff <= AMOUNT_DAYS_TO_SHOW_TRIPS_AHEAD;
        if is_pinned {
            Self {
                day,
                events: Event::get_pinned_for_day(db, day).await,
                trips: Trip::get_pinned_for_day(db, day).await,
                is_pinned,
                regular_sees_this_day,
                max_waterlevel: Waterlevel::max_waterlevel_for_day(db, day).await,
                weather: Weather::find_by_day(db, day).await,
                boat_reservations: BoatReservation::with_groups(
                    BoatReservation::for_day(db, day).await,
                ),
            }
        } else {
            Self {
                day,
                events: Event::get_for_day(db, day).await,
                trips: Trip::get_for_day(db, day).await,
                is_pinned,
                regular_sees_this_day,
                max_waterlevel: Waterlevel::max_waterlevel_for_day(db, day).await,
                weather: Weather::find_by_day(db, day).await,
                boat_reservations: BoatReservation::with_groups(
                    BoatReservation::for_day(db, day).await,
                ),
            }
        }
    }
    pub async fn new_guest(db: &SqlitePool, day: NaiveDate, is_pinned: bool) -> Self {
        let mut day = Self::new(db, day, is_pinned).await;

        day.events.retain(|e| e.event.allow_guests);
        day.trips.retain(|t| t.trip.allow_guests);

        day
    }
}