use chrono;
use uuid;
use std::net::{SocketAddr, IpAddr};
use std::fmt;
use std::io::Write;
use std::str::from_utf8;

/// SQL format code (text or binary).
#[repr(i16)]
pub enum FormatCode {
    /// Text format
    Text = 0,
    /// Binary format
    Binary = 1,
}

/// Postgres code for types.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
#[repr(i32)]
pub enum SqlType {
    /// Dynamic type
    None = 0,
}


/// Trait used to convert a type to its SQL representation.
pub trait ToSql {
    /// Postgres type code for this type.
    fn sql_type(&self) -> SqlType {
        SqlType::None
    }
    /// Postgres format code for this type.
    fn format_code(&self) -> FormatCode {
        FormatCode::Text
    }
    /// How to serialize this type in a Postgres-compatible way.
    fn write_sql(&self, w: &mut Vec<u8>);
}

/// Trait to produce types from their SQL representation.
pub trait FromSql<'a>: Sized {
    /// Deserialise from the given buffer.
    fn from_sql(s: &'a [u8]) -> Option<Self>;
}

impl ToSql for bool {
    fn sql_type(&self) -> SqlType {
        SqlType::None
    }
    fn write_sql(&self, w: &mut Vec<u8>) {
        if *self {
            write!(w, "TRUE").unwrap()
        } else {
            write!(w, "FALSE").unwrap()
        }
    }
}

impl<'a> FromSql<'a> for bool {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        Some(s == b"t")
    }
}

impl<Tz: chrono::TimeZone> ToSql for chrono::DateTime<Tz>
    where Tz::Offset: fmt::Display
{
    fn sql_type(&self) -> SqlType {
        SqlType::None
    }
    fn write_sql(&self, w: &mut Vec<u8>) {
        debug!("RFC3339: {:?}", self.to_rfc3339());
        w.write(self.to_rfc3339().as_bytes()).unwrap();
    }
}

impl<'a> FromSql<'a> for chrono::DateTime<chrono::UTC> {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        debug!("parse_timestamp: {:?}", s);
        from_utf8(s).ok().and_then(|s| {
            if let Ok(t) = chrono::NaiveDateTime::parse_from_str(s, "%F %T%.f+00") {
                Some(chrono::DateTime::<chrono::UTC>::from_utc(t, chrono::UTC))
            } else {
                None
            }
        })
    }
}


impl ToSql for i64 {
    fn sql_type(&self) -> SqlType {
        SqlType::None
    }
    fn write_sql(&self, w: &mut Vec<u8>) {
        write!(w, "{}", *self).unwrap();
    }
}

impl<'a> FromSql<'a> for i64 {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        from_utf8(s).ok().and_then(|s| s.parse().ok())
    }
}

impl ToSql for i32 {
    fn sql_type(&self) -> SqlType {
        SqlType::None
    }
    fn write_sql(&self, w: &mut Vec<u8>) {
        write!(w, "{}", *self).unwrap();
    }
}

impl<'a> FromSql<'a> for i32 {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        from_utf8(s).ok().and_then(|s| s.parse().ok())
    }
}

impl ToSql for String {
    fn sql_type(&self) -> SqlType {
        SqlType::None
    }
    fn write_sql(&self, w: &mut Vec<u8>) {
        write!(w, "{}", self).unwrap();
    }
}

impl<'a> FromSql<'a> for String {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        FromSql::from_sql(s).map(|s: &str| s.to_string())
    }
}

impl<'a> ToSql for &'a str {
    fn sql_type(&self) -> SqlType {
        SqlType::None
    }
    fn write_sql(&self, w: &mut Vec<u8>) {
        write!(w, "{}", self).unwrap();
    }
}
impl<'a> FromSql<'a> for &'a str {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        from_utf8(s).ok()
    }
}

impl ToSql for uuid::Uuid {
    fn write_sql(&self, w: &mut Vec<u8>) {
        write!(w, "{}", self.hyphenated()).unwrap();
    }
}

impl<'a> FromSql<'a> for uuid::Uuid {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        from_utf8(s).ok().and_then(|s| s.parse().ok())
    }
}

impl ToSql for SocketAddr {
    fn write_sql(&self, w: &mut Vec<u8>) {
        write!(w, "{}", self).unwrap();
    }
}
impl<'a> FromSql<'a> for SocketAddr {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        from_utf8(s).ok().and_then(|s| s.parse().ok())
    }
}

impl ToSql for IpAddr {
    fn write_sql(&self, w: &mut Vec<u8>) {
        write!(w, "{}", self).unwrap();
    }
}
impl<'a> FromSql<'a> for IpAddr {
    fn from_sql(s: &'a [u8]) -> Option<Self> {
        from_utf8(s).ok().and_then(|s| s.parse().ok())
    }
}

/// Types representing statements.
pub trait Statement {
    /// SQL statement.
    fn statement(&self) -> &str;

    /// Statement names. The default implementation returns the "unname".
    fn name(&self) -> &str {
        ""
    }
}

impl<'a, S: Statement> Statement for &'a S {
    fn name(&self) -> &str {
        (*self).name()
    }
    fn statement(&self) -> &str {
        (*self).statement()
    }
}

impl<'a> Statement for &'a str {
    fn statement(&self) -> &str {
        self
    }
}

impl<'a, 'b> Statement for (&'a str, &'b str) {
    fn statement(&self) -> &str {
        self.1
    }
    fn name(&self) -> &str {
        self.0
    }
}