var mysql = require('mysql');
var domain = require('domain');

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",
        getUserInfo : "SELECT * FROM users WHERE login = ?",
        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) {
        mysqlConnection.query (queries.markRead, id, 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 _getUserInfo (login, callback){
        mysqlConnection.query (queries.getUserInfo, login, function (err, result) {
            if (err)
                throw err;
            if (callback)
                callback (result[0]);
        });
    }

    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,
        getUserInfo : _getUserInfo,
        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) {
    var self = this;
    this.websocket = clientSocket;
    this.authorized = false;
    this.authorizedAdmin = false;

    this.websocket.on ('message', function (message) {
        self.onMessage (message);
    });

    this.websocket.on ('close', function (){
        self.onClose();
    });

    this.websocket.on ('error', function(){
        self.onError();
    });
}

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

ChatClient.prototype.onError = function() {

}

ChatClient.prototype.onMessage = function(message) {
    var self = this;
    console.log (message);

    domain.create().on ('error', function(err){
        console.log ('Failure is handling ' + message);
        console.log ('Error: '  + err);
    }).run (function() {
        var messageData = JSON.parse(message);
        if (self.authorizedAdmin){
            switch (message.type) {
/*                case 'AdminAddUser': break;
                case 'AdminAddGroup': self.historyRequest (messageData.to, messageData.date_time); break;
                case 'AdminDeleteUser': self.messageRead (messageData.id); break;
                case 'AdminDeleteGroup': self.getUsersGroups (); break;*/
            }
        }
        if (self.authorized){
            switch (messageData.type) {
                case 'SendMessageRequest': self.sendMessage (messageData.to, messageData.message); break;
                case 'HistoryRequest': self.historyRequest (messageData.to, messageData.date_time); break;
                case 'MessageAlreadyReadable': self.messageRead (messageData.id); break;
                case 'GetUsersGroups': self.getUsersGroups (); break;

                default: console.log ('Unknown event ' + messageData.type + 'from ' + self.login);
            }
        }else {
            switch (messageData.type) {
                    case 'AuthorizeRequest' : self.authorize (messageData.login, messageData.password); break;

                    default: console.log ('Unknown event ' + messageData.type + 'from ' + self.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){
    var self = this;
    serverDB.getUG (function(users, groups){
        self.sendData ({
            type : 'UsersGroups',
            allUsers: users,
            allGroups: 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){
    var self = this;

    serverDB.getUserInfo (login, function (userData){
        if (userData == undefined || userData.password != password)
        {
            self.sendData ({
                type: 'AuthorizeRequestAnswer',
                answer: 'WrongLoginOrPassword'
            }, callback);
        } else {
            self.login = login;
            self.authorized = true;
            if (login == 'admin')
                self.authorizedAdmin = authorized;

            self.sendData ({
                type: 'AuthorizeRequestAnswer',
                answer: 'SuccessAuthorization',
                lpeers: server.getOnline(),
                user : userData
            }, function () {
                self.successAuth (callback);
            })
        }
    });
}


ChatClient.prototype.sessionExpired = function (callback) {
    var self = this;

    this.sendData ({
        type: 'AdminYouHasBeenDeleted'
    }, function () {
        self.websocket.close();
        if (callback)
            callback();
    });

}

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

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

ChatClient.prototype.historyRequest = function (loginTo, dateAfter, callback) {
    var self = this;
    serverDB.getHistory (self.login, loginTo, dateAfter, function (history){
        self.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){
    self.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: 1338 });

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

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

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

    function getOnline (callback){
       return Object.keys(authorizedClients);
    }

    function successAuth (client, callback){
        authorizedClients [client.login] = client;
        for (var login in authorizedClients)
            authorizedClients [login].userOnlineStatus (client.login, 1);
    }

    function disconnect (client) {
        console.log ('disconnect: ' + client);

        delete authorizedClients [client.login];
        connectedClients.remove (client);

        for (var login in authorizedClients)
            authorizedClients [login].userOnlineStatus (client.login, 0);
    }

    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 addGroup (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 {
        successAuth : successAuth,
        disconnect : disconnect,
        sendTo : sendTo,
        addUser : addUser,
        deleteUser : deleteUser,
        addGroup : addGroup,
        deleteGroup : deleteGroup,
        getOnline : getOnline
    }
})();