use std::cmp::Ordering;
use std::fmt::{Debug, Formatter, Error, Display};
use std::mem;

mod iter;
pub use self::iter::Iter;


/// ALO means At Least One.
/// It cointains at least one item.
/// If there is only one item, ALO does not heap allocate.
/// If there is more than one items, ALO does heap allocate.
#[derive(Clone)]
pub struct ALO<T>(T, Vec<T>);

impl<T> ALO<T> {
    pub fn with_item(item: T) -> ALO<T> {
        ALO(item, Vec::new())
    }

    pub fn add(&mut self, item: T) {
        let &mut ALO(_, ref mut vec) = self;
        vec.push(item);
    }

    pub fn get(&self, index: usize) -> Option<&T> {
        if index == 0 {
            Some(&self.0)
        } else {
            self.1.get(index - 1)
        }
    }

    /// Remove item in given index.
    ///
    /// #Panics
    /// Panics if ALO has only one item.
    /// Panics if index is out of bounds.
    pub fn remove(&mut self, index: usize) -> T {
        if index == 0 {
            mem::replace(&mut self.0, self.1.remove(0))
        } else {
            self.1.remove(index - 1)
        }
    }

    pub fn len(&self) -> usize {
        self.1.len() + 1
    }


    pub fn iter<'a>(&'a self) -> Iter<'a, T> {
        Iter::with(&self.0, self.1.iter())
    }
}


impl<T> Debug for ALO<T>
    where T: Debug
{
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        let &ALO(ref first, ref another) = self;
        write!(f, "ALO ( {:?}, {:?} )", first, another)
    }
}


impl<T> Display for ALO<T>
    where T: Display
{
    /// This prints like below
    /// "ALO ( "String", and more 9 items )
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        let &ALO(ref first, ref another) = self;
        write!(f, "ALO ( {}, and more {} items )", first, another.len())
    }
}


impl<A, B> PartialEq<ALO<B>> for ALO<A>
    where A: PartialEq<B>
{
    fn eq(&self, other: &ALO<B>) -> bool {
        let &ALO(ref self_first, ref self_another) = self;
        let &ALO(ref other_first, ref other_another) = other;
        self_first.eq(other_first) && self_another.eq(other_another)
    }
}


impl<T> Eq for ALO<T> where T: Eq {}


impl<T> PartialOrd for ALO<T>
    where T: PartialOrd<T>
{
    fn partial_cmp(&self, other: &ALO<T>) -> Option<Ordering> {
        let &ALO(ref self_first, ref self_another) = self;
        let &ALO(ref other_first, ref other_another) = other;
        match self_first.partial_cmp(other_first) {
            None => None,
            Some(Ordering::Less) => Some(Ordering::Less),
            Some(Ordering::Greater) => Some(Ordering::Greater),
            Some(Ordering::Equal) => self_another.partial_cmp(other_another),
        }
    }
}


impl<T> Ord for ALO<T>
    where T: Ord
{
    fn cmp(&self, other: &ALO<T>) -> Ordering {
        let &ALO(ref self_first, ref self_another) = self;
        let &ALO(ref other_first, ref other_another) = other;
        match self_first.cmp(other_first) {
            Ordering::Less => Ordering::Less,
            Ordering::Greater => Ordering::Greater,
            Ordering::Equal => self_another.cmp(other_another),
        }
    }
}


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

    #[test]
    fn ord_singles() {
        let alo1 = ALO::with_item(42);
        let alo2 = ALO::with_item(420);
        assert!(alo1 < alo2);
    }

    #[test]
    fn ord_single_and_many() {
        let alo3 = ALO::with_item(42);
        let mut alo4 = ALO::with_item(42);
        alo4.add(4);
        assert!(alo3 < alo4);
    }

    #[test]
    fn ord_many_and_many() {
        let mut alo5 = ALO::with_item(42);
        alo5.add(1);
        alo5.add(1);
        let mut alo6 = ALO::with_item(42);
        alo6.add(1);
        alo6.add(4);
        assert!(alo5 < alo6);

        let mut alo5 = ALO::with_item(42);
        alo5.add(4);
        let mut alo6 = ALO::with_item(42);
        alo6.add(1);
        alo6.add(4);
        assert!(alo5 > alo6);
    }

    #[test]
    fn removeing_item_should_return_removed_value() {
        let mut alo1 = ALO::with_item(42);
        alo1.add(50);
        assert_eq!(42, alo1.remove(0));
        assert_eq!(Some(&50), alo1.get(0));
    }

    #[test]
    #[should_panic]
    fn removing_from_alo_which_contains_only_one_item_should_panic() {
        let mut alo = ALO::with_item(42);
        alo.remove(0);
    }

    #[test]
    #[should_panic]
    fn removing_by_out_of_bound_index_should_panic() {
        let mut alo = ALO::with_item(42);
        alo.add(42);
        alo.remove(2);
    }


    #[test]
    fn get() {
        let mut alo = ALO::with_item(0);
        alo.add(1);
        assert_eq!(alo.get(0), Some(&0));
        assert_eq!(alo.get(1), Some(&1));
        assert_eq!(alo.get(2), None);
    }
}