#pragma once

#include "utils.hpp"
#include "types.hpp"
#include "StringView.hpp"
#include "User.hpp"
#include <string>
#include <memory>
#include <vector>
#include <functional>
#include <mutex>
#include <odhtdb/Database.hpp>

namespace dchat
{
    struct RoomMessage
    {
        odhtdb::Hash id;
        std::shared_ptr<User> creator;
        uint32_t timestampSeconds;
        std::string text;
    };

    class Rooms;

    class Room
    {
        DISABLE_COPY(Room)
        friend class Rooms;
    public:
        Room(Rooms *rooms, std::shared_ptr<odhtdb::Hash> id);
        // Throws exception on failure if we are not allowed to add the user to the group
        void addUser(const odhtdb::Signature::PublicKey &userPublicKey, std::shared_ptr<Group> group);

        // Returns null if user doesn't exist in room
        std::shared_ptr<User> getUserByPublicKey(const odhtdb::Signature::PublicKey &userPublicKey);

        // Returns null if group doesn't exist in room
        std::shared_ptr<Group> getGroupById(const odhtdb::DataView groupId);

        void setAvatarUrl(const std::string &url);
        void setUserNickname(const std::string &nickname);
        bool setName(const std::string &name);
        void publishMessage(const std::string &msg);

        const odhtdb::Signature::MapPublicKey<std::shared_ptr<User>>& getUsers() const { return userByPublicKey; }
        const std::vector<std::shared_ptr<RoomMessage>>& getMessages() const { return messages; }

        Rooms *rooms;
        std::shared_ptr<odhtdb::Hash> id;
        std::shared_ptr<odhtdb::OwnedByteArray> encryptionKey;
        std::string name;
        std::shared_ptr<User> localUser;
        std::string inviteKey;
        void *userdata;

        // TODO: Move to private when we have proper support for groups
        std::vector<std::shared_ptr<Group>> groups;
    private:
        // Returns null if the user already exists in the room
        std::shared_ptr<User> addUserLocally(const odhtdb::Signature::PublicKey &userPublicKey, std::shared_ptr<Group> group);
        // Returns null if the group already exists in the room
        std::shared_ptr<Group> addGroupLocally(const odhtdb::DataView groupId);
        void setLocalUser(std::shared_ptr<User> user, std::shared_ptr<odhtdb::Signature::KeyPair> keyPair);
    private:
        odhtdb::Signature::MapPublicKey<std::shared_ptr<User>> userByPublicKey;
        // Used for local users
        odhtdb::Signature::MapPublicKey<std::shared_ptr<odhtdb::Signature::KeyPair>> publicKeyToKeyPairMap;

        std::vector<std::shared_ptr<RoomMessage>> messages;
    };

    struct RoomAddMessageRequest
    {
        std::shared_ptr<Room> room;
        bool loadedFromCache;
        std::shared_ptr<RoomMessage> message;
        std::shared_ptr<RoomMessage> prevMessage;
    };

    struct UserChangeNicknameRequest
    {
        std::shared_ptr<Room> room;
        std::shared_ptr<User> user;
        uint32_t timestampSeconds;
        bool loadedFromCache;
        std::string newNickname;
    };

    struct UserChangeAvatarRequest
    {
        std::shared_ptr<Room> room;
        std::shared_ptr<User> user;
        uint32_t timestampSeconds;
        bool loadedFromCache;
        std::string url;
    };

    struct RoomChangeNameRequest
    {
        std::shared_ptr<Room> room;
        std::shared_ptr<User> user;
        uint32_t timestampSeconds;
        bool loadedFromCache;
        std::string newName;
    };

    struct InviteUserRequest
    {
        Room *room;
        odhtdb::Signature::PublicKey userPublicKey;
        std::string message;
    };

    struct RoomAddUserRequest
    {
        std::shared_ptr<Room> room;
        std::shared_ptr<User> user;
        std::shared_ptr<User> addedByUser;
        uint32_t timestampSeconds;
        bool loadedFromCache;
        bool isLocalUser;
        bool waitedToJoin;
    };

    // if connection failed then @rooms is null and errMsg contains the error
    using ConnectBoostrapNodeCallbackFunc = std::function<void(std::shared_ptr<Rooms> rooms, const char *errMsg)>;
    using CreateRoomCallbackFunc = std::function<void(std::shared_ptr<Room> room)>;
    using RoomAddUserCallbackFunc = std::function<void(const RoomAddUserRequest &request)>;
    using RoomAddMessageCallbackFunc = std::function<void(const RoomAddMessageRequest &request)>;
    using UserChangeNicknameCallbackFunc = std::function<void(const UserChangeNicknameRequest &request)>;
    using UserChangeAvatarCallbackFunc = std::function<void(const UserChangeAvatarRequest &request)>;
    using ChangeRoomNameCallbackFunc = std::function<void(const RoomChangeNameRequest &request)>;
    using ReceiveInviteUserCallbackFunc = std::function<void(const InviteUserRequest &request)>;
    struct RoomCallbackFuncs
    {
        ConnectBoostrapNodeCallbackFunc connectCallbackFunc;
        CreateRoomCallbackFunc createRoomCallbackFunc;
        RoomAddUserCallbackFunc addUserCallbackFunc;
        RoomAddMessageCallbackFunc addMessageCallbackFunc;
        UserChangeNicknameCallbackFunc userChangeNicknameCallbackFunc;
        UserChangeAvatarCallbackFunc userChangeAvatarCallbackFunc;
        ChangeRoomNameCallbackFunc changeRoomNameCallbackFunc;
        ReceiveInviteUserCallbackFunc receiveInviteUserCallbackFunc;
    };

    class Rooms
    {
        friend Room;
        DISABLE_COPY(Rooms)
    public:
        // @callbackFuncs.connectCallbackFunc can't be null.
        // @address is used in another thread so it may need to live beyond the scope which Rooms::connect is called from
        static void connect(const char *address, u16 port, RoomCallbackFuncs callbackFuncs);
        // Throws on failure
        void loginUser(const std::string &username, const std::string &password);
        // Throws on failure
        void registerUser(const std::string &username, const std::string &password);
        // Throws on failure
        std::shared_ptr<Room> createRoom(const std::string &name);
        // Throws on failure, returns true on success, returns false on expected failures (such as already being a member of the room)
        bool requestJoinRoom(const std::string &inviteKey, const std::string &message);

        std::shared_ptr<odhtdb::Database> database;

        const odhtdb::MapHash<std::shared_ptr<Room>>& getRooms() const { return roomById; }
        bool isLoggedIn() const { return loggedIn; }
    private:
        Rooms(const char *address, u16 port, RoomCallbackFuncs callbackFuncs);
        void createNodeCallbackFunc(const odhtdb::DatabaseCreateNodeRequest &request);
        void addNodeCallbackFunc(const odhtdb::DatabaseAddNodeRequest &request);
        void addUserCallbackFunc(const odhtdb::DatabaseAddUserRequest &request);
    private:
        odhtdb::MapHash<std::shared_ptr<Room>> roomById;
        RoomCallbackFuncs callbackFuncs;
        bool loggedIn;
        odhtdb::MapHash<std::shared_ptr<odhtdb::Signature::KeyPair>> roomLocalUser;
        odhtdb::MapHash<std::shared_ptr<odhtdb::OwnedByteArray>> roomEncryptionKey;

        std::string currentUsername;
        std::string currentUserPassword;
        std::recursive_mutex roomModifyMutex;

        odhtdb::MapHash<std::shared_ptr<odhtdb::Signature::KeyPair>> waitingToJoinRoom;
        std::recursive_mutex waitingToJoinRoomMutex;
    };
}