// Copyright 2016 Kai Strempel
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

use std::collections::HashMap;
use chrono::{DateTime, TimeZone};
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Datapoints: () =
    {
        extern crate serde as _serde;
        #[automatically_derived]
        impl _serde::de::Deserialize for Datapoints {
            fn deserialize<__D>(deserializer: &mut __D)
             -> ::std::result::Result<Datapoints, __D::Error> where
             __D: _serde::de::Deserializer {
                #[allow(non_camel_case_types)]
                enum __Field {
                    __field0,
                    __field1,
                    __field2,
                    __field3,
                    __ignore,
                }
                impl _serde::de::Deserialize for __Field {
                    #[inline]
                    fn deserialize<__D>(deserializer: &mut __D)
                     ->
                         ::std::result::Result<__Field,
                                               __D::Error> where
                     __D: _serde::de::Deserializer {
                        struct __FieldVisitor;
                        impl _serde::de::Visitor for __FieldVisitor {
                            type
                            Value
                            =
                            __Field;
                            fn visit_usize<__E>(&mut self, value: usize)
                             ->
                                 ::std::result::Result<__Field, __E> where
                             __E: _serde::de::Error {
                                match value {
                                    0usize => { Ok(__Field::__field0) }
                                    1usize => { Ok(__Field::__field1) }
                                    2usize => { Ok(__Field::__field2) }
                                    3usize => { Ok(__Field::__field3) }
                                    _ =>
                                    Ok(

                                       __Field::__ignore),
                                }
                            }
                            fn visit_str<__E>(&mut self, value: &str)
                             -> ::std::result::Result<__Field, __E> where
                             __E: _serde::de::Error {
                                match value {
                                    "name" => {
                                        Ok(

                                           __Field::__field0)
                                    }
                                    "datapoints" => { Ok(__Field::__field1) }
                                    "tags" => { Ok(__Field::__field2) }
                                    "ttl" => { Ok(__Field::__field3) }
                                    _ => Ok(__Field::__ignore),
                                }
                            }
                            fn visit_bytes<__E>(&mut self,


                                                    value: &[u8])
                             -> ::std::result::Result<__Field, __E> where
                             __E: _serde::de::Error {
                                match value {
                                    b"name" => { Ok(__Field::__field0) }
                                    b"datapoints" => { Ok(__Field::__field1) }
                                    b"tags" => { Ok(__Field::__field2) }
                                    b"ttl" => { Ok(__Field::__field3) }
                                    _ => Ok(__Field::__ignore),
                                }
                            }
                        }
                        deserializer.deserialize_struct_field(__FieldVisitor)
                    }
                }
                struct __Visitor;
                impl _serde::de::Visitor for __Visitor {
                    type
                    Value
                    =
                    Datapoints;
                    #[inline]
                    fn visit_seq<__V>(&mut self, mut visitor: __V)
                     -> ::std::result::Result<Datapoints, __V::Error> where
                     __V: _serde::de::SeqVisitor {
                        let __field0 =
                            match try!(visitor . visit :: < String > (  )) {
                                Some(value) => { value }
                                None => {
                                    try!(visitor . end (  ));
                                    return Err(_serde::de::Error::invalid_length(0usize));
                                }
                            };
                        let __field1 =
                            match try!(visitor . visit :: < Vec < ( i64 , f64
                                       ) > > (  )) {
                                Some(value) => { value }
                                None => {
                                    try!(visitor . end (  ));
                                    return Err(_serde::de::Error::invalid_length(1usize));
                                }
                            };
                        let __field2 =
                            match try!(visitor . visit :: < HashMap < String ,
                                       String > > (  )) {
                                Some(value) => { value }
                                None => {
                                    try!(visitor . end (  ));
                                    return Err(_serde::de::Error::invalid_length(2usize));
                                }
                            };
                        let __field3 =
                            match try!(visitor . visit :: < u32 > (  )) {
                                Some(value) => { value }
                                None => {
                                    try!(visitor . end (  ));
                                    return Err(_serde::de::Error::invalid_length(3usize));
                                }
                            };
                        try!(visitor . end (  ));
                        Ok(Datapoints{name: __field0,
                                      datapoints: __field1,
                                      tags: __field2,
                                      ttl: __field3,})
                    }
                    #[inline]
                    fn visit_map<__V>(&mut self, mut visitor: __V)
                     -> ::std::result::Result<Datapoints, __V::Error> where
                     __V: _serde::de::MapVisitor {
                        let mut __field0: Option<String> = None;
                        let mut __field1: Option<Vec<(i64, f64)>> = None;
                        let mut __field2: Option<HashMap<String, String>> =
                            None;
                        let mut __field3: Option<u32> = None;
                        while let Some(key) =
                                  try!(visitor . visit_key :: < __Field > (
                                       )) {
                            match key {
                                __Field::__field0 => {
                                    if __field0.is_some() {
                                        return Err(<__V::Error as
                                                       _serde::de::Error>::duplicate_field("name"));
                                    }
                                    __field0 =
                                        Some(try!(visitor . visit_value :: <
                                                  String > (  )));
                                }
                                __Field::__field1 => {
                                    if __field1.is_some() {
                                        return Err(<__V::Error as
                                                       _serde::de::Error>::duplicate_field("datapoints"));
                                    }
                                    __field1 =
                                        Some(try!(visitor . visit_value :: <
                                                  Vec < ( i64 , f64 ) > > (
                                                  )));
                                }
                                __Field::__field2 => {
                                    if __field2.is_some() {
                                        return Err(<__V::Error as
                                                       _serde::de::Error>::duplicate_field("tags"));
                                    }
                                    __field2 =
                                        Some(try!(visitor . visit_value :: <
                                                  HashMap < String , String >
                                                  > (  )));
                                }
                                __Field::__field3 => {
                                    if __field3.is_some() {
                                        return Err(<__V::Error as
                                                       _serde::de::Error>::duplicate_field("ttl"));
                                    }
                                    __field3 =
                                        Some(try!(visitor . visit_value :: <
                                                  u32 > (  )));
                                }
                                _ => {
                                    try!(visitor . visit_value :: < _serde ::
                                         de :: impls :: IgnoredAny > (  ));
                                }
                            }
                        }
                        try!(visitor . end (  ));
                        let __field0 =
                            match __field0 {
                                Some(__field0) => __field0,
                                None =>
                                try!(visitor . missing_field ( "name" )),
                            };
                        let __field1 =
                            match __field1 {
                                Some(__field1) => __field1,
                                None =>
                                try!(visitor . missing_field ( "datapoints"
                                     )),
                            };
                        let __field2 =
                            match __field2 {
                                Some(__field2) => __field2,
                                None =>
                                try!(visitor . missing_field ( "tags" )),
                            };
                        let __field3 =
                            match __field3 {
                                Some(__field3) => __field3,
                                None =>
                                try!(visitor . missing_field ( "ttl" )),
                            };
                        Ok(Datapoints{name: __field0,
                                      datapoints: __field1,
                                      tags: __field2,
                                      ttl: __field3,})
                    }
                }
                const FIELDS: &'static [&'static str] =
                    &["name", "datapoints", "tags", "ttl"];
                deserializer.deserialize_struct("Datapoints", FIELDS,
                                                __Visitor)
            }
        }
    };
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Datapoints: () =
    {
        extern crate serde as _serde;
        #[automatically_derived]
        impl _serde::ser::Serialize for Datapoints {
            fn serialize<__S>(&self, _serializer: &mut __S)
             -> ::std::result::Result<(), __S::Error> where
             __S: _serde::ser::Serializer {
                let mut __serde_state =
                    try!(_serializer . serialize_struct (
                         "Datapoints" , 0 + 1 + 1 + 1 + 1 ));
                try!(_serializer . serialize_struct_elt (
                     & mut __serde_state , "name" , & self . name ));
                try!(_serializer . serialize_struct_elt (
                     & mut __serde_state , "datapoints" , & self . datapoints
                     ));
                try!(_serializer . serialize_struct_elt (
                     & mut __serde_state , "tags" , & self . tags ));
                try!(_serializer . serialize_struct_elt (
                     & mut __serde_state , "ttl" , & self . ttl ));
                _serializer.serialize_struct_end(__serde_state)
            }
        }
    };
/// Struct to define everything for a datapoint
#[derive(Debug)]
pub struct Datapoints {
    name: String,
    datapoints: Vec<(i64, f64)>,
    tags: HashMap<String, String>,
    ttl: u32,
}
impl Datapoints {
    /// Creates a new set of datapoints
    pub fn new(name: &str, ttl: u32) -> Datapoints {
        Datapoints{name: name.to_string(),
                   datapoints: Vec::new(),
                   tags: HashMap::new(),
                   ttl: ttl,}
    }
    /// Adds a new datapoint to the set using 'DateTime'
    pub fn add<Tz: TimeZone>(&mut self, datetime: DateTime<Tz>, value: f64) {
        self.datapoints.push((datetime.timestamp() * 1000, value));
    }
    /// Adds a new datapoint to the set using the unix millisecond as
    /// time reference
    pub fn add_ms(&mut self, ms: i64, value: f64) {
        self.datapoints.push((ms, value));
    }
    /// Adds a tag to the datapoint set
    pub fn add_tag(&mut self, name: &str, value: &str) {
        self.tags.insert(name.to_string(), value.to_string());
    }
}