use crate::ValueBuilder;
use crate::CollectionBuilder;
use crate::Backend;

// A value that can be built interactively, using a Backend
pub trait BuildableValue: Sized {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = Self, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
        ;
}

impl BuildableValue for bool {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = Self, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.bool_builder()
    }
}

impl BuildableValue for u8 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = u8, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.u8_builder()
    }
}

impl BuildableValue for u16 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = u16, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.u16_builder()
    }
}

impl BuildableValue for u32 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = u32, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.u32_builder()
    }
}

impl BuildableValue for u64 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = u64, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.u64_builder()
    }
}

impl BuildableValue for u128 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = u128, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.u128_builder()
    }
}

impl BuildableValue for i8 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = i8, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.i8_builder()
    }
}

impl BuildableValue for i16 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = i16, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.i16_builder()
    }
}

impl BuildableValue for i32 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = i32, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.i32_builder()
    }
}

impl BuildableValue for i64 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = i64, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.i64_builder()
    }
}

impl BuildableValue for i128 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = i128, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.i128_builder()
    }
}

impl BuildableValue for usize {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = usize, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.usize_builder()
    }
}

impl BuildableValue for isize {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = isize, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.isize_builder()
    }
}

impl BuildableValue for f32 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = f32, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.f32_builder()
    }
}

impl BuildableValue for f64 {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = f64, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.f64_builder()
    }
}

impl BuildableValue for char {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = char, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.char_builder()
    }
}

impl BuildableValue for String {
    fn builder<E, B>(backend: B) -> Box<dyn ValueBuilder<Output = String, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.string_builder()
    }
}



pub trait BuildableCollection {
    fn builder<E, B>(backend: B) -> Box<dyn CollectionBuilder<Output = Self, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
        ;
}

impl<T> BuildableCollection for Vec<T>
    where T: 'static + BuildableValue
{
    fn builder<E, B>(backend: B) -> Box<dyn CollectionBuilder<Output = Self, Error = E>>
        where E: Sized,
              B: Backend<Error = E>
    {
        backend.vec_builder::<T>()
    }
}