#include <QDebug>

#include <QFile>

#include <QModelIndex>

#include <QModelIndexList>

#include <QPainter>

#include <QTextStream>

#include "players_model.h"

PlayersListModel::PlayersListModel(QObject *parent)

    : QAbstractListModel(parent) {

  m_fontInRoom = QFont();

  m_fontInRoom.setItalic(true);

}

int PlayersListModel::rowCount(const QModelIndex &parent) const {

  if (parent.isValid())

    return 0;

  else

    return m_data.size();

}

QVariant PlayersListModel::data(const QModelIndex &index, int role) const {

  if (!index.isValid() || index.row() < 0 || index.row() >= rowCount() ||

      index.column() != 0)

    return QVariant(QVariant::Invalid);

  return m_data.at(index.row()).value(role);

}

bool PlayersListModel::setData(const QModelIndex &index, const QVariant &value,

                               int role) {

  if (!index.isValid() || index.row() < 0 || index.row() >= rowCount() ||

      index.column() != 0)

    return false;

  m_data[index.row()].insert(role, value);

  emit dataChanged(index, index);

  return true;

}

bool PlayersListModel::insertRows(int row, int count,

                                  const QModelIndex &parent) {

  if (parent.isValid() || row > rowCount() || row < 0 || count < 1)

    return false;

  beginInsertRows(parent, row, row + count - 1);

  for (int i = 0; i < count; ++i) m_data.insert(row, DataEntry());

  endInsertRows();

  return true;

}

bool PlayersListModel::removeRows(int row, int count,

                                  const QModelIndex &parent) {

  if (parent.isValid() || row + count > rowCount() || row < 0 || count < 1)

    return false;

  beginRemoveRows(parent, row, row + count - 1);

  for (int i = 0; i < count; ++i) m_data.removeAt(row);

  endRemoveRows();

  return true;

}

QModelIndex PlayersListModel::nicknameIndex(const QString &nickname) {

  QModelIndexList mil =

      match(index(0), Qt::DisplayRole, nickname, 1, Qt::MatchExactly);

  if (mil.size() > 0)

    return mil[0];

  else

    return QModelIndex();

}

void PlayersListModel::addPlayer(const QString &nickname, bool notify) {

  insertRow(rowCount());

  QModelIndex mi = index(rowCount() - 1);

  setData(mi, nickname);

  checkFriendIgnore(mi);

  emit nickAddedLobby(nickname, notify);

}

void PlayersListModel::removePlayer(const QString &nickname,

                                    const QString &msg) {

  if (msg.isEmpty())

    emit nickRemovedLobby(nickname, QString());

  else

    emit nickRemovedLobby(nickname, msg);

  QModelIndex mi = nicknameIndex(nickname);

  if (mi.isValid()) removeRow(mi.row());

}

void PlayersListModel::playerJoinedRoom(const QString &nickname, bool notify) {

  QModelIndex mi = nicknameIndex(nickname);

  if (mi.isValid()) {

    setData(mi, true, RoomFilterRole);

    updateIcon(mi);

    updateSortData(mi);

  }

  emit nickAdded(nickname, notify);

}

void PlayersListModel::playerLeftRoom(const QString &nickname) {

  emit nickRemoved(nickname);

  QModelIndex mi = nicknameIndex(nickname);

  if (mi.isValid()) {

    setData(mi, false, RoomFilterRole);

    setData(mi, false, RoomAdmin);

    setData(mi, false, Ready);

    setData(mi, false, InGame);

    updateIcon(mi);

  }

}

void PlayersListModel::setFlag(const QString &nickname, StateFlag flagType,

                               bool isSet) {

  if (flagType == Friend) {

    if (isSet)

      m_friendsSet.insert(nickname.toLower());

    else

      m_friendsSet.remove(nickname.toLower());

    // FIXME: set proper file name

    // saveSet(m_friendsSet, "friends");

  } else if (flagType == Ignore) {

    if (isSet)

      m_ignoredSet.insert(nickname.toLower());

    else

      m_ignoredSet.remove(nickname.toLower());

    // FIXME: set proper file name

    // saveSet(m_ignoredSet, "ignore");

  }

  QModelIndex mi = nicknameIndex(nickname);

  if (mi.isValid()) {

    setData(mi, isSet, flagType);

    if (flagType == Friend || flagType == ServerAdmin || flagType == Ignore ||

        flagType == RoomAdmin)

      updateSortData(mi);

    updateIcon(mi);

  }

}

bool PlayersListModel::isFlagSet(const QString &nickname, StateFlag flagType) {

  QModelIndex mi = nicknameIndex(nickname);

  if (mi.isValid())

    return mi.data(flagType).toBool();

  else if (flagType == Friend)

    return isFriend(nickname);

  else if (flagType == Ignore)

    return isIgnored(nickname);

  else

    return false;

}

void PlayersListModel::resetRoomFlags() {

  for (int i = rowCount() - 1; i >= 0; --i) {

    QModelIndex mi = index(i);

    if (mi.data(RoomFilterRole).toBool()) {

      setData(mi, false, RoomFilterRole);

      setData(mi, false, RoomAdmin);

      setData(mi, false, Ready);

      setData(mi, false, InGame);

      updateSortData(mi);

      updateIcon(mi);

    }

  }

}

void PlayersListModel::updateIcon(const QModelIndex &index) {

  quint32 iconNum = 0;

  QList<bool> flags;

  flags << index.data(Ready).toBool() << index.data(ServerAdmin).toBool()

        << index.data(RoomAdmin).toBool() << index.data(Registered).toBool()

        << index.data(Friend).toBool() << index.data(Ignore).toBool()

        << index.data(InGame).toBool() << index.data(RoomFilterRole).toBool()

        << index.data(InRoom).toBool() << index.data(Contributor).toBool();

  for (int i = flags.size() - 1; i >= 0; --i)

    if (flags[i]) iconNum |= 1 << i;

  if (m_icons().contains(iconNum)) {

    setData(index, m_icons().value(iconNum), Qt::DecorationRole);

  } else {

    QPixmap result(24, 16);

    result.fill(Qt::transparent);

    QPainter painter(&result);

    if (index.data(RoomFilterRole).toBool()) {

      if (index.data(InGame).toBool()) {

        painter.drawPixmap(0, 0, 16, 16, QPixmap(":/res/chat/ingame.png"));

      } else {

        if (index.data(Ready).toBool())

          painter.drawPixmap(0, 0, 16, 16, QPixmap(":/res/chat/lamp.png"));

        else

          painter.drawPixmap(0, 0, 16, 16, QPixmap(":/res/chat/lamp_off.png"));

      }

    } else {  // we're in lobby

      if (!index.data(InRoom).toBool())

        painter.drawPixmap(0, 0, 16, 16, QPixmap(":/res/Flake.png"));

    }

    QString mainIconName(":/res/chat/");

    if (index.data(ServerAdmin).toBool())

      mainIconName += "serveradmin";

    else {

      if (index.data(RoomAdmin).toBool())

        mainIconName += "roomadmin";

      else

        mainIconName += "hedgehog";

      if (index.data(Contributor).toBool()) mainIconName += "contributor";

    }

    if (!index.data(Registered).toBool()) mainIconName += "_gray";

    painter.drawPixmap(8, 0, 16, 16, QPixmap(mainIconName + ".png"));

    if (index.data(Ignore).toBool())

      painter.drawPixmap(8, 0, 16, 16, QPixmap(":/res/chat/ignore.png"));

    else if (index.data(Friend).toBool())

      painter.drawPixmap(8, 0, 16, 16, QPixmap(":/res/chat/friend.png"));

    painter.end();

    QIcon icon(result);

    setData(index, icon, Qt::DecorationRole);

    m_icons().insert(iconNum, icon);

  }

  if (index.data(Ignore).toBool())

    setData(index, QColor(Qt::gray), Qt::ForegroundRole);

  else if (index.data(Friend).toBool())

    setData(index, QColor(Qt::green), Qt::ForegroundRole);

  else

    setData(index, QBrush(QColor(0xff, 0xcc, 0x00)), Qt::ForegroundRole);

}

QHash<quint32, QIcon> &PlayersListModel::m_icons() {

  static QHash<quint32, QIcon> iconsCache;

  return iconsCache;

}

void PlayersListModel::updateSortData(const QModelIndex &index) {

  QString result =

      QString("%1%2%3%4%5%6")

          // room admins go first, then server admins, then friends

          .arg(1 - index.data(RoomAdmin).toInt())

          .arg(1 - index.data(ServerAdmin).toInt())

          .arg(1 - index.data(Friend).toInt())

          // ignored at bottom

          .arg(index.data(Ignore).toInt())

          // keep nicknames starting from non-letter character at bottom within

          // group assume there are no empty nicks in list

          .arg(index.data(Qt::DisplayRole).toString().at(0).isLetter() ? 0 : 1)

          // sort ignoring case

          .arg(index.data(Qt::DisplayRole).toString().toLower());

  setData(index, result, SortRole);

}

void PlayersListModel::setNickname(const QString &nickname) {

  m_nickname = nickname;

  // FIXME: set proper file names

  // loadSet(m_friendsSet, "friends");

  // loadSet(m_ignoredSet, "ignore");

  for (int i = rowCount() - 1; i >= 0; --i) checkFriendIgnore(index(i));

}

bool PlayersListModel::isFriend(const QString &nickname) {

  return m_friendsSet.contains(nickname.toLower());

}

bool PlayersListModel::isIgnored(const QString &nickname) {

  return m_ignoredSet.contains(nickname.toLower());

}

void PlayersListModel::checkFriendIgnore(const QModelIndex &mi) {

  setData(mi, isFriend(mi.data().toString()), Friend);

  setData(mi, isIgnored(mi.data().toString()), Ignore);

  updateIcon(mi);

  updateSortData(mi);

}

void PlayersListModel::loadSet(QSet<QString> &set, const QString &fileName) {

  set.clear();

  QFile txt(fileName);

  if (!txt.open(QIODevice::ReadOnly)) return;

  QTextStream stream(&txt);

  stream.setCodec("UTF-8");

  while (!stream.atEnd()) {

    QString str = stream.readLine();

    if (str.startsWith(";") || str.isEmpty()) continue;

    set.insert(str.trimmed());

  }

  txt.close();

}

void PlayersListModel::saveSet(const QSet<QString> &set,

                               const QString &fileName) {

  qDebug("saving set");

  QFile txt(fileName);

  // list empty? => rather have no file for the list than an empty one

  if (set.isEmpty()) {

    if (txt.exists()) {

      // try to remove file, if successful we're done here.

      if (txt.remove()) return;

    } else

      // there is no file

      return;

  }

  if (!txt.open(QIODevice::WriteOnly | QIODevice::Truncate)) return;

  QTextStream stream(&txt);

  stream.setCodec("UTF-8");

  stream << "; this list is used by Hedgewars - do not edit it unless you know "

            "what you're doing!"

         << Qt::endl;

  foreach (const QString &nick, set.values())

    stream << nick << Qt::endl;

  txt.close();

}