use interactive_object_builder::*;

#[derive(Copy, Clone)]
pub struct DummyBackend;

impl Backend for DummyBackend {
    fn bool_builder(&self) -> Box<dyn ValueBuilder<Output = bool>> {
        Box::new(BoolValBuilder)
    }
    fn u8_builder(&self)     -> Box<dyn ValueBuilder<Output = u8>> {
        Box::new(U8ValueBuilder)
    }
    fn u16_builder(&self)    -> Box<dyn ValueBuilder<Output = u16>> {
        unimplemented!()
    }
    fn u32_builder(&self)    -> Box<dyn ValueBuilder<Output = u32>> {
        unimplemented!()
    }
    fn u64_builder(&self)    -> Box<dyn ValueBuilder<Output = u64>> {
        unimplemented!()
    }
    fn u128_builder(&self)   -> Box<dyn ValueBuilder<Output = u128>> {
        unimplemented!()
    }
    fn i8_builder(&self)     -> Box<dyn ValueBuilder<Output = i8>> {
        unimplemented!()
    }
    fn i16_builder(&self)    -> Box<dyn ValueBuilder<Output = i16>> {
        unimplemented!()
    }
    fn i32_builder(&self)    -> Box<dyn ValueBuilder<Output = i32>> {
        unimplemented!()
    }
    fn i64_builder(&self)    -> Box<dyn ValueBuilder<Output = i64>> {
        unimplemented!()
    }
    fn i128_builder(&self)   -> Box<dyn ValueBuilder<Output = i128>> {
        unimplemented!()
    }
    fn usize_builder(&self)  -> Box<dyn ValueBuilder<Output = usize>> {
        unimplemented!()
    }
    fn isize_builder(&self)  -> Box<dyn ValueBuilder<Output = isize>> {
        unimplemented!()
    }
    fn f32_builder(&self)    -> Box<dyn ValueBuilder<Output = f32>> {
        unimplemented!()
    }
    fn f64_builder(&self)    -> Box<dyn ValueBuilder<Output = f64>> {
        unimplemented!()
    }
    fn char_builder(&self)   -> Box<dyn ValueBuilder<Output = char>> {
        unimplemented!()
    }
    fn string_builder(&self) -> Box<dyn ValueBuilder<Output = String>> {
        unimplemented!()
    }
    fn option_builder<T: 'static + BuildableValue>(&self) -> Box<dyn CollectionBuilder<Output = Option<T>>> {
        unimplemented!()
    }
    fn vec_builder<T>(&self) -> Box<dyn CollectionBuilder<Output = Vec<T>>>
        where T: 'static + BuildableValue
    {
        Box::new(VecBuilder::<T>(std::marker::PhantomData))
    }

    fn struct_builder<T>(&self) -> Box<dyn CollectionBuilder<Output = T>>
        where T: 'static + BuildableCollection
    {
        Box::new(StructBuilder::<T>(std::marker::PhantomData))
    }
}

pub struct BoolValBuilder;
impl ValueBuilder for BoolValBuilder {
    type Output = bool;

    fn build_value(&self, _question: &str, _default: Option<&Self::Output>) -> Result<Self::Output> {
        Ok(true)
    }
}

pub struct U8ValueBuilder;
impl ValueBuilder for U8ValueBuilder {
    type Output = u8;

    fn build_value(&self, _question: &str, _default: Option<&Self::Output>) -> Result<Self::Output> {
        Ok(42)
    }
}

pub struct VecBuilder<T: 'static + BuildableValue>(std::marker::PhantomData<T>);
impl<T: BuildableValue> CollectionBuilder for VecBuilder<T> {
    type Output = Vec<T>;

    fn build_collection(&self, value_desc: &str) -> Result<Self::Output> {
        let mut buf = vec![];

        loop {
            let v: T = T::builder(DummyBackend).build_value(value_desc, None)?;
            buf.push(v);

            if buf.len() == 3 {
                break
            }
        }

        Ok(buf)
    }
}

pub struct StructBuilder<T: BuildableCollection>(std::marker::PhantomData<T>);
impl<T: BuildableCollection> CollectionBuilder for StructBuilder<T> {
    type Output = T;

    fn build_collection(&self, value_desc: &str) -> Result<Self::Output> {
        T::builder(DummyBackend).build_collection(value_desc)
    }
}