use std::error::Error;
use std::sync::Arc;

use bson::{self, Bson};
use auth::Authenticator;
use client::Client;
use coll::Collection;
use coll::options::FindOptions;
use command_type::CommandType;
use common::{ReadPreference, merge_options, WriteConcern};
use cursor::{Cursor, DEFAULT_BATCH_SIZE};
use semver::Version;
use error::Result;
use error::Error::{CursorNotFoundError, OperationError, ResponseError};

use self::options::{CreateCollectionOptions, CreateUserOptions, UserInfoOptions};

pub mod options;
pub mod roles;

#[derive(Clone)]
pub struct Database {
    pub inner: Arc<DatabaseInner>
}

pub struct DatabaseInner {
    /// The database name.
    pub name: String,
    /// A reference to the client that spawned this database.
    pub client: Client,
    /// Indicates how a server should be selected for read operations.
    pub read_preference: ReadPreference,
    /// Describes the guarantees provided by MongoDB when reporting the success of a write
    /// operation.
    pub write_concern: WriteConcern,
}

fn is_send<T: Send>() {}
fn is_sync<T: Sync>() {}

impl Database {
    pub fn open(
        client: Client,
        name: &str,
        read_preference: Option<ReadPreference>,
        write_concern: Option<WriteConcern>
    ) -> Database {
        is_send::<Client>();
        is_sync::<Client>();

        let rp = read_preference.unwrap_or_else(|| client.inner.read_preference.clone());
        let wc = write_concern.unwrap_or_else(|| client.inner.write_concern.clone());

        Database {
            inner: Arc::new(DatabaseInner {
                name: name.to_string(),
                client: client,
                read_preference: rp,
                write_concern: wc,
            })
        }
    }

    pub fn auth(&self, user: &str, password: &str) -> Result<()> {
        let authenticator = Authenticator::new(self.clone());
        authenticator.auth(user, password)
    }

    pub fn collection(&self, coll_name: &str) -> Collection {
        Collection::new(
            self.clone(),
            coll_name,
            false,
            Some(self.inner.read_preference.clone()),
            Some(self.inner.write_concern.clone())
        )
    }

    pub fn collection_with_prefs(
        &self,
        coll_name: &str,
        create: bool,
        read_preference: Option<ReadPreference>,
        write_concern: Option<WriteConcern>
    ) -> Collection {
        Collection::new(
            self.clone(),
            coll_name,
            create,
            read_preference,
            write_concern
        )
    }

    pub fn get_req_id(&self) -> i32 {
        self.inner.client.get_req_id()
    }

    pub fn command_cursor(
        &self,
        spec: bson::Document,
        cmd_type: CommandType,
        read_pref: ReadPreference
    ) -> Result<Cursor> {
        Cursor::command_cursor(
            self.inner.client.clone(),
            &self.inner.name,
            spec,
            cmd_type,
            read_pref
        )
    }

    pub fn command(
        &self,
        spec: bson::Document,
        cmd_type: CommandType,
        read_preference: Option<ReadPreference>
    ) -> Result<bson::Document> {

        let coll = self.collection("$cmd");
        let mut options = FindOptions::new();
        options.batch_size = Some(1);
        options.read_preference = read_preference;
        let res = coll.find_one_with_command_type(Some(spec.clone()), Some(options), cmd_type)?;
        res.ok_or_else(|| {
            OperationError(format!("Failed to execute command with spec {:?}.", spec))
        })
    }

    pub fn list_collections(&self, filter: Option<bson::Document>) -> Result<Cursor> {
        self.list_collections_with_batch_size(filter, DEFAULT_BATCH_SIZE)
    }

    pub fn list_collections_with_batch_size(
        &self,
        filter: Option<bson::Document>,
        batch_size: i32
    ) -> Result<Cursor> {

        let mut spec = bson::Document::new();
        let mut cursor = bson::Document::new();

        cursor.insert("batchSize", Bson::Int32(batch_size));
        spec.insert("listCollections", Bson::Int32(1));
        spec.insert("cursor", Bson::Document(cursor));
        if filter.is_some() {
            spec.insert("filter", Bson::Document(filter.unwrap()));
        }

        self.command_cursor(
            spec,
            CommandType::ListCollections,
            self.inner.read_preference.clone()
        )
    }

    pub fn collection_names(&self, filter: Option<bson::Document>) -> Result<Vec<String>> {
        let mut cursor = self.list_collections(filter)?;
        let mut results = vec![];
        loop {
            match cursor.next() {
                Some(Ok(doc)) => {
                    if let Some(&Bson::String(ref name)) = doc.get("name") {
                        results.push(name.to_string());
                    }
                }
                Some(Err(err)) => return Err(err),
                None => return Ok(results),
            }
        }
    }

    pub fn version(&self) -> Result<Version> {
        let doc = doc! { "buildinfo": 1 };
        let out = self.command(doc, CommandType::BuildInfo, None)?;

        match out.get("version") {
            Some(&Bson::String(ref s)) => {
                match Version::parse(s) {
                    Ok(v) => Ok(v),
                    Err(e) => Err(ResponseError(e.description().to_string())),
                }
            }
            _ => Err(ResponseError("No version received from server".to_string())),
        }
    }

    pub fn create_collection(
        &self,
        name: &str,
        options: Option<CreateCollectionOptions>
    ) -> Result<()> {
        let mut doc = doc! { "create": name };

        if let Some(create_collection_options) = options {
            doc = merge_options(doc, create_collection_options);
        }

        self.command(doc, CommandType::CreateCollection, None).map(|_| ())
    }

    pub fn create_user(
        &self,
        name: &str,
        password: &str,
        options: Option<CreateUserOptions>
    ) -> Result<()> {
        let mut doc = doc! {
            "createUser": name,
            "pwd": password
        };

        match options {
            Some(user_options) => {
                doc = merge_options(doc, user_options);
            }
            None => {
                doc.insert("roles", Bson::Array(Vec::new()));
            }
        };

        self.command(doc, CommandType::CreateUser, None).map(|_| ())
    }

    pub fn drop_all_users(&self, write_concern: Option<WriteConcern>) -> Result<(i32)> {
        let mut doc = doc! { "dropAllUsersFromDatabase": 1 };

        if let Some(concern) = write_concern {
            doc.insert("writeConcern", Bson::Document(concern.to_bson()));
        }

        let response = self.command(doc, CommandType::DropAllUsers, None)?;

        match response.get("n") {
            Some(&Bson::Int32(i)) => Ok(i),
            Some(&Bson::Int64(i)) => Ok(i as i32),
            _ => Err(CursorNotFoundError),
        }
    }

    pub fn drop_collection(&self, name: &str) -> Result<()> {
        let mut spec = bson::Document::new();
        spec.insert("drop", Bson::String(name.to_string()));
        self.command(spec, CommandType::DropCollection, None)?;
        Ok(())
    }

    pub fn drop_database(&self) -> Result<()> {
        let mut spec = bson::Document::new();
        spec.insert("dropDatabase", Bson::Int32(1));
        self.command(spec, CommandType::DropDatabase, None)?;
        Ok(())
    }

    pub fn drop_user(&self, name: &str, write_concern: Option<WriteConcern>) -> Result<()> {
        let mut doc = doc! { "dropUser": name };

        if let Some(concern) = write_concern {
            doc.insert("writeConcern", (concern.to_bson()));
        }

        self.command(doc, CommandType::DropUser, None).map(|_| ())
    }

    pub fn get_all_users(&self, show_credentials: bool) -> Result<Vec<bson::Document>> {
        let doc = doc! {
            "usersInfo": 1,
            "showCredentials": show_credentials
        };

        let out = self.command(doc, CommandType::GetUsers, None)?;
        let vec = match out.get("users") {
            Some(&Bson::Array(ref vec)) => vec.clone(),
            _ => return Err(CursorNotFoundError),
        };

        let mut users = vec![];

        for bson in vec {
            match bson {
                Bson::Document(doc) => users.push(doc),
                _ => return Err(CursorNotFoundError),
            };
        }

        Ok(users)
    }

    pub fn get_user(&self, user: &str, options: Option<UserInfoOptions>) -> Result<bson::Document> {
        let mut doc = doc! {
            "usersInfo": {
                "user": user,
                "db": (self.inner.name.to_string())
            }
        };

        if let Some(user_info_options) = options {
            doc = merge_options(doc, user_info_options);
        }

        let out = match self.command(doc, CommandType::GetUser, None) {
            Ok(doc) => doc,
            Err(e) => return Err(e),
        };

        let users = match out.get("users") {
            Some(&Bson::Array(ref v)) => v.clone(),
            _ => return Err(CursorNotFoundError),
        };

        match users.first() {
            Some(&Bson::Document(ref doc)) => Ok(doc.clone()),
            _ => Err(CursorNotFoundError),
        }
    }

    pub fn get_users(
        &self,
        users: Vec<&str>,
        options: Option<UserInfoOptions>
    ) -> Result<Vec<bson::Document>> {
        let vec: Vec<_> = users.into_iter()
            .map(|user| {
                let doc = doc! {
                    "user": user,
                    "db": (self.inner.name.to_string())
                };
                Bson::Document(doc)
            })
            .collect();

        let mut doc = doc! { "usersInfo": vec };

        if let Some(user_info_options) = options {
            doc = merge_options(doc, user_info_options);
        }

        let out = self.command(doc, CommandType::GetUsers, None)?;
        let vec = match out.get("users") {
            Some(&Bson::Array(ref vec)) => vec.clone(),
            _ => return Err(CursorNotFoundError),
        };

        let mut users = vec![];

        for bson in vec {
            match bson {
                Bson::Document(doc) => users.push(doc),
                _ => return Err(CursorNotFoundError),
            };
        }

        Ok(users)
    }
}