/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            connectionhandler.cc
 *
 *  Fri Mar 30 09:25:16 CEST 2012
 *  Copyright 2012 Bent Bisballe Nyeng
 *  deva@aasimon.org
 ****************************************************************************/

/*
 *  This file is part of Munia.
 *
 *  Munia is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Munia is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Munia; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include "connectionhandler.h"

#include <stdio.h>

#include "hugin.hpp"

// Global ConnectionHandler.
ConnectionHandler connection_handler;

ConnectionHandler::ConnectionHandler()
{
}

void ConnectionHandler::init(clientid_t clientid)
{
  DEBUG(conn, "Adding client %p to connection list\n", clientid);
  connlist[clientid] = std::set<taskid_t>();

  DEBUG(conn, "Connections (%d):\n", connlist.size());
  ConnectionList::iterator it;
  for(it = connlist.begin(); it != connlist.end(); it++) {
    DEBUG(conn, "\t%p\n", it->first);
  }
}

void ConnectionHandler::close(clientid_t clientid)
{
  connlist.erase(clientid);
  DEBUG(conn, "Removed connection\n");
}

void ConnectionHandler::observe(clientid_t clientid, taskid_t taskid)
{
  connlist[clientid].insert(taskid);
  DEBUG(conn, "Added observer of %d\n", taskid);
}

void ConnectionHandler::unobserve(clientid_t clientid, taskid_t taskid)
{
  connlist[clientid].erase(taskid);
}

ObserverList ConnectionHandler::observerlist(TaskIdList tasks)
{
  DEBUG(conn, "Observerlist request (#tasks: %d)\n", tasks.size());
  ObserverList clients;

  for(TaskIdList::iterator i = tasks.begin(); i != tasks.end(); i++) {
    taskid_t tid = *i;

    DEBUG(conn, "Locating observers of node %d\n", tid);
    for(ConnectionList::iterator ci = connlist.begin();
        ci != connlist.end(); ci++) {
      std::set<taskid_t>::iterator ti = ci->second.find(tid);
      if(ti != ci->second.end()) {
        std::pair<clientid_t, taskid_t> m;
        m.first = ci->first;
        m.second = tid;
        clients.push_back(m);
      }
    }
  }

  return clients;
}


#ifdef TEST_CONNECTIONHANDLER
//deps:
//cflags:
//libs:

#include "test.h"

TEST_BEGIN;

ConnectionHandler &h = connection_handler;

h.init((clientid_t)1);
h.observe((clientid_t)1, (taskid_t)1);
h.observe((clientid_t)1, (taskid_t)2);

h.init((clientid_t)2);
h.observe((clientid_t)2, (taskid_t)1);
h.observe((clientid_t)2, (taskid_t)2);

h.init((clientid_t)3);
h.observe((clientid_t)3, (taskid_t)3);

{
  TaskIdList tasks;
  tasks.push_back((taskid_t)1);
  ObserverList clst = h.observerlist(tasks);

  TEST_TRUE(clst.find((clientid_t)1) != clst.end(), "Got client 1?");
  TEST_TRUE(clst.find((clientid_t)2) != clst.end(), "Got client 2?");
  TEST_FALSE(clst.find((clientid_t)3) != clst.end(), "Got client 3?");
}

{
  TaskIdList tasks;
  tasks.push_back((taskid_t)3);
  ObserverList clst = h.observerlist(tasks);

  TEST_FALSE(clst.find((clientid_t)1) != clst.end(), "Got client 1?");
  TEST_FALSE(clst.find((clientid_t)2) != clst.end(), "Got client 2?");
  TEST_TRUE(clst.find((clientid_t)3) != clst.end(), "Got client 3?");
}

{
  TaskIdList tasks;
  tasks.push_back((taskid_t)4);
  ObserverList clst = h.observerlist(tasks);

  TEST_FALSE(clst.find((clientid_t)1) != clst.end(), "Got client 1?");
  TEST_FALSE(clst.find((clientid_t)2) != clst.end(), "Got client 2?");
  TEST_FALSE(clst.find((clientid_t)3) != clst.end(), "Got client 3?");
}

{
  TaskIdList tasks;
  tasks.push_back((taskid_t)1);
  tasks.push_back((taskid_t)2);
  tasks.push_back((taskid_t)3);
  ObserverList clst = h.observerlist(tasks);

  TEST_TRUE(clst.find((clientid_t)1) != clst.end(), "Got client 1?");
  TEST_TRUE(clst.find((clientid_t)2) != clst.end(), "Got client 2?");
  TEST_TRUE(clst.find((clientid_t)3) != clst.end(), "Got client 3?");
}

h.close((clientid_t)1);
{
  TaskIdList tasks;
  tasks.push_back((taskid_t)1);
  tasks.push_back((taskid_t)2);
  tasks.push_back((taskid_t)3);
  ObserverList clst = h.observerlist(tasks);

  TEST_FALSE(clst.find((clientid_t)1) != clst.end(), "Got client 1?");
  TEST_TRUE(clst.find((clientid_t)2) != clst.end(), "Got client 2?");
  TEST_TRUE(clst.find((clientid_t)3) != clst.end(), "Got client 3?");
}

h.close((clientid_t)2);
{
  TaskIdList tasks;
  tasks.push_back((taskid_t)1);
  tasks.push_back((taskid_t)2);
  tasks.push_back((taskid_t)3);
  ObserverList clst = h.observerlist(tasks);

  TEST_FALSE(clst.find((clientid_t)1) != clst.end(), "Got client 1?");
  TEST_FALSE(clst.find((clientid_t)2) != clst.end(), "Got client 2?");
  TEST_TRUE(clst.find((clientid_t)3) != clst.end(), "Got client 3?");
}

h.close((clientid_t)3);
{
  TaskIdList tasks;
  tasks.push_back((taskid_t)1);
  tasks.push_back((taskid_t)2);
  tasks.push_back((taskid_t)3);
  ObserverList clst = h.observerlist(tasks);

  TEST_FALSE(clst.find((clientid_t)1) != clst.end(), "Got client 1?");
  TEST_FALSE(clst.find((clientid_t)2) != clst.end(), "Got client 2?");
  TEST_FALSE(clst.find((clientid_t)3) != clst.end(), "Got client 3?");
}

TEST_END;

#endif/*TEST_CONNECTIONHANDLER*/