#include "room.h"

#include <algorithm>
#include <server.h>
#include <unistd.h>
#include <iostream>

namespace Yc {
    namespace Lib {

        Room::Room(Server *parent, std::string name, std::string password, std::vector<std::string> allowedUsers) :
                _parent(parent),
                _name(name),
                _password(password),
                _allowedUsers(allowedUsers),
                _blocked(false),
                _stop(false) {
            thread = new std::thread(&Room::run, this);
        }

        void Room::run() {
            while (!_stop) {
                if (_msgQueue.size() > 0 && !_blocked) {
                    _blocked = true;
                    while (_msgQueue.size() > 0) {
                        Message message = _msgQueue.front();
                        _msgQueue.pop();
                        for (auto &user: _users) {
                            user.sendMsg(message.type, message.messageTr, message.userName, message.color);
                        }
                    }
                    _blocked = false;
                }
                usleep(50000);
            }
        }

        bool Room::addUser(std::string _userName, std::string color, std::string _password, int socket) {
            if (_password != "" && _password == _password && std::find(std::begin(_allowedUsers), std::end(_allowedUsers), _userName) == std::end(_allowedUsers)) {
                return false;
            }
            User newUser(this, _userName, color, socket);
            _users.push_back(newUser);
            newUser.sendMsg(User::roomList, _parent->jsonRoomList(), "", "");
            addMessage(User::system, "room_entered", newUser.name(), newUser.color());
            return true;
        }

        bool Room::addUser(User user, std::string password) {
            if (password == _password) {
                _users.push_back(user);
                return true;
            }
            return false;
        }

        bool Room::userNameExists(std::string userName) {
            for (auto &user: _users) {
                if (user.name() == userName) {
                    return true;
                }
            }
            return false;
        }

        void Room::removeUser(std::string _token) {
            for (std::vector<User>::iterator user = _users.begin(); user != _users.end(); ++user) {
                if (user->validateToken(_token)) {
                    _users.erase(user);
                }
            }
        }

        void Room::setStop() {
            _stop = true;
        }

        void Room::addMessage(User::MsgType type, std::string messageText, std::string userName, std::string color)
        {
            Message message;
            message.type = type;
            message.messageTr = messageText;
            message.userName = userName;
            message.color = color;
            _msgQueue.push(message);
        }

        std::string Room::name() {
            return _name;
        }

    } // namespace Lib
} // namespace Yc