mod data;

use std::borrow::BorrowMut;

use moka::future::Cache;
use rand::{seq::SliceRandom, Rng};
use rand_pcg::Pcg64;
use rand_seeder::Seeder;
use rocket_dyn_templates::Template;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use data::{TITLES,DESCRIPTIONS,TOGGLES};

/// A struct to represent the content of a form.
/// Contains a title, description, 0 or more FormToggle and buttons
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct FormContent {
    title: String,
    description: String,
    toggles: Option<Vec<FormToggle>>,
    buttons: Vec<FormButton>,
}

/// A struct representing the content of a form / popup
impl FormContent {
    /// Creates a new FormContent with random values, given a Pcg64 pseudo-random number generator
    fn new(rng: &mut Pcg64) -> Self {
        const MAX_TOGGLES: usize = 7; // WARNING:changing this value will change the output for uuid generated forms invalid

        // randomly create choose a title and description
        let title = TITLES.choose(rng).unwrap_or(&"").to_string();
        let description = DESCRIPTIONS.choose(rng).unwrap_or(&"").to_string();

        // include a random number of toggles
        let toggle_len = rng.gen_range(0..=MAX_TOGGLES);

        // select a random sample of that number of toggles
        let toggle_samples = TOGGLES.choose_multiple(rng, toggle_len);

        // create the toggles given the number of toggles
        let toggles: Option<Vec<FormToggle>> = Some(
            toggle_samples
                .map(|(x, y, z)| FormToggle {
                    // set the name of the toggle
                    name: (*x).to_string(),
                    // set the description of the toggle
                    description: (*y).to_string(),
                    // randomly generate a boolean for the initial status
                    initial_status: rng.gen_range(0..=1) != 0,
                    // set the desired status of the toggle
                    desired_status: *z,
                    // set the selectors for the toggle
                    selectors: HTMLSelectors {
                        // ids for the toggle
                        ids: vec![],
                        // classes for the toggle
                        classes: vec![],
                    },
                })
                .collect(),
        );

        // create the accept and reject buttons
        let mut buttons = vec![FormButton::accept_all()];

        // if toggles exist, add the save button
        if toggle_len > 0 {
            buttons.push(FormButton::save());
            if rng.gen_range(0..4) != 0 { buttons.push(FormButton::reject_all()); }
        } else {
            buttons.push(FormButton::reject_all());
        }

        // return the form with populated content
        FormContent {
            title,
            description,
            toggles,
            buttons,
        }
    }

    /// Returns the toggles that are part of the form
    pub fn get_toggles(&self) -> Option<Vec<FormToggle>> {
        self.toggles.clone()
    }
}

impl Default for FormContent {
    fn default() -> Self {
        Self {
            title: "".to_string(),
            description: "".to_string(),
            toggles: None,
            buttons: vec![],
        }
    }
}

/// A struct representing a button in a form / popup
#[derive(Debug, Serialize, Deserialize, Clone)]
struct FormButton {
    name: String,
    value: String,
    is_submit: bool,
    on_click: Option<String>,
    selectors: HTMLSelectors,
}

impl FormButton {
    /// Creates a new FormButton with the name "accept" and the value "Accept All Cookies"
    pub fn accept_all() -> Self {
        FormButton {
            name: "accept".to_string(),
            value: "Accept All Cookies".to_string(),
            is_submit: true,
            on_click: None,
            selectors: HTMLSelectors {
                ids: vec![],
                classes: vec![],
            },
        }
    }

    /// Creates a new FormButton with the name "reject" and the value "Reject All Cookies"
    pub fn reject_all() -> Self {
        FormButton {
            name: "reject".to_string(),
            value: "Reject All Cookies".to_string(),
            is_submit: true,
            on_click: None,
            selectors: HTMLSelectors {
                ids: vec![],
                classes: vec![],
            },
        }
    }

    /// Creates a new FormButton with the name "save" and the value "Save Cookie Settings"
    pub fn save() -> Self {
        FormButton {
            name: "save".to_string(),
            value: "Save Cookie Settings".to_string(),
            is_submit: true,
            on_click: None,
            selectors: HTMLSelectors {
                ids: vec![],
                classes: vec![],
            },
        }
    }
}

/// A struct representing the content for a form toggle
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct FormToggle {
    name: String,
    description: String,
    initial_status: bool,
    desired_status: bool,
    selectors: HTMLSelectors,
}

impl FormToggle {
    /// Returns the initial and desired statuses of the toggle
    pub fn get_statuses(&self) -> (bool, bool) {
        (self.initial_status, self.desired_status)
    }
}

/// A struct representing HTML selectors for an element
#[derive(Debug, Serialize, Deserialize, Clone)]
struct HTMLSelectors {
    ids: Vec<String>,
    classes: Vec<String>,
}

/// An enum representing the type of cookie form
/// Can be a `Banner` or a `Popup`
#[derive(Debug, Serialize, Deserialize, Clone)]
enum TemplateType {
    Banner,
    Popup,
}

impl TemplateType {
    /// Creates a template type given a random number generator
    /// 0 => Banner
    /// 1 => Popup
    pub fn new(rng: &mut Pcg64) -> Option<Self> {
        Some(match rng.gen_range(0..=1) {
            0 => TemplateType::Banner,
            1 => TemplateType::Popup,
            _ => unreachable!(),
        })
    }
}

/// A struct representing an oven
/// Contains an id, a template type, and a form content
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Oven {
    id: Uuid,
    template: Option<TemplateType>,
    form: FormContent,
}

impl Default for Oven {
    fn default() -> Self {
        Self::new()
    }
}

impl Oven {
    /// Creates a new oven with a random id
    pub fn new() -> Self {
        let id = Uuid::new_v4();
        Self::preheat(id)
    }

    /// Creates a new oven with a given id
    pub fn preheat(id: Uuid) -> Self {
        // create a new random number generator using the Pcg64 algorithm
        let mut rng: Pcg64 = Seeder::from(id).make_rng();
        
        // choose a random type of popup
        let template = TemplateType::new(rng.borrow_mut());

        // create the new form content, passing the rng to allow deterministic results
        let form = FormContent::new(rng.borrow_mut());

        Self { id, form, template }
    }

    /// Gets the id of the oven
    pub fn get_uuid(&self) -> Uuid {
        self.id
    }

    /// Gets the form content of the oven
    pub fn get_form(&self) -> FormContent {
        self.form.clone()
    }

    /// Renders the oven as through a tera template
    pub fn render(&self) -> Template {
        let name = if let Some(template) = &self.template {
            match template {
                TemplateType::Popup => "popup",
                _ => "popup",
            }
        } else {
            unreachable!();
        };
        Template::render(name, self)
    }
}

/// A struct representing a cache of ovens
pub struct PopupCache {
    cache: Cache<Uuid, Oven>,
}

impl Default for PopupCache {
    fn default() -> Self {
        Self {
            cache: Cache::new(1000),
        }
    }
}

impl PopupCache {
    /// Gets an oven from the cache given an id
    pub async fn get(&self, id: Uuid) -> Option<Oven> {
        self.cache.get(&id).await
    }

    /// Inserts an oven into the cache given an id
    pub async fn insert(&self, id: Uuid, data: Oven) {
        self.cache.insert(id, data).await;
    }

    /// Gets an oven from the cache given an id, or inserts one and returns if one does not exist
    pub async fn get_or_create(&self, id: Option<Uuid>) -> Oven {
        match id {
            Some(id) => {
                // if the id is already in the cache, return the resulting oven
                if let Some(oven) = self.cache.get(&id).await {
                    oven
                } else {
                    // create a new oven with the id
                    let oven = Oven::preheat(id);
                    
                    // insert it into the cache
                    self.cache.insert(oven.get_uuid(), oven.clone()).await;

                    // return it
                    oven
                }
            }
            None => {
                // create a new oven randomly
                let oven = Oven::new();

                // insert it into the cache
                self.cache.insert(oven.get_uuid(), oven.clone()).await;

                // return it
                oven
            }
        }
    }

    /// Invalidate the cache
    pub fn flush(&self) {
        self.cache.invalidate_all();
    }

    /// Dump all items from the cache into an iterator
    pub async fn dump(&self) -> moka::future::Iter<'_, Uuid, Oven> {
        self.cache.run_pending_tasks().await;
        self.cache.iter()
    }

    /// Return the (approximate) size of the cache
    pub async fn size(&self) -> u64 {
        self.cache.run_pending_tasks().await;
        self.cache.entry_count()
    }
}