#include <map>
#include <vector>
#include <string>

/*  A system to manage shared expenses on a trip.
 */

typedef int person_id_t;

void trip_initialize();
void trip_shutdown();

person_id_t trip_add_person(const char * name);
person_id_t trip_find_person(const char * name);

int trip_add_expense(const char * descr, float amount, person_id_t payer);

void trip_print_expenses();
void trip_print_balance();

class trip;
class expense;
class person;

class person {
public:
    const std::string name;
    const person_id_t id;

    person(const char * n, person_id_t i)
	: name(n), id(i) {};
};

extern person_id_t new_id();

// Persons
std::vector <person> persons;
std::map <person_id_t, unsigned int> person_id_index;
std::map <std::string, person_id_t> person_name_index;

const person_id_t PERSON_NOT_FOUND = -1;

person_id_t trip_add_person(const char * name) {
    // okay to add two persons with same name
    person_id_t id = new_id();
    persons.push_back(person(name, id));
    person_id_index.insert(std::map <person_id_t, unsigned int>::value_type(id, persons.size() - 1));
    person_name_index.insert(std::map <std::string, person_id_t>::value_type(name,id));
    return id;
}

person_id_t trip_find_person(const char * name) {
    auto i = person_name_index.find(name);
    if (i != person_name_index.end())
	return i->second;
    else
	return PERSON_NOT_FOUND;
}

class expense {
public:
    std::string description;
    float amount;
    person_id_t payer;

    expense(const char * descr, float a, person_id_t p)
	: description(descr), amount(a), payer(p) {};
};

std::vector <expense> expenses;

int trip_add_expense(const char * descr, float amount, person_id_t payer) {
    expenses.push_back(expense(descr, amount, payer));
    return 1;
}

void trip_initialize() {
    expenses.clear();
    persons.clear();
    person_id_index.clear();
    person_name_index.clear();
}

void trip_shutdown() {
    trip_initialize();
}

void trip_print_balance() {
    float total = 0;
    std::vector <float> balance(persons.size()); // all implicitly initialized to 0
    
    for(const expense & e : expenses) {
	total += e.amount;
	balance[person_id_index[e.payer]] += e.amount;
    }
    total /= persons.size();
    for(auto i = balance.begin(); i != balance.end(); ++i)
	*i -= total;
}