use serde_cbor::to_vec;
use uuid::Uuid;
use bcrypt::{DEFAULT_COST, hash};
use rand::{thread_rng, Rng};
use rand::distributions::Alphanumeric;
use std::iter;

use std::str;

use net::Db;
use rpc::{AccountCreateParams};

#[derive(Debug,Clone,Serialize,Deserialize)]
struct User {
    id: Uuid,
    name: String,
    token: String,
}

struct UserEntry {
    id: Uuid,
    name: String,
    password: String,
    token: String,
}

pub fn create(params: AccountCreateParams, db: Db) -> Vec<u8> {

    let id = Uuid::new_v4();
    let password = hash(&params.password, DEFAULT_COST)
        .expect("unable to hash password");

    let mut rng = thread_rng();
    let token: String = iter::repeat(())
        .map(|()| rng.sample(Alphanumeric))
        .take(64)
        .collect();

    let user = UserEntry {
        name: params.name,
        id,
        password,
        token,
    };

    let query = "
        INSERT INTO users (id, name, password, token)
        VALUES ($1, $2, $3, $4)
        RETURNING id, name, token;
    ";

    let result = db
        .query(query, &[&user.id, &user.name, &user.password, &user.token])
        .expect("user insert failed");
    let returned = result.iter().next().expect("no row returned");

    let entry = User {
        id: returned.get(0),
        name: returned.get(1),
        token: returned.get(2),
    };

    println!("{:?}", entry);

    to_vec(&entry).expect("serialising user failed")
}