use fake::{Fake, Faker};
use rand::{distributions::{Distribution, Standard}, Rng};
use std::sync::{Mutex, OnceLock};
use strum_macros::{self, EnumIter, EnumString};

#[allow(unused_imports)] // trait into scope
use strum::IntoEnumIterator;

#[derive(Clone, Debug)]
pub struct Task {
    pub id: i32,
    pub label: TaskLabel,
    pub title: String,
    pub status: TaskStatus,
    pub priority: TaskPriority,
}

#[derive(Clone, Debug, EnumString, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub enum TaskLabel {
    Bug,
    Feature,
    Documentation,
}

#[derive(Clone, Debug, EnumString, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub enum TaskStatus {
    Backlog,
    Todo,
    InProgress,
    Done,
    Canceled,
}

#[derive(Clone, Debug, EnumString, EnumIter)]
#[strum(serialize_all = "snake_case")]
pub enum TaskPriority {
    Low,
    Medium,
    High,
}

impl Distribution<TaskLabel> for Standard {
    fn sample<R: Rng+ ?Sized>(&self, rng: &mut R) -> TaskLabel {
        match rng.gen_range(0..3) {
            0 => TaskLabel::Bug,
            1 => TaskLabel::Feature,
            _ => TaskLabel::Documentation,
        }
    }
}

impl Distribution<TaskStatus> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> TaskStatus {
        match rng.gen_range(0..5) {
            0 => TaskStatus::Backlog,
            1 => TaskStatus::Todo,
            2 => TaskStatus::InProgress,
            3 => TaskStatus::Done,
            _ => TaskStatus::Canceled,
        }
    }
}

impl Distribution<TaskPriority> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> TaskPriority {
        match rng.gen_range(0..3) {
            0 => TaskPriority::Low,
            1 => TaskPriority::Medium,
            _ => TaskPriority::High,
        }
    }
}

impl Distribution<Task> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Task {
        Task {
            id: Faker.fake(),
            label: rng.gen(),
            title: Faker.fake(),
            status: rng.gen(),
            priority: rng.gen(),
        }
    }
}

static TASKS: OnceLock<Mutex<Vec<Task>>> = OnceLock::new();

pub fn all() -> Vec<Task> {
    TASKS
        .get_or_init(|| Mutex::new((0..100).map(|_| rand::random::<Task>()).collect()))
        .lock()
        .unwrap()
        .clone()
}

pub fn by_id(id: i32) -> Option<Task> {
    TASKS
        .get_or_init(|| Mutex::new((0..100).map(|_| rand::random::<Task>()).collect()))
        .lock()
        .unwrap()
        .iter()
        .find(|task| task.id == id)
        .cloned()
}

/*
*
use fake::{Fake, Faker};
use rand::Rng;
use std::sync::Mutex;
use strum_macros::{self, EnumString};
use tokio::sync::Mutex;

#[allow(unused_imports)] // bring trait into scope
use strum::EnumProperty;

#[derive(Clone, Debug)]
pub struct Task {
    pub id: i32,
    pub label: TaskLabel,
    pub title: String,
    pub status: TaskStatus,
    pub priority: TaskPriority,
}

#[derive(Clone, Debug, EnumString)]
#[strum(serialize_all = "snake_case")]
enum TaskLabel {
    Bug,
    Feature,
    Documentation,
}

#[derive(Clone, Debug, EnumString)]
#[strum(serialize_all = "snake_case")]
enum TaskStatus {
    Backlog,
    Todo,
    InProgress,
    Done,
    Canceled,
}
#[derive(Clone, Debug, EnumString, strum_macros::EnumProperty)]
#[strum(serialize_all = "snake_case")]
enum TaskPriority {
    Low,
    Medium,
    High,
}

*/