// Copyright 2016-2017 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::io::Read;

use hyper::header::Connection;
use hyper::status::StatusCode;

use datapoints::Datapoints;
use query::Query;
use result::{QueryResult, ResultMap};
use error::KairoError;
use helper::parse_metricnames_result;
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_DESERIALIZE_FOR_Version: () =
    {
        extern crate serde as _serde;
        #[automatically_derived]
        impl _serde::de::Deserialize for Version {
            fn deserialize<__D>(deserializer: &mut __D)
             -> ::std::result::Result<Version, __D::Error> where
             __D: _serde::de::Deserializer {
                #[allow(non_camel_case_types)]
                enum __Field { __field0, __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) }
                                    _ => Ok(__Field::__ignore),
                                }
                            }
                            fn visit_str<__E>(&mut self, value: &str)
                             ->
                                 ::std::result::Result<

                                                       __Field, __E> where
                             __E: _serde::de::Error {
                                match value {
                                    "version" => { Ok(__Field::__field0) }
                                    _ => Ok(__Field::__ignore),
                                }
                            }
                            fn visit_bytes<__E>(&mut self, value: &[u8])
                             -> ::std::result::Result<__Field, __E> where
                             __E: _serde::de::Error {
                                match value {
                                    b"version" => { Ok(__Field::__field0) }
                                    _ => Ok(__Field::__ignore),
                                }
                            }
                        }
                        deserializer.deserialize_struct_field(

                                                              __FieldVisitor)
                    }
                }
                struct __Visitor;
                impl _serde::de::Visitor for __Visitor {
                    type
                    Value
                    =
                    Version;
                    #[inline]
                    fn visit_seq<__V>(&mut self, mut visitor: __V)
                     -> ::std::result::Result<Version, __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));
                                }
                            };
                        try!(visitor . end (  ));
                        Ok(Version{version: __field0,})
                    }
                    #[inline]
                    fn visit_map<__V>(&mut self,
                                      mut visitor:
                                          __V)
                     -> ::std::result::Result<Version, __V::Error> where
                     __V: _serde::de::MapVisitor 
                     {
                        let mut __field0: Option<String> = 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("version"));
                                    }
                                    __field0 =
                                        Some(try!(visitor . visit_value :: <
                                                  String > (  )));
                                }
                                _ => {
                                    try!(visitor . visit_value :: < _serde ::
                                         de :: impls :: IgnoredAny > (  ));

                                }
                            }
                        }
                        try!(visitor . end (  ));
                        let __field0 =
                            match __field0 {
                                Some(__field0) => __field0,
                                None =>
                                try!(visitor . missing_field ( "version" )),
                            };
                        Ok(Version{version: __field0,})
                    }
                }
                const FIELDS: &'static [&'static str] = &["version"];
                deserializer.deserialize_struct("Version", FIELDS, __Visitor)
            }
        }
    };
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _IMPL_SERIALIZE_FOR_Version: () =
    {
        extern crate serde as _serde;
        #[automatically_derived]
        impl _serde::ser::Serialize for Version {
            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 ( "Version" , 0 + 1
                         ));
                try!(_serializer . serialize_struct_elt (
                     & mut __serde_state , "version" , & self . version ));
                _serializer.serialize_struct_end(__serde_state)
            }
        }
    };
#[derive(Debug)]
struct Version {
    version: String,
}
/// The core of the kairosdb client, owns a HTTP connection.
#[derive(Debug)]
pub struct Client {
    base_url: String,
    http_client: hyper::Client,
}
impl Client {
    /// Constructs a new KairosDB Client
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// let client = Client::new("localhost", 8080);
    /// ```
    pub fn new(host: &str, port: u32) -> Client {
        info!("create new client host: {} port: {}" , host , port);
        Client{base_url: format!("http://{}:{}" , host , port),
               http_client: hyper::Client::new(),}
    }
    /// Returns the version string of the KairosDB Server
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// let client = Client::new("localhost", 8080);
    /// assert!(client.version().unwrap().starts_with("KairosDB"));
    /// ```
    pub fn version(&self) -> Result<String, KairoError> {
        let mut response =
            self.http_client.get(&format!("{}/api/v1/version" , self .
                                          base_url)).header(Connection::close()).send()?;
        let mut body = String::new();
        response.read_to_string(&mut body)?;
        let version: Version = serde_json::from_str(&body)?;
        info!("get server version {:?}" , version . version);
        Ok(version.version)
    }
    /// Returns the health status of the KairosDB Server
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// let client = Client::new("localhost", 8080);
    /// let response = client.health();
    /// ```
    pub fn health(&self) -> Result<Vec<String>, KairoError> {
        let mut response =
            self.http_client.get(&format!("{}/api/v1/health/status" , self .
                                          base_url)).header(Connection::close()).send()?;
        match response.status {
            StatusCode::Ok => {
                let mut body = String::new();
                response.read_to_string(&mut body)?;
                let health: Vec<String> = serde_json::from_str(&body)?;
                info!("get server health {:?}" , health);
                Ok(health)
            }
            _ => {
                let msg =
                    format!("Health endpoint returns with wrong status code: {:?}"
                            , response . status);
                Err(KairoError::Kairo(msg))
            }
        }
    }

    /// Method to add datapoints to the time series database
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// use kairosdb::datapoints::Datapoints;
    ///
    /// let client = Client::new("localhost", 8080);
    /// let mut datapoints = Datapoints::new("first", 0);
    /// datapoints.add_ms(1475513259000, 11.0);
    /// datapoints.add_ms(1475513259001, 12.0);
    /// datapoints.add_tag("test", "first");
    /// let result = client.add(&datapoints);
    /// assert!(result.is_ok())
    /// ```
    pub fn add(&self, datapoints: &Datapoints) -> Result<(), KairoError> {
        info!("Add datapoints {:?}" , datapoints);
        let body = serde_json::to_string(&vec!(datapoints))?;
        let response =
            self.http_client.post(&format!("{}/api/v1/datapoints" , self .
                                           base_url)).header(Connection::close()).body(&body).send()?;
        match response.status {
            StatusCode::NoContent => Ok(()),
            _ => {
                let msg =
                    format!("Add datapoints returns with bad response code: {:?}"
                            , response . status);
                Err(KairoError::Kairo(msg))
            }
        }
    }

    /// Runs a query on the database.
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// use kairosdb::query::{Query, Time, TimeUnit};
    ///
    /// let client = Client::new("localhost", 8080);
    /// let query = Query::new(
    ///    Time::Nanoseconds(1),
    ///    Time::Relative{value: 1, unit: TimeUnit::WEEKS});
    /// let result = client.query(&query);
    /// assert!(result.is_ok())
    /// ```
    pub fn query(&self, query: &Query) -> Result<ResultMap, KairoError> {
        match self.run_query(query, "query") {
            Ok(body) => self.parse_query_result(&body),
            Err(err) => Err(err),
        }
    }

    /// Runs a delete query on the database. View the query structure
    /// to understand more about.
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// use kairosdb::query::{Query, Time, TimeUnit};
    ///
    /// let client = Client::new("localhost", 8080);
    /// let query = Query::new(
    ///    Time::Nanoseconds(1),
    ///    Time::Relative{value: 1, unit: TimeUnit::WEEKS});
    /// let result = client.delete(&query);
    /// assert!(result.is_ok())
    /// ```
    pub fn delete(&self, query: &Query) -> Result<(), KairoError> {
        match self.run_query(query, "delete") {
            Ok(_) => Ok(()),
            Err(err) => Err(err),
        }
    }

    /// Returns a list with all metric names
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// # use kairosdb::datapoints::Datapoints;
    /// let client = Client::new("localhost", 8080);
    /// # let mut datapoints = Datapoints::new("first", 0);
    /// # datapoints.add_ms(1475513259000, 11.0);
    /// # datapoints.add_tag("test", "first");
    /// # let result = client.add(&datapoints);
    ///
    /// let result = client.list_metrics();
    /// assert!(result.is_ok());
    /// assert!(result.unwrap().contains(&"first".to_string()));
    /// ```
    pub fn list_metrics(&self) -> Result<Vec<String>, KairoError> {
        info!("Get metricnames");
        let mut response =
            self.http_client.get(&format!("{}/api/v1/metricnames" , self .
                                          base_url)).header(Connection::close()).send()?;

        match response.status {
            StatusCode::Ok => {
                let mut result_body = String::new();
                response.read_to_string(&mut result_body)?;
                Ok(parse_metricnames_result(&result_body)?)
            }
            _ =>
            Err(KairoError::Kairo(format!("Bad response code: {:?}" , response
                                          . status))),
        }
    }

    /// Deleting a metric
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// # use kairosdb::datapoints::Datapoints;
    /// let client = Client::new("localhost", 8080);
    /// # let mut datapoints = Datapoints::new("first", 0);
    /// # datapoints.add_ms(1475513259000, 11.0);
    /// # let result = client.add(&datapoints);
    ///
    /// let result = client.delete_metric(&"first");
    /// assert!(result.is_ok());
    /// # let result = client.list_metrics();
    /// # assert!(result.is_ok());
    /// # assert!(!result.unwrap().contains(&"first".to_string()));
    /// ```
    pub fn delete_metric(&self, metric: &str) -> Result<(), KairoError> {
        let response =
            self.http_client.delete(&format!("{}/api/v1/metric/{}" , self .
                                             base_url ,
                                             metric)).header(Connection::close()).send()?;

        match response.status {
            StatusCode::NoContent => Ok(()),
            _ =>
            Err(KairoError::Kairo(format!("Bad response code: {:?}" , response
                                          . status))),
        }
    }

    /// Returns a list of all tagnames
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// # use kairosdb::datapoints::Datapoints;
    /// let client = Client::new("localhost", 8080);
    /// # let mut datapoints = Datapoints::new("first", 0);
    /// # datapoints.add_ms(1475513259000, 11.0);
    /// # datapoints.add_tag("test", "first");
    /// # let _ = client.add(&datapoints);
    ///
    /// let result = client.tagnames();
    /// assert!(result.is_ok());
    /// assert!(result.unwrap().contains(&"test".to_string()));
    /// ```
    pub fn tagnames(&self) -> Result<Vec<String>, KairoError> {
        info!("Get tagnames");
        let mut response =
            self.http_client.get(&format!("{}/api/v1/tagnames" , self .
                                          base_url)).header(Connection::close()).send()?;

        match response.status {
            StatusCode::Ok => {
                let mut result_body = String::new();
                response.read_to_string(&mut result_body)?;
                Ok(parse_metricnames_result(&result_body)?)
            }
            _ =>
            Err(KairoError::Kairo(format!("Bad response code: {:?}" , response
                                          . status))),
        }
    }

    /// Returns a list of all tagvalues
    ///
    /// # Example
    /// ```
    /// use kairosdb::Client;
    /// # use kairosdb::datapoints::Datapoints;
    /// let client = Client::new("localhost", 8080);
    /// # let mut datapoints = Datapoints::new("first", 0);
    /// # datapoints.add_ms(1475513259000, 11.0);
    /// # datapoints.add_tag("test", "first");
    /// # let _ = client.add(&datapoints);
    ///
    /// let result = client.tagvalues();
    /// assert!(result.is_ok());
    /// assert!(result.unwrap().contains(&"first".to_string()));
    /// ```
    pub fn tagvalues(&self) -> Result<Vec<String>, KairoError> {
        info!("Get tagnames");
        let mut response =
            self.http_client.get(&format!("{}/api/v1/tagvalues" , self .
                                          base_url)).header(Connection::close()).send()?;

        match response.status {
            StatusCode::Ok => {
                let mut result_body = String::new();
                response.read_to_string(&mut result_body)?;
                Ok(parse_metricnames_result(&result_body)?)
            }
            _ =>
            Err(KairoError::Kairo(format!("Bad response code: {:?}" , response
                                          . status))),
        }
    }

    fn run_query(&self, query: &Query, endpoint: &str)
     -> Result<String, KairoError> {
        let body = serde_json::to_string(query)?;
        info!("Run query {}" , body);
        let mut response =
            self.http_client.post(&format!("{}/api/v1/datapoints/{}" , self .
                                           base_url ,
                                           endpoint)).header(Connection::close()).body(&body).send()?;

        match response.status {
            StatusCode::Ok => {
                let mut result_body = String::new();
                response.read_to_string(&mut result_body)?;
                Ok(result_body)
            }
            StatusCode::NoContent => Ok("".to_string()),
            _ =>
            Err(KairoError::Kairo(format!("Bad response code: {:?}" , response
                                          . status))),
        }
    }


    fn parse_query_result(&self, body: &str)
     -> Result<ResultMap, KairoError> {
        let result = QueryResult::new();
        result.parse_result(body)
    }
}