#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/bind.hpp>
#include <boost/date_time/posix_time/ptime.hpp>
#include <iostream>
#include <boost/persistent/database.hpp>
#include <boost/persistent/loc.hpp>
#include <boost/persistent/shared_loc.hpp>
#include <boost/persistent/transaction.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#define foreach BOOST_FOREACH
#define atomic BOOST_PERSISTENT_ATOMIC
#define retry BOOST_PERSISTENT_RETRY


using namespace std;
using namespace boost;
using namespace persistent;
using namespace posix_time;


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

	int account_nr;
	int balance;

	template<class Archive>
	void serialize(Archive &ar,unsigned int){
		ar & account_nr;
		ar & balance;
	}
};

struct teller{
	teller() : thr(boost::bind(&teller::run,this)){}

	void run(){
		loc<bank> bank=loc<bank>::pinned();
		while(!this_thread::interruption_requested()){
			int amount=random() % 1000;
			int acc1=random() % bank->accounts.size();
			int acc2=random() % bank->accounts.size();

			atomic{
				bank->accounts[acc1]->balance+=amount;
				bank->accounts[acc2]->balance-=amount;
			} retry;
		}
	}
	thread thr;
};


struct bank{
	vector<shared_loc<account> > accounts;
	int overall_balance() const{
		int tmp=0;
		foreach(shared_loc<account const> const &a,this->accounts){
			tmp+=a->balance;
		}
		return tmp;
	}

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


loc<bank> create_db(int nr_of_accounts){
	transaction tx;
	loc<bank> mybank(new bank);
	for(int c=0;c<nr_of_accounts;++c){
		shared_loc<account> acc(new account(c));
		mybank->accounts.push_back(acc);
	}
	mybank.pin();
	tx.commit();
	return mybank;
}

int main(int argc,char **argv){
	srand(time(0));
	int nr_of_threads=10;
	int nr_of_accounts=200;
	if(argc > 1) nr_of_threads=lexical_cast<int>(argv[1]);
	if(argc > 2) nr_of_accounts=lexical_cast<int>(argv[2]);

	database db("bankingdb");
	loc<bank> mybank=loc<bank>::pinned();
	if(!loc<bank>::pinned()) mybank=create_db(nr_of_accounts);

	cerr << "overall balance before: " << mybank.read()->overall_balance() << endl;

	ptr_vector<teller> tellers;
	for(int c=0;c<nr_of_threads;++c){
		tellers.push_back(new teller(c,mybank));
	}

	this_thread::sleep(posix_time::seconds(10));

	foreach(teller &t,tellers){
		t.thr.interrupt();
		t.thr.join();
	}
	cerr << "overall balance after: " << mybank.read()->overall_balance() << endl;
}