#include "../include/Channel.hpp"
#include <odhtdb/Database.hpp>
#include <odhtdb/bin2hex.hpp>
#include <cstring>
#include <sibs/SafeSerializer.hpp>

using namespace std;

namespace dchat
{
    static Channel *currentChannel;
    
    Channel::Channel(const string &_name, const odhtdb::DatabaseNode &_databaseNodeInfo, User *_localUser, odhtdb::Database *_database) : 
        database(_database),
        databaseNodeInfo(_databaseNodeInfo),
        name(_name),
        messageBoard(this),
        localUser(_localUser ? _localUser : new OfflineUser("You"))
    {
        addUserLocally(localUser);
            
        //addLocalMessage(u8"[emoji](https://discordemoji.com/assets/emoji/PepeDab.gif) deaf [emoji](https://discordemoji.com/assets/emoji/COGGERS.gif)", &systemUser, 0, odhtdb::Hash());
        //addLocalMessage(u8"[emoji](https://discordemoji.com/assets/emoji/PepeDab.gif)[emoji](https://discordemoji.com/assets/emoji/COGGERS.gif)", &systemUser, 0, odhtdb::Hash());
        //addLocalMessage(u8"pepedab https://discordemoji.com/assets/emoji/PepeDab.gif coggers https://discordemoji.com/assets/emoji/COGGERS.gif check out this url http://www.grandtournation.com/6808/start-date-of-the-grand-tour-season-3-confirmed-mark-your-calendars/ owo", &systemUser, 0, odhtdb::Hash());
       // addLocalMessage(u8"ht clic", &systemUser, 0, odhtdb::Hash());
        
        if(database)
            database->seed(databaseNodeInfo);
    }
    
    Channel::~Channel()
    {
        if(database)
            database->stopSeeding(*databaseNodeInfo.getRequestHash());
        
        for(User *user : users)
        {
            delete user;
        }
    }
    
    User* Channel::getLocalUser()
    {
        return localUser;
    }
    
    SystemUser* Channel::getSystemUser()
    {
        return &systemUser;
    }
    
    MessageBoard& Channel::getMessageBoard()
    {
        return messageBoard;
    }
    
    const string& Channel::getName() const
    {
        return name;
    }
    
    const vector<User*> Channel::getUsers() const
    {
        return users;
    }
    
    OnlineUser* Channel::getUserByPublicKey(const odhtdb::Signature::PublicKey &publicKey)
    {
        auto userIt = publicKeyOnlineUsersMap.find(publicKey);
        if(userIt != publicKeyOnlineUsersMap.end())
            return userIt->second;
        return nullptr;
    }
    
    const odhtdb::DatabaseNode& Channel::getNodeInfo() const
    {
        return databaseNodeInfo;
    }
    
    void Channel::addLocalMessage(const std::string &msg, User *owner, u64 timestampSeconds)
    {
        addLocalMessage(msg, owner, timestampSeconds, odhtdb::Hash());
    }
    
    void Channel::addLocalMessage(const std::string &msg, User *owner, u64 timestampSeconds, const odhtdb::Hash &id)
    {
        assert(owner);
        if(timestampSeconds == 0)
        {
            timestampSeconds = time(NULL);
        }
        messageBoard.addMessage(new Message(owner, msg, timestampSeconds), id);
    }
    
    void Channel::addMessage(const std::string &msg)
    {
        if(database && localUser->type == User::Type::ONLINE_LOCAL_USER)
        {
            auto onlineLocalUser = static_cast<OnlineLocalUser*>(localUser);
            
            sibs::SafeSerializer serializer;
            serializer.add(ChannelDataType::ADD_MESSAGE);
            serializer.add((const u8*)msg.data(), msg.size());
            
            database->addData(databaseNodeInfo, onlineLocalUser->keyPair, odhtdb::DataView(serializer.getBuffer().data(), serializer.getBuffer().size()));
        }
        else
            addLocalMessage(msg, localUser, 0, odhtdb::Hash());
    }
    
    void Channel::deleteLocalMessage(const odhtdb::Hash &id, const odhtdb::Signature::PublicKey &requestedByUser)
    {
        messageBoard.deleteMessage(id, requestedByUser);
    }
    
    void Channel::deleteMessage(const odhtdb::Hash &id, const odhtdb::Signature::PublicKey &requestedByUser)
    {
        if(database && localUser->type == User::Type::ONLINE_LOCAL_USER)
        {
            auto onlineLocalUser = static_cast<OnlineLocalUser*>(localUser);
            
            sibs::SafeSerializer serializer;
            serializer.add(ChannelDataType::DELETE_MESSAGE);
            serializer.add((const u8*)id.getData(), odhtdb::HASH_BYTE_SIZE);
            
            database->addData(databaseNodeInfo, onlineLocalUser->keyPair, odhtdb::DataView(serializer.getBuffer().data(), serializer.getBuffer().size()));
        }
        else
            deleteLocalMessage(id, requestedByUser);
    }
    
    void Channel::addUserLocally(User *user)
    {
        users.push_back(user);
        user->avatarUrl = "https://discordemoji.com/assets/emoji/HanekawaSmug.gif";
        if(user->isOnlineUser())
        {
            auto onlineUser = static_cast<OnlineUser*>(user);
            publicKeyOnlineUsersMap[onlineUser->getPublicKey()] = onlineUser;
        }
    }
    
    bool Channel::addUser(const odhtdb::Signature::PublicKey &userId, const odhtdb::DataView &groupId)
    {
        assert(database);
        if(!database || localUser->type != User::Type::ONLINE_LOCAL_USER)
            return false;
        
        if(groupId.size != odhtdb::GROUP_ID_LENGTH)
        {
            fprintf(stderr, "Group id is wrong size. Expected to be %u bytes, was %u byte(s)\n", odhtdb::GROUP_ID_LENGTH, groupId.size);
            return false;
        }
        
        auto onlineLocalUser = static_cast<OnlineLocalUser*>(localUser);
        try
        {
            database->addUser(databaseNodeInfo, onlineLocalUser->keyPair, userId, groupId);
            return true;
        }
        catch(std::exception &e)
        {
            fprintf(stderr, "Group with id %s does not exist in channel %s or you do not have permission to add user to that group\nError: %s\n", odhtdb::bin2hex((const char*)groupId.data, groupId.size).c_str(), databaseNodeInfo.getRequestHash()->toString().c_str(), e.what());
            return false;
        }
    }
    
    void Channel::replaceLocalUser(OnlineLocalUser *newOnlineLocalUser)
    {
        for(vector<User*>::iterator it = users.begin(); it != users.end(); ++it)
        {
            if(*it == localUser)
            {
                users.erase(it);
                delete localUser;
                break;
            }
        }
        
        localUser = newOnlineLocalUser;
        addUserLocally(newOnlineLocalUser);
    }
    
    void Channel::changeNick(const std::string &newNick)
    {
        if(database && localUser->type == User::Type::ONLINE_LOCAL_USER)
        {
            auto onlineLocalUser = static_cast<OnlineLocalUser*>(localUser);
            
            sibs::SafeSerializer serializer;
            serializer.add(ChannelDataType::NICKNAME_CHANGE);
            serializer.add((u8)newNick.size());
            serializer.add((const u8*)newNick.data(), newNick.size());
            
            database->addData(databaseNodeInfo, onlineLocalUser->keyPair, odhtdb::DataView(serializer.getBuffer().data(), serializer.getBuffer().size()));
        }
    }
    
    void Channel::processEvent(const sf::Event &event, Cache &cache)
    {
        chatbar.processEvent(event, cache, this);
        messageBoard.processEvent(event, cache);
    }
    
    void Channel::draw(sf::RenderWindow &window, Cache &cache)
    {
        messageBoard.draw(window, cache);
        chatbar.draw(window, cache);
    }
    
    void Channel::setCurrent(Channel *channel)
    {
        currentChannel = channel;
    }
    
    Channel* Channel::getCurrent()
    {
        return currentChannel;
    }
}