use serde::de::{
    self, DeserializeSeed, MapAccess, SeqAccess,
    Visitor,
};
use serde::{Serialize};
use serde::Deserialize;

use crate::bipack_source::{BipackSource, VecSource};
use crate::error::{Error, Result};
use crate::ser::to_bytes;
use crate::tools::to_dump;

pub struct Deserializer {
    // This string starts with the input data and characters are truncated off
    // the beginning as data is parsed.
    input: VecSource,
}

pub fn from_bytes<'de,T: Deserialize<'de>>(source: Vec<u8>) -> Result<T> {
    let mut des = Deserializer { input: VecSource::from(source)};
    T::deserialize(&mut des)
}

impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer {
    type Error = Error;

    fn deserialize_any<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(Error::NotPossible)
    }

    fn deserialize_bool<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_bool(if self.input.get_u8()? == 0 { false } else { true } )
    }

    fn deserialize_i8<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_i8(self.input.get_i8()?)
    }

    fn deserialize_i16<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_i16(self.input.get_signed()? as i16)
    }

    fn deserialize_i32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_i32(self.input.get_signed()? as i32)
    }

    fn deserialize_i64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_i64(self.input.get_signed()?)
    }

    fn deserialize_u8<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_u8(self.input.get_u8()?)
    }

    fn deserialize_u16<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_u16(self.input.get_unsigned()? as u16)
    }

    fn deserialize_u32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_u32(self.input.get_unsigned()? as u32)
    }

    fn deserialize_u64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_u64(self.input.get_unsigned()?)
    }

    fn deserialize_f32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(Error::NotImplemented)
    }

    fn deserialize_f64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(Error::NotImplemented)
    }

    fn deserialize_char<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        let ch = self.input.get_str()?;
        if ch.len() != 1 {
            Err(Error::BadFormat(format!("Char length is {}, should be 1 {:?}", ch.len(), ch)))
        }
        else {
            visitor.visit_char(ch.chars().next().unwrap())
        }
    }

    fn deserialize_str<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_string( self.input.get_str()?)
    }

    fn deserialize_string<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_string(self.input.get_str()?)
    }

    fn deserialize_bytes<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_byte_buf(self.input.get_var_bytes()?)
    }

    fn deserialize_byte_buf<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_byte_buf(self.input.get_var_bytes()?)
    }

    fn deserialize_option<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        let marker = self.input.get_u8()?;
        if marker == 0 {
            visitor.visit_none()
        } else {
            visitor.visit_some(self)
        }
    }

    fn deserialize_unit<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_unit()
    }

    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        self.deserialize_unit(visitor)
    }

    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_newtype_struct(self)
    }

    fn deserialize_seq<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        let size = self.input.get_unsigned()? as usize;
        visitor.visit_seq(SimpleSeq::new(self, size))
    }

    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_seq(SimpleSeq::new(self, len))
    }

    fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_seq(SimpleSeq::new(self, len))
    }

    fn deserialize_map<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        let size = self.input.get_unsigned()?;
        visitor.visit_map(SimpleMap { de: self, size: size as usize} )
    }

    fn deserialize_struct<V>(self, name: &'static str, fields: &'static [&'static str], visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_seq(SimpleSeq::new(self, fields.len() ))
    }

    fn deserialize_enum<V>(self, name: &'static str, variants: &'static [&'static str], visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        todo!()
    }

    fn deserialize_identifier<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(Error::NotPossible)
    }

    fn deserialize_ignored_any<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(Error::NotPossible)
    }

    fn is_human_readable(&self) -> bool {
        false
    }
}

struct SimpleSeq<'a> {
    de: &'a mut Deserializer,
    size: usize,
}

impl<'a> SimpleSeq<'a> {
    fn new(de: &'a mut Deserializer,size: usize) -> Self {
        SimpleSeq {
            de,
            size: size,
        }
    }
}

// `SeqAccess` is provided to the `Visitor` to give it the ability to iterate
// through elements of the sequence.
impl<'de, 'a> SeqAccess<'de> for SimpleSeq<'a> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
        where
            T: DeserializeSeed<'de>,
    {
        if self.size < 1 {
            return Ok(None);
        }
        self.size -= 1;
        seed.deserialize(&mut *self.de).map(Some)
    }
}


struct SimpleMap<'a> {
    de: &'a mut Deserializer,
    size: usize,
}

impl<'de, 'a> MapAccess<'de> for SimpleMap<'a> {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K) -> std::result::Result<Option<K::Value>, Self::Error> where K: DeserializeSeed<'de> {
        if self.size < 1 {
            Ok(None)
        }
        else {
            self.size -= 1;
            seed.deserialize(&mut *self.de).map(Some)
        }
    }

    fn next_value_seed<V>(&mut self, seed: V) -> std::result::Result<V::Value, Self::Error> where V: DeserializeSeed<'de> {
        seed.deserialize(&mut *self.de)
    }
}


#[test]
fn test_ints() -> Result<()> {
    // #[derive(Deserialize, PartialEq, Debug)]
    // struct Test {
    //     int: u32,
    //     seq: Vec<String>,
    // }

    let b = vec![7];
    assert_eq!( 7u8, from_bytes(vec![7u8])?);


    // let j = r#"{"int":1,"seq":["a","b"]}"#;
    // let expected = Test {
    //     int: 1,
    //     seq: vec!["a".to_owned(), "b".to_owned()],
    // };
    // assert_eq!(expected, from_str(j).unwrap());
    Ok(())
}

#[test]
fn test_struct_de() -> Result<()> {
    #[derive(Serialize, Deserialize, PartialEq, Debug)]
    struct Test {
        int: u32,
        seq: Vec<String>,
    }
    let expected = Test {
        int: 1,
        seq: vec!["a".to_owned(), "b".to_owned()],
    };

    let packed = to_bytes(&expected)?;
    println!("::{}", to_dump(&packed));
    let unpacked: Test = from_bytes(packed)?;
    println!("::{:?}", unpacked);
    Ok(())

    // let j = r#"{"int":1,"seq":["a","b"]}"#;
    // assert_eq!(expected, from_str(j).unwrap());
}