#ifndef RECIPIENTS_HANDLER_HH
#define RECIPIENTS_HANDLER_HH

#include "recipient.hh"

#include <string>
#include <vector>

#include <boost/asio.hpp>

/**
 * \author cpellegrino
 */

boost::asio::ip::tcp::endpoint make_endpoint(const std::string& address);

class RecipientsHandler
{
  typedef std::vector<Recipient*> container_t;

  boost::asio::io_service m_service;
  const size_t m_circbuff_size;
  container_t m_recipients;

 public:

  RecipientsHandler(size_t circbuf_size = 10)
    :
    m_circbuff_size(circbuf_size)
  {}

  ~RecipientsHandler()
  {
    wipe();
  }

  bool add(const std::string& id)
  {
    if (find(make_endpoint(id)) == m_recipients.end())
    {
      m_recipients.push_back(
          new Recipient(
              m_service,
              make_endpoint(id),
              m_circbuff_size));
      return true;
    }

    return false;
  }

  bool remove(const std::string& id)
  {
    container_t::iterator it = find(make_endpoint(id));

    if (it != m_recipients.end()) {
      const Recipient* to_be_erased = *it;

      m_recipients.erase(it);

      // write on disk to_be_erased->m_cbuffer. If necessary...

      delete to_be_erased;
      return true;
    }

    return false;
  }

  bool send(const Frame& data)
  {
    bool status = false;
    if (m_recipients.size())
    {
      const size_t n = data.getSeqNumber() % m_recipients.size();
      status = m_recipients[n]->sendIfPossible(data);
    }
    return status;
  }

  void wipe()
  {
    for (size_t i = 0; i < m_recipients.size(); ++i)
    {
      delete m_recipients[i];
    }
    m_recipients.clear();
  }

 private:

  container_t::iterator find(const boost::asio::ip::tcp::endpoint& ep)
  {
    container_t::iterator it = m_recipients.begin();
    for (container_t::const_iterator et = m_recipients.end(); it != et; ++it)
    {
      if ((*it)->m_endpoint == ep)
      {
        break;
      }
    }

    return it;
  }

};

#endif // RECIPIENTS_HANDLER_HPP