use crate::{
    message::{Action, MsgAction},
    name::NameType,
};
use uuid::Uuid;

#[derive(Clone, Debug, Eq, Hash)]
pub enum Include<T> {
    All,
    Just(T),
}

impl<T: PartialEq> PartialEq for Include<T> {
    fn eq(&self, other: &Self) -> bool {
        match self {
            Include::All => true,
            Include::Just(data) => match other {
                Include::All => true,
                Include::Just(other_data) => data == other_data,
            },
        }
    }
}

#[cfg(test)]
mod includes {
    use super::*;

    #[test]
    fn does_all_equal_evberything() {
        let a: Include<isize> = Include::All;
        let b: Include<isize> = Include::Just(5);
        let c: Include<isize> = Include::Just(7);
        assert!(a == a, "all should equal all");
        assert!(a == b, "all should equal just");
        assert!(b == a, "just should equal all");
        assert!(b == b, "same just should equal");
        assert!(b != c, "different justs do not equal");
    }
}

#[derive(Clone, Debug)]
pub struct Path {
    pub msg_id: Include<Uuid>,
    pub doc: Include<NameType>,
    pub action: Include<Action>,
}

impl Path {
    pub fn new(id: Include<Uuid>, doc: Include<NameType>, action: Include<Action>) -> Self {
        Self {
            msg_id: id,
            doc: doc,
            action: action,
        }
    }

    pub fn for_message<NT>(name: NT, action: &MsgAction) -> Self
    where
        NT: Into<NameType>,
    {
        Self {
            msg_id: Include::Just(Uuid::new_v4()),
            doc: Include::Just(name.into()),
            action: Include::Just(action.into()),
        }
    }
}

#[cfg(test)]
mod paths {
    use super::*;
    use crate::{
        message::{MsgAction, Records},
        name::{Name, Names},
    };

    #[test]
    fn can_create_for_message() {
        let input = [
            (Name::english("one"), MsgAction::Show),
            (
                Name::english("two"),
                MsgAction::Records(Records::new(Names::new())),
            ),
        ];
        for item in input.iter() {
            let path = Path::for_message(item.0.clone(), &item.1);
            match path.doc {
                Include::Just(name) => assert_eq!(name, item.0.clone().into()),
                _ => unreachable!("should have returned document name"),
            }
            match path.action {
                Include::Just(action) => assert_eq!(action, item.1.clone().into()),
                _ => unreachable!("should have returned action type"),
            }
        }
    }

    #[test]
    fn message_ids_are_unique_for_message_paths() {
        let count = 10;
        let mut ids: Vec<Uuid> = Vec::new();
        for _ in 0..count {
            let path = Path::for_message(NameType::None, &MsgAction::Show);
            let id = match path.msg_id {
                Include::Just(data) => data.clone(),
                Include::All => unreachable!("should have been a message id"),
            };
            assert!(!ids.contains(&id), "{:?} is duplicated in {:?}", id, ids);
            ids.push(id);
        }
    }
}