use crate::SessionConfig;
use chrono::{DateTime, Duration, Utc};
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, fmt::Debug};

/// The Store and Configured Data for a Session.
///
/// # Examples
/// ```rust ignore
/// use session::{SessionConfig, SessionData};
/// use uuid::Uuid;
///
/// let config = SessionConfig::default();
/// let token = Uuid::new_v4();
/// let session_data = SessionData::new(token.to_string(), true, &config);
/// ```
///
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct SessionData {
    #[serde(skip)]
    pub(crate) id: String,
    pub(crate) data: HashMap<String, String>,
    #[serde(default = "serde_expires_default")]
    pub(crate) expires: DateTime<Utc>,
    #[serde(default = "serde_autoremove_default")]
    pub(crate) autoremove: DateTime<Utc>,
    #[serde(skip)]
    pub(crate) destroy: bool,
    #[serde(skip)]
    pub(crate) renew: bool,
    pub(crate) longterm: bool,
    #[serde(skip)]
    pub(crate) store: bool,
    #[serde(skip)]
    pub(crate) update: bool,
    #[serde(skip)]
    pub(crate) requests: usize,
    #[serde(skip)]
    pub(crate) last_db_update: DateTime<Utc>,
}

/// Fallback for sessions persisted before `expires` was serialized (or written
/// by an older release): treat them as still valid for the configured lifespan
/// instead of instantly expiring, which would wipe the stored session data.
fn serde_expires_default() -> DateTime<Utc> {
    Utc::now() + Duration::days(7)
}

/// Same reasoning as [`serde_expires_default`]; an unloaded session should not
/// be treated as immediately eligible for memory eviction.
fn serde_autoremove_default() -> DateTime<Utc> {
    Utc::now() + Duration::minutes(60)
}

impl SessionData {
    /// Constructs a new SessionData.
    ///
    /// # Examples
    /// ```rust ignore
    /// use session::{SessionConfig, SessionData};
    /// use uuid::Uuid;
    ///
    /// let config = SessionConfig::default();
    /// let token = Uuid::new_v4();
    /// let session_data = SessionData::new(token.to_string(), true, &config);
    /// ```
    ///
    #[inline]
    pub(crate) fn new(id: String, storable: bool, config: &SessionConfig) -> Self {
        Self {
            id,
            data: HashMap::new(),
            expires: Utc::now() + config.lifespan,
            destroy: false,
            renew: false,
            autoremove: Utc::now() + config.memory.memory_lifespan,
            longterm: false,
            store: storable,
            update: true,
            requests: 1,
            last_db_update: Utc::now(),
        }
    }

    /// Determines whether the session has expired.
    ///
    /// # Examples
    /// ```rust ignore
    /// use session::{SessionConfig, SessionData};
    /// use uuid::Uuid;
    ///
    /// let config = SessionConfig::default();
    /// let token = Uuid::new_v4();
    /// let session_data = SessionData::new(token.to_string(), true, &config);
    /// let expired = session_data.expired();
    /// ```
    ///
    #[inline]
    pub(crate) fn expired(&self) -> bool {
        self.expires < Utc::now()
    }

    /// Validates and checks if the Session is to be destroyed.
    /// If so the Sessions Data is Cleared.
    /// autoremove is then updated for the session regardless.
    ///
    /// # Examples
    /// ```rust ignore
    /// use session::{SessionConfig, SessionData};
    /// use uuid::Uuid;
    ///
    /// let config = SessionConfig::default();
    /// let token = Uuid::new_v4();
    /// let mut session_data = SessionData::new(token.to_string(), true, &config);
    /// let expired = session_data.service_clear(Duration::days(5));
    /// ```
    ///
    #[inline]
    pub(crate) fn service_clear(&mut self, memory_lifespan: Duration, clear_check: bool) {
        if clear_check && self.autoremove < Utc::now() {
            self.update = true;

            if self.expired() {
                self.data.clear();
            }
        }

        self.autoremove = Utc::now() + memory_lifespan;
    }

    /// Set session flags to renew/regenerate the ID.
    /// This deletes data from the database keyed with the old ID.
    /// This helps to enhance security when logging into secure
    /// areas on a website. The current session's data will be
    /// stored with the new ID.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.renew();
    /// ```
    ///
    #[inline]
    pub fn renew(&mut self) {
        self.renew = true;
        self.update = true;
    }

    /// Sets the Session to force update the database.
    /// This will increase the Timer on the sessions store
    /// making the session live longer in the persistent database.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.update();
    /// ```
    ///
    #[inline]
    pub fn update(&mut self) {
        self.update = true;
    }

    /// Sets the Current Session to be Destroyed.
    /// This will Deleted the Session and Cookies upon Response Phase.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.destroy();
    /// ```
    ///
    #[inline]
    pub fn destroy(&mut self) {
        self.destroy = true;
    }

    /// Sets the Current Session to a long term expiration. Useful for Remember Me setups.
    /// This will also update the database on Response Phase.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.set_longterm(true);
    /// ```
    ///
    #[inline]
    pub fn set_longterm(&mut self, longterm: bool) {
        self.longterm = longterm;
        self.update = true;
    }

    /// Sets the Current Session to be storable.
    /// This will also update the database on Response Phase.
    ///
    /// This is only used when `SessionMode` is Manual or Storable.
    /// This will allow the Session to be stored if true.
    /// This will delete and not allow a session to be stored if false.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.set_store(true);
    /// ```
    ///
    #[inline]
    pub fn set_store(&mut self, can_store: bool) {
        self.store = can_store;
        self.update = true;
    }

    /// Gets data from the Session's HashMap
    ///
    /// Provides an Option<T> that returns the requested data from the Sessions store.
    /// Returns None if Key does not exist or if serde_json failed to deserialize.
    ///
    /// # Examples
    /// ```rust ignore
    /// let id = session.get("user-id").unwrap_or(0);
    /// ```
    ///
    ///Used to get data stored within SessionDatas hashmap from a key value.
    ///
    #[inline]
    pub fn get<T: serde::de::DeserializeOwned>(&self, key: &str) -> Option<T> {
        let string = self.data.get(key)?;
        serde_json::from_str(string).ok()
    }

    /// Removes a Key from the Current Session's HashMap returning it.
    /// This will also update the database on Response Phase.
    ///
    /// Provides an Option<T> that returns the requested data from the Sessions store.
    /// Returns None if Key does not exist or if serde_json failed to deserialize.
    ///
    /// # Examples
    /// ```rust ignore
    /// let id = session.get_remove("user-id").unwrap_or(0);
    /// ```
    ///
    /// Used to get data stored within SessionDatas hashmap from a key value.
    ///
    #[inline]
    pub fn get_remove<T: serde::de::DeserializeOwned>(&mut self, key: &str) -> Option<T> {
        let string = self.data.remove(key)?;
        self.update = true;
        serde_json::from_str(&string).ok()
    }

    /// Sets data to the Current Session's HashMap.
    /// This will also update the database on Response Phase.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.set("user-id", 1);
    /// ```
    ///
    #[inline]
    pub fn set(&mut self, key: &str, value: impl Serialize) {
        let value = serde_json::to_string(&value).unwrap_or_else(|_| "".to_string());
        let _ = self.data.insert(key.to_string(), value);
        self.update = true;
    }

    /// Removes a Key from the Current Session's HashMap.
    /// Does not process the String into a Type, Just removes it.
    /// This will also update the database on Response Phase.
    ///
    /// # Examples
    /// ```rust ignore
    /// let _ = session.remove("user-id");
    /// ```
    ///
    #[inline]
    pub fn remove(&mut self, key: &str) {
        let _ = self.data.remove(key);
        self.update = true;
    }

    /// Clears all data from the Current Session's HashMap.
    /// This will also update the database on Response Phase.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.clear();
    /// ```
    ///
    #[inline]
    pub fn clear(&mut self) {
        self.data.clear();
        self.update = true;
    }

    /// Removes a Request from the request counter
    /// used to determine if parallel requests exist.
    /// prevents data deletion until requests == 0.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.remove_request();
    /// ```
    ///
    #[inline]
    pub(crate) fn remove_request(&mut self) {
        self.requests = self.requests.saturating_sub(1);
    }

    /// Removes a Request from the request counter
    /// used to determine if parallel requests exist.
    /// prevents data deletion until requests == 0.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.set_request();
    /// ```
    ///
    #[inline]
    pub(crate) fn set_request(&mut self) {
        self.requests = self.requests.saturating_add(1);
    }

    /// checks if a session has a request still.
    ///
    /// # Examples
    /// ```rust ignore
    /// session.is_parallel();
    /// ```
    ///
    #[inline]
    pub(crate) fn is_parallel(&self) -> bool {
        self.requests >= 1
    }
}

/// Internal Timers
///
/// used to keep track of the last ran expiration check for both database and memory session data.
///
#[derive(Debug)]
pub(crate) struct SessionTimers {
    pub(crate) last_expiry_sweep: DateTime<Utc>,
    pub(crate) last_database_expiry_sweep: DateTime<Utc>,
}