tournament.h

#ifndef TOURNAMENT_RUNNER_TOURNAMENT_H_
#define TOURNAMENT_RUNNER_TOURNAMENT_H_

#include <string>
#include <vector>
#include <utility>
#include <cstdint>

#include <boost/serialization/access.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/nvp.hpp>

#include "tournament_runner/karateka.h"
#include "tournament_runner/date.h"

using boost::serialization::make_nvp;

namespace TournamentRunner
{

struct TournamentData
{
    TournamentData& with_name (const std::string& name)
    {
        name_ = name;
        return *this;
    }

    TournamentData& with_name (std::string&& name) noexcept
    {
        name_ = std::move(name);
        return *this;
    }

    TournamentData& on_date (const Date& date)
    {
        date_ = date;
        return *this;
    }

    TournamentData& on_date (Date&& date) noexcept
    {
        date_ = std::move(date);
        return *this;
    }

    TournamentData& on_date (const std::string& date_as_string)
    {
        date_ = Date(date_as_string);
        return *this;
    }

    TournamentData& at_location (const std::string& address)
    {
        location_ = address;
        return *this;
    }

    TournamentData& at_location (std::string&& address) noexcept
    {
        location_ = std::move(address);
        return *this;
    }

    std::string name_{};
    Date date_{};
    std::string location_{};
};

class Tournament
{
public:
    Tournament () = default;

    explicit Tournament (TournamentData data);

    std::string name () const;

    std::string date_as_string () const;

    Date date() const;

    std::string location () const;

    void update_data (const TournamentData& data);

    void add_participant (const Karateka& participant);

    size_t number_of_participants () const;

    Karateka& get_participant (size_t start_number);

    void remove_participant (size_t start_number);

    std::vector<Karateka> get_ranked_list_of_participants () const;

    using RankAnnotatedParticipant = std::pair<size_t, Karateka>;

    static constexpr auto rank_annotated_participant_rank_idx = 0u;
    static constexpr auto rank_annotated_participant_karateka_idx = 1u;
    std::vector<RankAnnotatedParticipant> get_anotated_ranked_list_of_participants() const;

    uint8_t get_current_round () const;

    uint8_t start_next_kata_round ();

    std::vector<size_t> get_startlist_for_next_kata_round(size_t no_of_participants_for_round) const;

private:
    void reassign_startnumbers ();
    friend class boost::serialization::access;

    template<class Archive>
    void serialize (Archive& archive,
                    const unsigned int version);

    std::vector<size_t> get_list_of_participants_for_next_kata_round (size_t no_of_participants_for_round) const;

    TournamentData data_{};
    std::vector<Karateka> participants_;
    uint8_t current_kata_round_{};
};


inline std::string Tournament::name () const
{
    return data_.name_;
}

inline std::string Tournament::location () const
{
    return data_.location_;
}

inline Date Tournament::date () const
{
    return data_.date_;
}

inline void Tournament::update_data(const TournamentData& data)
{
    data_ = data;
}

inline uint8_t Tournament::get_current_round() const
{
    return current_kata_round_;
}

inline size_t Tournament::number_of_participants() const
{
    return participants_.size();
}


inline Karateka& Tournament::get_participant (size_t start_number)
{
    return participants_.at(start_number);
}

template<class Archive>
void Tournament::serialize (Archive& archive,
                            const unsigned int)
{
    archive & make_nvp("CurrentKataRound", current_kata_round_);
    archive & make_nvp("Name", data_.name_);
    archive & make_nvp("Location", data_.location_);
    archive & make_nvp("Date", data_.date_);
    archive & make_nvp("Participants", participants_);
}

} // namespace TournamentRunner

#endif // TOURNAMENT_RUNNER_TOURNAMENT_H_