use rfkpos::{Login, Transaction, TransactionReturn, Error, ErrorPriority};
use rfkpos::transaction_return::ReturnValue;

use rfkpos::{CreateTransaction, GetTransaction, TransactionReturn, Database};

use std::collections::LinkedList;
use std::io;
use rand::{thread_rng, Rng};
use rand::distributions::Alphanumeric;
use openssl::sign::{Signer, Verifier};
use openssl::ec::{EcKey, EcGroup, EcGroupRef};
use openssl::pkey::{ PKey, Private };
use openssl::hash::MessageDigest;
use openssl::nid::Nid;

pub struct RFKPOSImpl {}

pub struct RFKPOSImpl {
    db: Arc<Mutex<Database>>,
    tokens: Arc<Mutex<LinkedList<String>>>,
}
pub struct DataValidator {
    group: EcGroup,
    key_priv: PKey<Private>,
}
impl DataValidator {
    pub fn new() -> Result<Self, io::Error> {
        let group = EcGroup::from_curve_name(Nid::SECP256K1)?;
        let key = EcKey::generate(group.as_ref())?;
        let key_priv = PKey::from_ec_key(key)?;
        // let signer = Signer::new(MessageDigest::sha256(), &key_priv.as_ref()).unwrap();
        Ok(Self { group: group, key_priv: key_priv })
    }
}
fn new_token(tokens: Arc<Mutex<LinkedList<String>>>) -> String {
    let new_token: String = thread_rng().sample_iter(Alphanumeric).take(32).map(char::from).collect();
    let mut tokens = tokens.lock().unwrap();
    tokens.push_back(new_token.clone());
    while tokens.len() > 100 { tokens.pop_front(); }
    new_token
}

    async fn new_transaction(&self, request: Request<Transaction>) -> Result<Response<TransactionReturn>, Status> {
        println!("Request from {:?}", request.remote_addr());
        Ok(Response::new(TransactionReturn { return_value: Some(ReturnValue::Err(Error { message: "Not implemented".to_string(), prio: ErrorPriority::ErrCritical as i32 })) }))

    async fn create(&self, request: Request<CreateTransaction>) -> Result<Response<TransactionReturn>, Status> {
        let remote_addr = request.remote_addr();
        let data = request.into_inner();
        println!("Request from {:?} {:?}", remote_addr, data);
        let data_validator = DataValidator::new();
        let transaction = data.transaction.ok_or(Status::invalid_argument("transaction not specified"))?;
        let data = transaction.data.ok_or(io::Error::new(io::ErrorKind::NotFound, "No transaction data found."))?;
        let tid = data.tid;
        self.db.lock().unwrap().transactions.insert(tid, transaction);
        Ok(Response::new(TransactionReturn {
            token: new_token(self.tokens.clone()),
            tid: tid,
        }))

    async fn last_transaction(&self, request: Request<Login>) -> Result<Response<TransactionReturn>, Status> {

    async fn get(&self, request: Request<GetTransaction>) -> Result<Response<TransactionReturn>, Status> {

        Ok(Response::new(TransactionReturn { return_value: Some(ReturnValue::Err(Error { message: "Not implemented".to_string(), prio: ErrorPriority::ErrCritical as i32 })) }))

        Err(Status::internal("Not implemented"))

    rpc NewTransaction(Transaction) returns (TransactionReturn);
    rpc LastTransaction(Login) returns (TransactionReturn);

    rpc Create(CreateTransaction) returns (TransactionReturn);
    rpc Get(GetTransaction) returns (TransactionReturn);
}
message GetTransaction {
    string token = 1;
    optional uint64 tid = 2;
    string signature = 3;
}
message CreateTransaction {
    string token = 1;
    Transaction transaction = 2;
    string signature = 3;

}
enum ErrorPriority {
    ERR_INFO = 0;
    ERR_WARNING = 1;
    ERR_ERROR = 2;
    ERR_CRITICAL = 3;
}
message Error {
    string message = 1;
    ErrorPriority prio = 2;

message TransactionEntry {

message PurchaseEntry {

}
message TransactionData {
    Timestamp ts = 1;
    Timestamp valid_until = 2;
    optional uint64 customer = 3; // customer tid
    optional Money discount = 4;
    repeated TransactionEntry entry = 5;
}
message Invalidate {
    optional string comment = 2;
    repeated uint64 invalidate = 3; // tid of transaction to invalidate
}
message SellTransaction {
    TransactionData data = 1;
    optional Invalidate invalidate = 2;

message BuyTransaction {
    TransactionData data = 1;
    optional Invalidate invalidate = 2;

enum PurchaseType {
    P_SELL = 0;
    P_BUY = 1;
    P_RENT = 2;
    P_INVALIDATE = 3;

message RentTransaction {
    TransactionData data = 1;
    optional Invalidate invalidate = 2;

message Purchase {
    Timestamp ts = 1;
    PurchaseType purchase_type = 2;
    optional Timestamp valid_until = 3;
    optional uint64 customer = 4; // customer tid
    optional Money discount = 5;
    repeated PurchaseEntry entry = 6;
    repeated uint64 invalidate = 7; // tid of transaction to invalidate
    optional string comment = 8;

}
message Login {
    string name = 1;
    string signature = 2;

message Transaction {

message TransactionData {

    string signature = 5;

        SellTransaction sell = 10;
        BuyTransaction buy = 11;
        RentTransaction rent = 12;
        Invalidate invalidate = 13;

        Purchase purchase = 10;

message Transaction {
    TransactionData data = 1;
    string signature = 2;
}

    oneof return_value {
        Transaction tr = 1;
        Error err = 2;
    }

    string token = 1;
    uint64 tid = 2;

rand = "0.8.5"
openssl = "0.10.42"