extern crate mongodb;
#[macro_use] extern crate bson;

use bson::{Bson, Document};
use bson::oid::ObjectId;

use mongodb::{Client, ClientOptions, ThreadedClient};
use mongodb::db::{Database, ThreadedDatabase};
use mongodb::connstring::{ConnectionString, ConnectionOptions, Host};
use mongodb::topology::{TopologyDescription, TopologyType};

fn main(){
    let user = "user";
    let password = "password";
    let host = "domain.name".to_string();

    let hosts = vec![Host{
        host_name: host,
        ipc: String::new(),
        port: 27017
    }];

    let connection_config = ConnectionString{
        hosts: hosts,
        string: None,
        user: Some(user.to_string()),
        password: Some(password.to_string()),
        database: None,
        collection: None,
        options: None
    };

    let mut client_options = ClientOptions::new();
    client_options.log_file = Some("/tmp/mongo-commands".to_string());

    let mut description = TopologyDescription::new();
    description.topology_type = TopologyType::Single;

    let client = Client::with_config(
        connection_config,
        Some(client_options),
        Some(description)
    ).ok().expect("Couldn't connect to mongodb database");

    let database = client.db("db");
    database.auth(user, password)
        .ok().expect("Can't authenticate to database");

    let collection = database.collection("collection");

    let mut doc = Document::new();
    doc.insert("test".to_owned(), Bson::String("test".to_string()));

    collection.insert_one(doc, None).ok().expect("Couldn't insert a document");
}