#include <persistence.hpp>
#include <persistence/filesystem_storage.hpp>
#include <persistence/client.hpp>
#include <persistence/transaction.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/foreach.hpp>
#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <stdlib.h>
#define foreach BOOST_FOREACH

using namespace std;
using namespace boost;
using namespace persistence;


struct account{  //persistent object
	account(){}
	account(int account_nr)
	: account_nr(account_nr)
	, balance(0){}

	int account_nr;
	int balance;
private:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize(Archive &ar,unsigned int){
		ar & account_nr;
		ar & balance;
	}
};

struct bank{ //persistent object
	vector<db_ptr<account> > accounts;
	int overall_balance() const{
		int tmp=0;
		foreach(shared_ptr<account const> const &a,this->accounts){
			tmp+=a->balance;
		}
		return tmp;
	}
private:
	friend class boost::serialization::access;
	template<class Archive>
	void serialize(Archive &ar,unsigned int){
		ar & accounts;
	}
};

struct teller{
	teller(db_ptr< ::bank> const &bank)
		: bank(bank){}
	void operator()(){  //thread start
		while(!exit){
			try{
				transaction tx;
				int amount=random() % 1000;
				int acc1=random() % bank->accounts.size();
				int acc2=random() % bank->accounts.size();
				bank->accounts[acc1]->balance-=amount;   //withdraw
				bank->accounts[acc2]->balance+=amount;   //deposit
	
				tx.commit();
			}catch(isolation_exception &){
				//this transaction conflicted with another transaction, all changes are undone.
				//normally, the exact same transaction should be restarted, but random
				//numbers are used in this case, so just continue;
			}
		}
	}
	db_ptr< ::bank> bank;
	static bool volatile exit;
};

bool volatile teller::exit=false;


void create_db(client<bank> &db,int nr_of_accounts){
	transaction tx;
	db_ptr<bank> mybank(new bank);
	for(int c=0;c<nr_of_accounts;++c){
		db_ptr<account> acc(new account(c));
		mybank->accounts.push_back(acc);
	}
	db.root(mybank);
	tx.commit();
}


int main(){
	srand(time(0));

	int nr_of_threads=10;
	int nr_of_accounts=200;

	filesystem_storage storage("mydb");
	client<bank> db(storage);
	if(!db.root()) create_db(db,nr_of_accounts);

	db_ptr<bank> mybank=db.root();
	
	cerr << "overall balance before: " << mybank->overall_balance() << endl;

	list<shared_ptr<thread> > threads;
	for(int c=0;c<nr_of_threads;++c){
		thread *newthread=new thread(teller(mybank));
		threads.push_back(shared_ptr<thread>(newthread));
	}

	string wait; cin >> wait;
	threads.clear(); teller::exit=true;
	cin >> wait;

	cerr << "overall balance after: " << mybank->overall_balance() << endl;
}