/*
 * UserList.h
 *
 * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef MAD_COMMON_USERLISTS_USERLIST_H_
#define MAD_COMMON_USERLISTS_USERLIST_H_

#include "../export.h"

#include "UserListEntry.h"

#include <list>
#include <map>
#include <set>

namespace Mad {
namespace Common {
namespace UserLists {

class MAD_COMMON_EXPORT UserList {
  private:
    template <typename Type, typename IteratorType>
    class iterator_base {
      public:
        friend class UserList;

        typedef Type value_type;

        typedef value_type &reference;
        typedef value_type *pointer;

        typedef long difference_type;

      private:
        IteratorType it;

        iterator_base(IteratorType it0) : it(it0) {}

      public:
        iterator_base() {}

        reference operator*() const {
          return *it;
        }

        iterator_base operator++(int) {
          return iterator(it++);
        }

        iterator_base& operator++() {
          ++it;
          return *this;
        }

        iterator_base operator--(int) {
          return iterator(it--);
        }

        iterator_base& operator--() {
          --it;
          return *this;
        }

        bool operator==(const iterator_base &it2) {
          return it2.it == it;
        }

        bool operator!=(const iterator_base &it2) {
          return it2.it != it;
        }

        pointer operator->() const {
          return &*it;
        }
    };

    std::set<std::string> names;
    std::list<UserListEntry> list;

    std::map<std::string, unsigned> detailCounts;

    void registerEntry(const UserListEntry &entry);
    void unregisterEntry(const UserListEntry &entry);

    std::list<UserListEntry>::iterator findEntry(const std::string &name);
    std::list<UserListEntry>::const_iterator findEntry(const std::string &name) const;

  public:
    typedef iterator_base<const UserListEntry, std::list<UserListEntry>::iterator> iterator;
    typedef iterator_base<const UserListEntry, std::list<UserListEntry>::const_iterator> const_iterator;

    iterator find(const std::string &name);
    const_iterator find(const std::string &name) const;

    iterator begin() {
      return iterator(list.begin());
    }

    const_iterator begin() const {
      return const_iterator(list.begin());
    }

    iterator end() {
      return list.end();
    }

    const_iterator end() const {
      return const_iterator(list.end());
    }

    bool isEmpty() const {
      return list.empty();
    }

    size_t getLength() const {
      return list.size();
    }

    std::set<std::string> getDetails() const {
      std::set<std::string> ret;

      for(std::map<std::string, unsigned>::const_iterator it = detailCounts.begin(); it != detailCounts.end(); ++it)
        ret.insert(it->first);

      return ret;
    }

    unsigned getDetailUsage(const std::string &detail) const {
      std::map<std::string, unsigned>::const_iterator it = detailCounts.find(detail);
      if(it == detailCounts.end())
        return 0;
      else
        return it->second;
    }

    bool addUser(const UserListEntry &entry);
    bool insertUser(const UserListEntry &entry, iterator after);
    bool removeUser(const std::string &name);
    bool updateUser(const UserListEntry &entry);

    UserList() {}
};

}
}
}

#endif /* MAD_COMMON_USERLISTS_USERLIST_H_ */