var mysql = require('mysql');

var serverDB = (function(connectionData, callback) {
    var queries = {
        markRead    : "UPDATE messages SET readable = TRUE WHERE message_id = ?",
        getHistory  : "SELECT * FROM messages WHERE (date_time >= ?) AND ((from_login = ? AND to_login = ?) OR (from_login = ? AND to_login = ?) ) ORDER BY date_time",
        getUG       : "SELECT * FROM users; SELECT * FROM groups",
        login       : "SELECT 1 FROM users WHERE login = ? AND password = ?",
        userExists  : "SELECT 1 FROM users WHERE login = ?",
        insertMess  : "INSERT INTO messages SET ?",
        addUser     : "INSERT INTO users SET ?",
        deleteUser  : "DELETE FROM users WHERE login = ?"
    };

    var connData = connectionData;
    connData.multipleStatements = true;

    var mysqlConnection = mysql.createConnection (connectionData);
    mysqlConnection.connect ( function (error) {
        if (error)
            throw error;
        console.log ('Successfully connected to MySQL server.');

        if (callback)
            callback(this);
    });


    function _messageSetRead(id, callback) {
        var query = util.format (queries.markRead, id);
        mysqlConnection.query (query, function (err) {
            if (err)
                throw err;
            if (callback)
                callback();
        });
    }

    function _getHistory (loginFrom, loginTo, dateAfter, callback) {
        mysqlConnection.query (
                queries.getHistory,
                [dateAfter, loginFrom, loginTo, loginTo, loginFrom],
                function (err, rows) {
                    if (err)
                        throw err;
                    if (callback)
                        callback (rows);
                }
        );
    }

    function _getUG(callback) {
        mysqlConnection.query (queries.getUG, function (err, result) {
            if (err)
                throw err;
            if (callback)
                callback (result[0], result[1]);
        });
    }

    function _checkUser(login, password, callback){
        mysqlConnection.query (queries.login, [login, password], function (err, result) {
            if (err)
                throw err;
            if (callback)
                callback (result.length !== 0);
        });
    }

    function _insertMessage (from, to, message, time, callback){
        var insertSet = {
            'from_login' : from,
            'to_login' : to,
            'message' : message,
            'date_time' : time
        };

        mysqlConnection.query (queries.insertMess, insertSet, function (err, result) {
            if (err)
                throw err;
            if (callback)
                callback (result.id);
        });
    }

    function _userExists (login, callback){
        mysqlConnection.query (queries.userExists, login, function (err, result) {
            if(err)
                throw err;
            if (callback)
                callback (result.length !== 0);
        });
    }

    function _addUser (user, callback){
        mysqlConnection.query (queries.addUser, user, function (err, result) {
            if(err)
                throw err;
            if (callback)
                callback();
        });
    }

    function _deleteUser (login, callback){
        mysqlConnection.query (queries.deleteUser, login, function (err, result) {
            if(err)
                throw err;
            if (callback)
                callback();
        });
    }

    return {
        messageSetRead : _messageSetRead,
        getHistory : _getHistory,
        getUG : _getUG,
        checkUser : _checkUser,
        insertMessage : _insertMessage,
        userExists : _userExists,
        addUser : _addUser,
        deleteUser : _deleteUser,
    };

})({
     host     : '178.62.178.14',
     user     : 'root',
     password : 'databasepassword',
     database : 'corporative_messenger'
});

function ChatClient (clientSocket) {
    this.websocket = clientSocket;
    this.authorized = false;
    this.authorizedAdmin = false;
    this.websocket.on ('message', this.onMessage);
    this.websocket.on ('close', this.onClose);
    this.websocket.on ('error', this.onError);
}

ChatClient.prototype.onClose = function (){
    server.disconnect (this);
}

ChatClient.prototype.onError = function() {

}

ChatClient.prototype.onMessage = function(message) {
    try {
        var messageData = JSON.parse(message);

        if (this.authorizedAdmin){
            switch (message.type) {
                case 'AdminAddUser': break;
                case 'AdminAddGroup': this.historyRequest (message.to, message.date_time); break;
                case 'AdminDeleteUser': this.messageRead (message.id); break;
                case 'AdminDeleteGroup': this.getUsersGroups (); break;
            }
        }
        if (this.authorized){
            switch (message.type) {
                case 'SendMessageRequest': this.sendMessage (message.to, message.message); break;
                case 'HistoryRequest': this.historyRequest (message.to, message.date_time); break;
                case 'MessageAlreadyReadable': this.messageRead (message.id); break;
                case 'GetUsersGroups': this.getUsersGroups (); break;

                default: console.log ('Unknown event ' + message.type + 'from ' + this.login);
            }
        }else {
            switch (messageData.type) {
                    case 'AuthorizeRequest' : this.obtainSession (message.login, message.password); break;
                    case 'ConfirmSession': this.confirmSession (this.login, message.session_id); break;

                    default: console.log ('Unknown event ' + message.type + 'from ' + this.login);
            }
        }
    } catch (e) {
        console.log ('Bad message from ' + this.login);
    }
};


ChatClient.prototype.adminAddUser = function (user, callback){
    server.addUser (user, function(answer) {
        this.sendData (answer, callback);
    });
}

ChatClient.prototype.adminDeleteUser = function (user, callback){
    server.deleteUser (user, function(answer) {
        this.sendData (answer, callback);
    });
}

ChatClient.prototype.adminAddGroup = function (group, callback) {
    server.addGroup (group, function(answer) {
        this.sendData (answer, callback);
    });
}

ChatClient.prototype.adminDeleteGroup = function (group, callback) {
    server.deleteGroup (group, function(answer) {
        this.sendData (answer, callback);
    });
}

ChatClient.prototype.successAuth = function (callback){
    server.successAuth (this, callback);
}

ChatClient.prototype.getUsersGroups = function (callback){
    serverDB.getUG (function(users, groups){
        this.sendData ({
            type : 'UsersGroups',
            allUsers: users,
            groupName: groups
        }, callback);
    });
}
ChatClient.prototype.sendData = function (data, callback){
    if (this.websocket)
        this.websocket.send (JSON.stringify (data), function (error) {
            if (error)
                throw error;
            if (callback)
                callback();
        });
}

ChatClient.prototype.authorize = function (login, password, callback){
    serverDB.checkUser (login, password, function (authorized){
        if (authorized){
            this.login = login;
            this.authorized = true;
            if (login == 'admin')
                this.authorizedAdmin = authorized;

            this.sendData ({
                type: 'AuthorizeRequestAnswer',
                answer: 'SuccessAuthorization'
            }, function () {
                this.successAuth (callback);
            })
        } else {
            this.sendData ({
                type: 'AuthorizeRequestAnswer',
                answer: 'WrongLoginOrPassword'
            }, callback);
        }
    });
}


ChatClient.prototype.sessionExpired = function (callback) {
    this.sendData ({
        type: 'AdminYouHasBeenDeleted'
    }, function () {
        this.websocket.close();
        if (callback)
            callback();
    });

}

ChatClient.prototype.sendMessage = function (to, message, callback) {
    var currentTime = new Date();
    serverDB.insertMessage (this.login, to, message, currentTime, function (id) {
        var messageData = {
            type: 'RenderMessageRequest',
            id:         id,
            from:       this.login,
            to:         to,
            message:    message,
            date_time:  currentTime,
            readable:   false
        };

        server.sendTo(this.login, messageData, function (){
            server.sendTo (msg.to, messageData, callback);
        });
    });
}

ChatClient.prototype.historyRequest = function (loginTo, dateAfter, callback) {
    serverDB.getHistory (this.login, loginTo, dateAfter, function (history){
        this.sendData ({
            type: 'HistoryRequestAnswer',
            answer: history
        }, callback);
    });
}

ChatClient.prototype.messageRead = function (id, callback) {
    serverDB.messageSetRead (id, callback);
}

ChatClient.prototype.userOnlineStatus = function (user, ustate, callback){
    this.sendData ({
        type: 'OnlineOfflineStateRequest',
        login: user,
        state: ustate
    }, callback);
}

ChatClient.prototype.addUser = function (userd, callback){
    this.sendData ({
        type: 'AdminAddUserAnswer',
        user: userd,
        answer: 'UserHasBeenAdded'
    }, callback);
}

ChatClient.prototype.deleteUser = function (logind, callback){
    if (logind == this.login)
        this.sessionExpired (callback);
    else {
        this.sendData ({
            type: 'AdminUserHasBeenDeleted',
            login: logind
        }, callback);
    }
}

ChatClient.prototype.addGroup = function (group_name, callback) {
}

ChatClient.prototype.deleteGroup = function (group_id, callback) {
}

// ----------------------------------------------------------------------------
var server = (function (){
    var TWebSocketServer = require('ws').Server;
    var TMySQL =  require('mysql');
    var wsserver = new TWebSocketServer ({ port: 1337 });

    var connectedClients = [];
    var authorizedClients = {};

    wsserver.on ('connection', function (ws){
        connectedClients.push (new ChatClient (ws));
    });

    wsserver.on ('error', function (error) {
        if (error)
            throw error;
    });

    function successAuth (client, callback){
        authorizedClients [client.login] = client;
    }

    function disconnect (client) {
        delete authorizedClients [client.login];
        connectedClients.remove (client);
    }

    function sendTo (login, messageData, callback) {
        if (authorizedClients[login])
            authorizedClients[login].sendData (messageData, callback);
    }

    function addUser (user, callback){
        serverDB.userExists (user.login, function (r){
            if (r) {
                if (callback)
                    callback ({
                        type: 'AdminAddUserAnswer',
                        answer: 'UserAlreadyExist',
                        user: user
                    });
            }else {
                serverDB.addUser (user, function (){
                    authorizedClients.forEach (function (client){
                        client.addUser (user);
                    });

                    if (callback)
                        callback ({
                            type: 'AdminAddUserAnswer',
                            answer: 'UserHasBeenAdded',
                            user: user
                        });
                });
            }
        });
    }

    function deleteUser (user, callback){
        serverDB.userExists (user.login, function (r){
            if (!r) {
                if (callback)
                    callback ({
                        type: 'AdminDeleteUserAnswer',
                        answer: 'UserDoesNotExist',
                        user: user
                    });
            }else {
                serverDB.deleteUser (user, function (){
                    authorizedClients.forEach (function (client){
                        client.deleteUser (user);
                    });

                    if (callback)
                        callback ({
                            type: 'AdminDeleteUserAnswer',
                            answer: 'UserHasBeenDeleted',
                            user: user
                        });
                });
            }
        });
    }

    function adminAddGroup (group, callback){

    }

    function deleteGroup (group, callback){

    }

    Array.prototype.remove = function (value) {
        var i = this.indexOf(value);
        if (i === -1) return;
        this.splice(i, 1);
    };

    return {

    }
})();