public bool checkJobAvailable(string typeString, int carNumber, NetworkPlayer networkPlayer)
        {
            if (carNumber < 0 || carNumber >= Game.Cars.Count)
            {
                return false;
            }

            Car car = Game.Cars[carNumber];
            if (car == null)
            {
                return false;
            }

            Player player = (typeString == "Throttler" ? car.Throttler : car.Driver);
            if (player.NetworkPlayer != default(NetworkPlayer))
            {
                return false;
            }

            if (typeString == "Throttler")
            {
                car.Throttler.NetworkPlayer = networkPlayer;
            }
            else
            {
                car.Driver.NetworkPlayer = networkPlayer;
            }
            return true;
        }

 public static string GenerateToken(string identifier, string password_or_token, NetworkPlayer? np = null)
 {
     PurpleAccount userData = get_database_user (identifier);
     if(userData == null)
         return string.Empty;
     return GenerateToken (userData, password_or_token, np);
 }

 // HANDLER /////////////////////////
 // ACCOUNT /////////////////////////
 public static void client_validate_username_handler(string dataObject, NetworkPlayer np)
 {
     PurpleDebug.Log("Username validation received: #" + np.ToString());
     _PMBasic.Data basicData = PurpleSerializer.StringToObjectConverter<_PMBasic.Data> (dataObject);
     basicData.validate = AccountHelper.IsUniqueUsername (basicData.data);
     PurpleNetwork.ToPlayer (np, "server_validate_username_result", basicData);
 }

 public void ServerPlaceBlock( NetworkPlayer sender, int x, int y, int z, int chunkx, int chunky, int chunkz, int data )
 {
     if (EnableDebugLog) Debug.Log ("UniblocksServer: Received PlaceBlock from player " + sender.ToString());
     // You can check whether the change sent by the client is valid here
     // if (true) {
     DistributeChange (sender, x,y,z, chunkx, chunky,chunkz, data, false);
     // }
 }

 public static void SwitchServer(NetworkPlayer np, string hostname, string password, int port, string token)
 {
     _PMServer.SwitchMessage switchObject = new _PMServer.SwitchMessage ();
     switchObject.Hostname = hostname;
     switchObject.Password = password;
     switchObject.Port = port;
     switchObject.SwitchToken = token;
     PurpleNetwork.ToPlayer (np, "server_switch", switchObject);
 }

        // DESTROY /////////////////////////
        public static void remove_account_handler(object ob, NetworkPlayer np)
        {
            PurpleNetwork.RemoveListener("client_validate_username", client_validate_username_handler);
            PurpleNetwork.RemoveListener("client_register", client_register_handler);
            PurpleNetwork.RemoveListener("client_disable", client_disable_handler);

            PurpleNetwork.RemoveListener("client_create_character", client_create_character_handler);

            PurpleNetwork.DisconnectedFromPurpleServer -= remove_account_handler;
        }

 public void SendVoxelData( NetworkPlayer player, int chunkx, int chunky, int chunkz )
 {
     // >> You can check whether the request for voxel data is valid here <<
     // if (true) {
     Chunk chunk = ChunkManager.SpawnChunk (chunkx,chunky,chunkz).GetComponent<Chunk>(); // get the chunk (spawn it if it's not spawned already)
     chunk.Lifetime = 0f; // refresh the chunk's lifetime
     string data = ChunkDataFiles.CompressData (chunk); // get data from the chunk and compress it
     byte[] dataBytes = GetBytes (data); // convert to byte array (sending strings over RPC doesn't work too well)
     GetComponent<NetworkView>().RPC ("ReceiveVoxelData", player, chunkx, chunky, chunkz, dataBytes); // send compressed data to the player who requested it
     // }
 }

        public static void client_authenticate_switch_handler(string dataObject, NetworkPlayer np)
        {
            PurpleDebug.Log("Authentication Switch received: #" + np.ToString());
            if(np.ToString() == Constants.SERVER_ID_STRING && Network.isServer) return;

            _PMClient.Authentication authObject = PurpleSerializer.StringToObjectConverter<_PMClient.Authentication> (dataObject);
            bool validationResult = false;
            string newToken = string.Empty;

            // TODO...
        }

        //TODO: test
        public static void client_disable_handler(string dataObject, NetworkPlayer np)
        {
            PurpleDebug.Log("Authentication received: #" + np.ToString());
            _PMClient.Authentication authObject = PurpleSerializer.StringToObjectConverter<_PMClient.Authentication> (dataObject);
            _PMBasic.Boolean returnData = new _PMBasic.Boolean ();
            returnData.value = AccountHelper.Disable (authObject.ClientName, authObject.ClientPassword, np);

            AccountHelper.AddLog(get_network_player_reference(np).UserName,
                                 "client_disable_handler " + authObject.ClientName + " - " + returnData.value.ToString());
            PurpleNetwork.ToPlayer (np, "server_disable_result", returnData);
        }

        // multiplayer
        public static void DestroyBlockMultiplayer( VoxelInfo voxelInfo, NetworkPlayer sender )
        {
            // received from server, don't use directly

            GameObject voxelObject = Instantiate ( Engine.GetVoxelGameObject (voxelInfo.GetVoxel()) ) as GameObject;
            VoxelEvents events = voxelObject.GetComponent<VoxelEvents>();
            if (events != null) {
            events.OnBlockDestroy(voxelInfo);
            events.OnBlockDestroyMultiplayer(voxelInfo, sender);
            }
            voxelInfo.chunk.SetVoxel (voxelInfo.index, 0, true);
            Destroy(voxelObject);
        }

 // EVENT /////////////////////////
 public static void connected_to_server_handler(object ob, NetworkPlayer np)
 {
     // TODO - server switch
     if(string.IsNullOrEmpty(PurpleClient.CurrentConfig.ServerSwitchToken))
     {
         Calls.Base.Authenticate (PurpleClient.CurrentConfig);
     }
     else
     {
         Calls.Base.AuthenticateSwitch (PurpleClient.CurrentConfig);
     }
     Calls.Base.GetVersion ();
 }

        public static void client_authenticate_handler(string dataObject, NetworkPlayer np)
        {
            PurpleDebug.Log("Authentication received: #" + np.ToString());
            if(np.ToString() == Constants.SERVER_ID_STRING && Network.isServer) return;

            _PMClient.Authentication authObject = PurpleSerializer.StringToObjectConverter<_PMClient.Authentication> (dataObject);
            bool validationResult = false;
            string newToken = string.Empty;

            if(string.IsNullOrEmpty(authObject.ClientPassword))
            {
                validationResult = AccountHelper.ValidateAuthentication (authObject.ClientName, authObject.ClientToken);
                if(validationResult)
                    newToken = AccountHelper.GenerateToken(authObject.ClientName, authObject.ClientToken, np);
            }
            else
            {
                validationResult = AccountHelper.Login (authObject.ClientName, authObject.ClientPassword, np, out newToken);
            }

            authObject.validate = validationResult;
            authObject.timestamp = DateTime.Now;

            // save 2 spaces if monitoring is allowed otherwise just one for Admin/Mod/GM
            int maxAllowedConnections = PurpleServer.CurrentConfig.ServerMaxClients;
            maxAllowedConnections -= (PurpleServer.CurrentConfig.ServerAllowMonitoring) ? 2 : 1;

            authObject.ClientPassword = String.Empty;
            authObject.ClientToken = String.Empty;
            authObject.ClientAuthenticated = false;

            if(validationResult && PurpleServer.UserList.Count <= maxAllowedConnections)
            {
                authObject.ClientToken = newToken;
                authObject.ClientAuthenticated = true;

            }
            else if(validationResult)
            {
                PurpleNetworkUser playerReference = get_network_player_reference(np);
                if (playerReference.UserType != UserTypes.User)
                {
                    authObject.ClientToken = newToken;
                    authObject.ClientAuthenticated = true;
                }
            }
            AccountHelper.AddLog(get_network_player_reference(np).UserName, "client_authenticate_handler "
                                 + authObject.ClientName + " - "+ authObject.ClientAuthenticated);
            PurpleDebug.Log("Authentication result: " + authObject.ClientName + ": " + authObject.ClientAuthenticated);
            PurpleNetwork.ToPlayer(np, "server_authenticate_result", authObject);
        }

        public static void ChangeBlockMultiplayer( VoxelInfo voxelInfo, ushort data, NetworkPlayer sender )
        {
            // received from server, don't use directly

            voxelInfo.chunk.SetVoxel (voxelInfo.index, data, true);

            GameObject voxelObject = Instantiate ( Engine.GetVoxelGameObject (data) ) as GameObject;
            VoxelEvents events = voxelObject.GetComponent<VoxelEvents>();
            if (events != null) {
            events.OnBlockChange(voxelInfo);
            events.OnBlockChangeMultiplayer(voxelInfo, sender);
            }
            Destroy (voxelObject);
        }

        public PurpleNetworkUser(NetworkPlayer player)
        {
            UserReference 		= player;

            UserGUID 			= new Guid ();
            UserID				= -1;
            UserType 			= UserTypes.User;
            UserAuthenticated 	= false;
            UserConnectedTime 	= DateTime.Now;

            UserName			= String.Empty;
            UserPassword        = String.Empty;
            UserToken 			= String.Empty;
            UserTokenCreated	= DateTime.MinValue;
        }

        public void ReceiveChangeBlock( NetworkPlayer sender, int x, int y, int z, int chunkx, int chunky, int chunkz, int data )
        {
            // receives a change sent by other client or server

            GameObject chunkObject = ChunkManager.GetChunk (chunkx,chunky,chunkz);
            if (chunkObject != null) {

            // convert back to VoxelInfo
            Index voxelIndex = new Index (x,y,z);
            VoxelInfo info = new VoxelInfo (voxelIndex, chunkObject.GetComponent<Chunk>());

            // apply change
            Voxel.ChangeBlockMultiplayer (info, (ushort)data, sender);
            }
        }

        // DESTROY /////////////////////////
        public static void remove_base_handler(object ob, NetworkPlayer np)
        {
            PurpleClient.CurrentConfig.PlayerAuthenticated = false;
            PurpleNetwork.ConnectedToPurpleServer -= connected_to_server_handler;

            PurpleNetwork.RemoveListener("server_broadcast", server_broadcast_handler);

            PurpleNetwork.RemoveListener("server_authenticate_result", server_authenticate_result_handler);
            PurpleNetwork.RemoveListener("server_generate_token_result", server_generate_token_result_handler);
            PurpleNetwork.RemoveListener("server_logout_result", server_logout_result_handler);
            PurpleNetwork.RemoveListener("server_ping", server_ping_handler);
            PurpleNetwork.RemoveListener("server_switch", server_switch_handler);
            PurpleNetwork.RemoveListener("server_version_result", server_version_result_handler);

            PurpleNetwork.DisconnectedFromPurpleServer -= remove_base_handler;
        }

        public static bool Disable(string identifier, string password, NetworkPlayer? np = null)
        {
            if(!ValidateAuthentication (identifier, password))
                return false;

            PurpleAccount userData = get_database_user (identifier);
            if(userData == null)
                return false;

            userData.active = false;

            if(np != null)
            {
                return update_user_reference (userData, np, false);
            }
            else
            {
                return update_user_reference (userData, false);
            }
        }

        public void SetupServer()
        {
            _networkPlayer = new NetworkPlayer();
            _gameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
            _testServer = _gameObject.AddComponent<Server>();
            _carObject = _gameObject.AddComponent<CarBehaviour>();
            Network = new Mock<INetwork>();
            NetworkView = new Mock<INetworkView>();
            _testServer.Game = new Game();
            _testServer.Network = Network.Object;
            _testServer.StartServer();
            _testServer.NetworkView = NetworkView.Object;
            _carObject.NetworkView = NetworkView.Object;

            var cars = new List<Car>();
            for (var i = 0; i < GameData.CARS_AMOUNT; i++)
            {
                var c = new Car(_carObject);
                cars.Add(c);
            }
            MainScript.Cars = cars;
        }

        // HANDLER /////////////////////////
        // GAMEMASTER /////////////////////////
        public static void gamemaster_add_warning_handler(string dataObject, NetworkPlayer np)
        {
            PurpleDebug.Log("Gamemaster add warning received: #" + np.ToString(), 1);
            _PMGamemaster.Warning accountWarning = PurpleSerializer.StringToObjectConverter<_PMGamemaster.Warning> (dataObject);
            string password_or_token = string.Empty;

            PurpleNetworkUser playerReference = get_network_player_reference(np);
            if (playerReference.UserType != UserTypes.User)
            {
                if(!string.IsNullOrEmpty(accountWarning.gmToken))
                    password_or_token = accountWarning.gmToken;
                if(!string.IsNullOrEmpty(accountWarning.gmPassword))
                    password_or_token = accountWarning.gmPassword;

                accountWarning.validate = AccountHelper.AddWarning (accountWarning.gmUsername, password_or_token,
                    accountWarning.warningUser, accountWarning.warningComment,
                    accountWarning.warningLevel);

                AccountHelper.AddLog (get_network_player_reference (np).UserName,
                    "gamemaster_add_warning_handler " + accountWarning.gmUsername);
                PurpleNetwork.ToPlayer (np, "server_add_warning_result", accountWarning);
            }
        }

        public static void client_register_handler(string dataObject, NetworkPlayer np)
        {
            PurpleDebug.Log("Registration received: #" + np.ToString());
            _PMClient.CreateAccount accountData = PurpleSerializer.StringToObjectConverter<_PMClient.CreateAccount> (dataObject);
            Entities.Database.PurpleAccount purpleAccount = new Entities.Database.PurpleAccount ();

            purpleAccount.birthday		= accountData.ClientBirthday;
            purpleAccount.country_code	= accountData.ClientCountry;
            purpleAccount.email 		= accountData.ClientEmail;
            purpleAccount.first_name 	= accountData.ClientFirstName;
            purpleAccount.gender 		= accountData.ClientGender;
            purpleAccount.language_code = accountData.ClientLanguage;
            purpleAccount.last_name 	= accountData.ClientLastName;
            purpleAccount.username 		= accountData.ClientName;

            // TODO: test
            accountData.validate = AccountHelper.Register (purpleAccount, accountData.ClientPassword);
            accountData.error = AccountHelper.GetErrorList();

            AccountHelper.AddLog(get_network_player_reference(np).UserName,
                                 "client_register_handler " + accountData.ClientName + " - " + accountData.validate.ToString());
            PurpleNetwork.ToPlayer (np, "server_register_result", accountData);
        }