package com.jamesquinley.DelegationServices;

import com.jamesquinley.Asecure.electronicMailHandler;
import com.jamesquinley.Asecure.secureCalls;
import com.mongodb.BasicDBObject;
import com.mongodb.ConnectionString;
import com.mongodb.MongoClientSettings;
import com.mongodb.MongoCommandException;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

import java.util.Random;
import java.util.UUID;

import static com.jamesquinley.Asecure.secureCalls.accountMigrationComplete;
import static com.mongodb.client.model.Filters.eq;
import static java.util.concurrent.TimeUnit.SECONDS;

public class delegationServices {
    static ConnectionString scReadconnectionString;
    static MongoClientSettings scReadsettings;
    static MongoClient dClient;
    static MongoDatabase dClientDatabase;
    static MongoCollection<Document> dCollection;
    static MongoDatabase RGFilterDB;
    static MongoCollection<Document> RGFilter;
    public static void connectionInit (Boolean beta)
   {
       if (beta == true)
       {
           scReadconnectionString = new ConnectionString("mongodb+srv://serverClientBeta:Unz6c3I0wjrUVBIf@delegationrequest.qnvfa.mongodb.net/mDelegationRequest?retryWrites=true&w=majority");
     //connects to database that beta clients can use.
           System.out.println("This is a beta server build (and will only work on that type)");
           scReadsettings = MongoClientSettings.builder()
                   .applyConnectionString(scReadconnectionString)
                   .applyToSocketSettings(builder ->
                           builder.connectTimeout(5, SECONDS)
                                   .readTimeout(6, SECONDS))
                   .build();
           dClient = MongoClients.create(scReadsettings);
           dClientDatabase = dClient.getDatabase("DelegationRequest");
           dCollection = dClientDatabase.getCollection("accountRequestBeta");
           RGFilterDB = dClient.getDatabase("rgcon");
           RGFilter = RGFilterDB.getCollection("blocked");
       } else
       {
           scReadconnectionString = new ConnectionString("mongodb+srv://serverClient:x2sJ8Qu0VVMifNLX@accountdelegation.n06hb.mongodb.net/DelegationRequest?retryWrites=true&w=majority");
       //connects to database that production clients can use
           System.out.println("This is a production server build (and will only work on that type)");
           scReadsettings = MongoClientSettings.builder()
                   .applyConnectionString(scReadconnectionString)
                   .applyToSocketSettings(builder ->
                           builder.connectTimeout(5, SECONDS)
                                   .readTimeout(6, SECONDS))
                   .build();
           dClient = MongoClients.create(scReadsettings);
           dClientDatabase = dClient.getDatabase("DelegationRequest");
           dCollection = dClientDatabase.getCollection("accountRequest");
           RGFilterDB = dClient.getDatabase("rgcon");
           RGFilter = RGFilterDB.getCollection("blocked");
       }
   }
//TODO get switcher working, NPE currently triggers on post init, move below code block into if statement, or outside of it so it will do the same thing regardless of t/f switch output
    static ConnectionString AccountCon = new ConnectionString("mongodb+srv://DelegationServerClient:UNxldb8abSJkWscG@account.ufgrh.mongodb.net/account?retryWrites=true&w=majority");
    static MongoClientSettings AccountSettings = MongoClientSettings.builder()
            .applyConnectionString(AccountCon)
            .applyToSocketSettings(builder ->
                    builder.connectTimeout(5, SECONDS)
                            .readTimeout(6, SECONDS))
            .build();
    static MongoClient accountGetClient = MongoClients.create(AccountSettings);
    static MongoDatabase accountDatabase = accountGetClient.getDatabase("account");
    static MongoCollection<Document> accountS = accountDatabase.getCollection("UserPass");
    static MongoCollection<Document> FNETDOC = accountDatabase.getCollection("FNet");
    static int RequestR;
    //still need to config
    public static String lastNet = null;
    public static String Macid = null;

    public static void banUserID(String UUID)
    {
        BasicDBObject searchQuery = new BasicDBObject();
        searchQuery.append("UUID", UUID);
        BasicDBObject updateQuery2 = new BasicDBObject();
        updateQuery2.append("$set",
                new BasicDBObject().append("Status",false));
        accountS.updateOne(searchQuery, updateQuery2);
    }

    public static void delegationProcesser() {
        Document Filter;
        int ClientID = 0;
        Document Lrequest = dCollection.find(eq("status", false)).first();
        if ((boolean) Lrequest.get("status") == true)
        {


            System.out.println("This request was completed, ignoring");
        } else {

            try {
                try {
                    ClientID = (int) Lrequest.get("clientid");
                } catch (Exception exrp) {
                    delegationTimer.DeleteTargetRequest(ClientID);
                }
                try {
                    Macid = (String)  Lrequest.get("net");

                } catch (Exception exrp) {
                    System.out.println("Failed To Get MacAdr");
                    delegationTimer.DeleteTargetRequest(ClientID);
                }

                String RG = (String) Lrequest.get("rg");
               Filter = RGFilter.find(eq("rgkey", "UAROCKS")).first();
                String blockedRG = (String) Filter.get("rgflag");
                if ((Boolean)Filter.get("serviceState") == false)
                {
                    if ((Boolean)Filter.get("serviceTermination") == true)
                    {
                        BasicDBObject searchQuery = new BasicDBObject();
                        searchQuery.append("rid", Lrequest.get("rid"));

                        BasicDBObject updateQuery = new BasicDBObject();
                        BasicDBObject updateQuery1 = new BasicDBObject();
                        BasicDBObject updateQuery2 = new BasicDBObject();
                        updateQuery.append("$set",
                                new BasicDBObject().append("type", 60));
                        updateQuery2.append("$set",
                                new BasicDBObject().append("dn",Filter.get("serviceTerminationNotes")));
                        updateQuery1.append("$set",
                                new BasicDBObject().append("status", true));
                        dCollection.updateOne(searchQuery, updateQuery);
                        dCollection.updateOne(searchQuery, updateQuery2);
                        dCollection.updateOne(searchQuery, updateQuery1);
                        delegationTimer.DeleteTargetRequest(ClientID);
                    } else
                    {
                        BasicDBObject searchQuery = new BasicDBObject();
                        searchQuery.append("rid", Lrequest.get("rid"));

                        BasicDBObject updateQuery = new BasicDBObject();
                        BasicDBObject updateQuery1 = new BasicDBObject();
                        BasicDBObject updateQuery2 = new BasicDBObject();
                        updateQuery.append("$set",
                                new BasicDBObject().append("type", 52));
                        updateQuery2.append("$set",
                                new BasicDBObject().append("dn",Filter.get("deniedmsg")));
                        updateQuery1.append("$set",
                                new BasicDBObject().append("status", true));
                        dCollection.updateOne(searchQuery, updateQuery);
                        dCollection.updateOne(searchQuery, updateQuery2);
                        dCollection.updateOne(searchQuery, updateQuery1);
                        delegationTimer.DeleteTargetRequest(ClientID);
                    }

                } else {
                    if (blockedRG.contains(RG)) {
                        BasicDBObject searchQuery = new BasicDBObject();
                        searchQuery.append("rid", Lrequest.get("rid"));

                        BasicDBObject updateQuery = new BasicDBObject();
                        BasicDBObject updateQuery1 = new BasicDBObject();
                        updateQuery.append("$set",
                                new BasicDBObject().append("type", 19));
                        updateQuery1.append("$set",
                                new BasicDBObject().append("status", true));
                        dCollection.updateOne(searchQuery, updateQuery);
                        dCollection.updateOne(searchQuery, updateQuery1);
                        delegationTimer.DeleteTargetRequest(ClientID);
                    } else {
                        System.out.println("User On Allowed Region");
                        int requesttype = (int) Lrequest.get("type");
                        System.out.println("Got Type, Getting Doc ID");
                        RequestR = requesttype;


                        System.out.println("Delegation Has Started");
                        if (requesttype == 0 || requesttype == 1 || requesttype == 2 || requesttype == 3 || requesttype == 4 || requesttype == 5 || requesttype == 6 || requesttype == 7 || requesttype == 8 || requesttype == 9 || requesttype == 10 || requesttype == 11 || requesttype == 12 || requesttype == 14 || requesttype == 20 || requesttype == 21 || requesttype == 41 || requesttype == 18 || requesttype == 47 || requesttype == 48 || requesttype == 54 || requesttype == 57) {
                            if (requesttype == 47) {
                                System.out.println("Self Updater download Request");
                                BasicDBObject searchQuery = new BasicDBObject();
                                BasicDBObject SqS = new BasicDBObject();
                                SqS.append("clientid", ClientID);

                                BasicDBObject updateQuery = new BasicDBObject();
                                BasicDBObject updateQuery2 = new BasicDBObject();
                                BasicDBObject updateQuery3 = new BasicDBObject();
                                BasicDBObject updateQuery4 = new BasicDBObject();
                                BasicDBObject updateQuery6 = new BasicDBObject();
                                try {

                                    Document LCP = RGFilter.find(eq("rgkey", "UAROCKS")).first();
                                    String UPDT = (String) LCP.get("UURI");
                                    String config = (String) LCP.get("config");
                                    System.out.println("ThisIsConfig " + config);
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 42));
                                    updateQuery2.append("$set",
                                            new BasicDBObject().append("uri", UPDT));
                                    updateQuery3.append("$set",
                                            new BasicDBObject().append("winconfig", config));
                                    updateQuery6.append("$set",
                                            new BasicDBObject().append("status", true));
                                } catch (Exception ex) {
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 43));
                                    updateQuery2.append("$set",
                                            new BasicDBObject().append("uri", "F"));
                                    updateQuery6.append("$set",
                                            new BasicDBObject().append("status", true));
                                }
                                dCollection.updateOne(SqS, updateQuery);
                                dCollection.updateOne(SqS, updateQuery2);
                                dCollection.updateOne(SqS, updateQuery3);
                                dCollection.updateOne(SqS, updateQuery6);
                                System.out.println("Finished Updater Request");
                                delegationTimer.DeleteTargetRequest(ClientID);

                            }

                            if (requesttype == 41) {
                                System.out.println("Internal Launcher Download Request");
                                BasicDBObject searchQuery = new BasicDBObject();
                                BasicDBObject SqS = new BasicDBObject();
                                SqS.append("clientid", ClientID);

                                BasicDBObject updateQuery = new BasicDBObject();
                                BasicDBObject updateQuery2 = new BasicDBObject();
                                BasicDBObject updateQuery3 = new BasicDBObject();
                                BasicDBObject updateQuery4 = new BasicDBObject();
                                BasicDBObject updateQuery6 = new BasicDBObject();
                                try {
                                    Document LCP = RGFilter.find(eq("rgkey", "UAROCKS")).first();
                                    String UPDT = (String) LCP.get("URI");
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 42));
                                    updateQuery2.append("$set",
                                            new BasicDBObject().append("uri", UPDT));
                                    updateQuery6.append("$set",
                                            new BasicDBObject().append("status", true));
                                } catch (Exception ex) {
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 43));
                                    updateQuery2.append("$set",
                                            new BasicDBObject().append("uri", "F"));
                                    updateQuery6.append("$set",
                                            new BasicDBObject().append("status", true));
                                }
                                dCollection.updateOne(SqS, updateQuery);
                                dCollection.updateOne(SqS, updateQuery2);
                                dCollection.updateOne(SqS, updateQuery6);
                                System.out.println("Finished Updater Request");
                                delegationTimer.DeleteTargetRequest(ClientID);

                            }
                            if (requesttype == 0) {
                                int CTOKEN = (int) Lrequest.get("Token");
                                System.out.println("Sync Request (Read)");
                                Document accountServer;
                                String Password;
                                int Token;
                                String Fname;
                                String Path;
                                String UserName;
                                String Email;
                                try {
                                    accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                    Token = (int) accountServer.get("Token");
                                    if (accountServer.get("Status").equals(true)) {
                                        if (Token == CTOKEN) {

                                            Token = (int) accountServer.get("Token");
                                            Password = (String) accountServer.get("Password");
                                            Fname = (String) accountServer.get("FName");
                                            Path = (String) accountServer.get("Path");
                                            Email = (String) accountServer.get("Email");
                                            UserName = (String) accountServer.get("User");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);
                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            BasicDBObject updateQuery2 = new BasicDBObject();
                                            BasicDBObject updateQuery3 = new BasicDBObject();
                                            BasicDBObject updateQuery4 = new BasicDBObject();
                                            BasicDBObject updateQuery5 = new BasicDBObject();
                                            BasicDBObject updateQuery6 = new BasicDBObject();
                                            BasicDBObject updateQuery7 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 12));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("Token", Token));
                                            updateQuery2.append("$set",
                                                    new BasicDBObject().append("Fname", Fname));
                                            updateQuery3.append("$set",
                                                    new BasicDBObject().append("Path", Path));
                                            updateQuery4.append("$set",
                                                    new BasicDBObject().append("User", UserName));
                                            updateQuery5.append("$set",
                                                    new BasicDBObject().append("Password", Password));
                                            updateQuery7.append("$set",
                                                    new BasicDBObject().append("Email", Email));
                                            updateQuery6.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            dCollection.updateOne(searchQuery, updateQuery2);
                                            dCollection.updateOne(searchQuery, updateQuery3);
                                            dCollection.updateOne(searchQuery, updateQuery4);
                                            dCollection.updateOne(searchQuery, updateQuery5);
                                            dCollection.updateOne(searchQuery, updateQuery6);
                                            dCollection.updateOne(searchQuery, updateQuery7);
                                            delegationTimer.DeleteTargetRequest(ClientID);
                                            System.out.println("Finished Sync Read Op");
                                        } else {
                                            System.out.println("Sync Failure");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("rid", Lrequest.get("rid"));

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 9));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            delegationTimer.DeleteTargetRequest(ClientID);
                                            //delegationTimer.trigger();
                                        }
                                    } else {
                                        System.out.println("Banned Account");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("clientid", ClientID);

                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 11));
                                        updateQuery1.append("$set",
                                                new BasicDBObject().append("status", true));
                                        dCollection.updateOne(searchQuery, updateQuery);
                                        dCollection.updateOne(searchQuery, updateQuery1);
                                        delegationTimer.DeleteTargetRequest(ClientID);
                                    }
                                } catch (MongoCommandException ERC) {
                                    System.out.println("Malformed Request");
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 7));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    //delegationTimer.trigger();
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                }
                            }
                            //sync write request
                            if (requesttype == 1) {
                                System.out.println("Sync Request (Write)");
                                int CTOKEN = (int) Lrequest.get("Token");
                                System.out.println("Got Token.");
                                Document accountServer;
                                int Token;
                                String Fname;
                                String Path;
                                String UserName;
                                try {
                                    accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                    Token = (int) accountServer.get("Token");
                                    if (accountServer.get("Status").equals(true)) {
                                        System.out.println("Account is OK");
                                        if (Token == CTOKEN) {
                                            System.out.println("Logged In");
                                            Token = (int) Lrequest.get("Token");
                                            Fname = (String) Lrequest.get("FName");
                                            Path = (String) Lrequest.get("Path");
                                            UserName = (String) Lrequest.get("User");
                                            System.out.println("Got info.");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("Token", Token);
                                            BasicDBObject SqS = new BasicDBObject();
                                            SqS.append("clientid", ClientID);

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery3 = new BasicDBObject();
                                            BasicDBObject updateQuery6 = new BasicDBObject();
                                            System.out.println("Made Objects");
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 12));
                                            updateQuery3.append("$set",
                                                    new BasicDBObject().append("Path", Path));
                                            updateQuery6.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(SqS, updateQuery);
                                            dCollection.updateOne(SqS, updateQuery6);
                                            accountS.updateOne(searchQuery, updateQuery3);
                                            System.out.println("Updated Account");
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequest(ClientID);
                                        } else {
                                            System.out.println("Sync Failure");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("rid", (int) Lrequest.get("rid"));

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 9));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequest(ClientID);
                                        }
                                    } else {
                                        System.out.println("Banned Account");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("clientid", ClientID);

                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 11));
                                        updateQuery1.append("$set",
                                                new BasicDBObject().append("status", true));
                                        dCollection.updateOne(searchQuery, updateQuery);
                                        dCollection.updateOne(searchQuery, updateQuery1);
                                        delegationTimer.DeleteTargetRequest(ClientID);
                                    }
                                } catch (MongoCommandException ERC) {
                                    System.out.println("Malformed Request");
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 7));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    //delegationTimer.trigger();
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                }
                            }
                            if (requesttype == 2) {
                                System.out.println("Login Request (USR&PASS)");
                                 String username = (String) Lrequest.get("User");
                                 String password = (String) Lrequest.get("Password");
                                Document accountServer;
                                String Password;
                                int Token;
                                String Fname;
                                String Path;
                                String UserName;
                                String Email;
                                String keychainUUID;

                                Boolean accountKeyStatus = false;
                                try {
                                    accountServer = accountS.find(eq("User", username)).first();
                                    Password = (String) accountServer.get("Password");
                                    Email = (String) accountServer.get("Email");
                                    if (accountServer.get("Status").equals(true)) {
                                        if (accountServer.get("Version").equals("1")) {
                                          try {
                                             accountKeyStatus = accountServer.getBoolean("keyStatus");
                                          } catch (Exception NPE)
                                          {
                                              System.out.println("Assuming False Due To Variable Not Existing For User.");
                                              accountKeyStatus = false;
                                          }
                                          if (accountKeyStatus == false ) {
                                            System.out.println(accountKeyStatus);
                                            String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
                                            StringBuilder sb = new StringBuilder();
                                            Random random = new Random();
                                            int length = 15;
                                            for (int i = 0; i < length; i++) {
                                                int index = random.nextInt(alphabet.length());
                                                char randomChar = alphabet.charAt(index);
                                                sb.append(randomChar);
                                            }
                                            String OTK = sb.toString();
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            BasicDBObject keyApplicationIndex = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);
                                            keyApplicationIndex.append("User", username);
                                            secureCalls.oneTimeKeyEmail(((String) accountServer.get("Email")), OTK, username);
                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            BasicDBObject keyApply = new BasicDBObject();
                                            BasicDBObject keyAccountState = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 53));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            keyAccountState.append("$set",
                                                    new BasicDBObject().append("keyStatus", true));
                                            keyApply.append("$set",
                                                    new BasicDBObject().append("tempKey", OTK));
                                            accountS.updateOne(keyApplicationIndex, keyApply);
                                            accountS.updateOne(keyApplicationIndex, keyAccountState);
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            accountKeyStatus = true;
                                        } else {
                                           System.out.println("RS1");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);
                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 53));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequest(ClientID);
                                        }

                                        }
                                        else
                                        {
                                            System.out.println("RSC");
                                            if (Password.equals(password)) {
                                                System.out.println("R3c");
                                                Token = (int) accountServer.get("Token");
                                                Fname = (String) accountServer.get("FName");
                                                Path = (String) accountServer.get("Path");
                                                Email = (String) accountServer.get("Email");
                                                UserName = (String) accountServer.get("User");
                                                lastNet = (String) accountServer.get("lastNet");
                                                keychainUUID = (String) accountServer.get("UUID");
                                                localNet.macRead(Macid, lastNet, Email, UserName, Token);
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("clientid", ClientID);
                                                BasicDBObject updateQuery = new BasicDBObject();
                                                BasicDBObject updateQuery1 = new BasicDBObject();
                                                BasicDBObject updateQuery2 = new BasicDBObject();
                                                BasicDBObject updateQuery3 = new BasicDBObject();
                                                BasicDBObject updateQuery4 = new BasicDBObject();
                                                BasicDBObject updateQuery5 = new BasicDBObject();
                                                BasicDBObject updateQuery6 = new BasicDBObject();
                                                BasicDBObject updateQuery7 = new BasicDBObject();
                                                BasicDBObject updateQuery8 = new BasicDBObject();
                                                updateQuery.append("$set",
                                                        new BasicDBObject().append("type", 8));
                                                updateQuery1.append("$set",
                                                        new BasicDBObject().append("Token", Token));
                                                updateQuery2.append("$set",
                                                        new BasicDBObject().append("Fname", Fname));
                                                updateQuery3.append("$set",
                                                        new BasicDBObject().append("Path", Path));
                                                updateQuery4.append("$set",
                                                        new BasicDBObject().append("User", UserName));
                                                updateQuery5.append("$set",
                                                        new BasicDBObject().append("Password", Password));
                                                updateQuery7.append("$set",
                                                        new BasicDBObject().append("Email", Email));
                                                updateQuery6.append("$set",
                                                        new BasicDBObject().append("status", true));
                                                updateQuery8.append("$set",
                                                        new BasicDBObject().append("keychainUUID", keychainUUID));
                                                dCollection.updateOne(searchQuery, updateQuery);
                                                dCollection.updateOne(searchQuery, updateQuery1);
                                                dCollection.updateOne(searchQuery, updateQuery2);
                                                dCollection.updateOne(searchQuery, updateQuery3);
                                                dCollection.updateOne(searchQuery, updateQuery4);
                                                dCollection.updateOne(searchQuery, updateQuery5);
                                                dCollection.updateOne(searchQuery, updateQuery6);
                                                dCollection.updateOne(searchQuery, updateQuery7);
                                                dCollection.updateOne(searchQuery, updateQuery8);
                                                //delegationTimer.trigger();
                                                delegationTimer.DeleteTargetRequest(ClientID);
                                            } else {
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("clientid", ClientID);

                                                BasicDBObject updateQuery = new BasicDBObject();
                                                BasicDBObject updateQuery1 = new BasicDBObject();
                                                updateQuery.append("$set",
                                                        new BasicDBObject().append("type", 9));
                                                updateQuery1.append("$set",
                                                        new BasicDBObject().append("status", true));
                                                dCollection.updateOne(searchQuery, updateQuery);
                                                dCollection.updateOne(searchQuery, updateQuery1);
                                                //delegationTimer.trigger();
                                                delegationTimer.DeleteTargetRequest(ClientID);
                                            }
                                        }
                                    } else {
                                        System.out.println("Banned Account");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("clientid", ClientID);

                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 11));
                                        updateQuery1.append("$set",
                                                new BasicDBObject().append("status", true));
                                        dCollection.updateOne(searchQuery, updateQuery);
                                        dCollection.updateOne(searchQuery, updateQuery1);
                                        delegationTimer.DeleteTargetRequest(ClientID);
                                    }
                                } catch (Exception ERC) {
                                   System.out.println("Something Went Wrong: " + ERC.getLocalizedMessage());
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 7));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    //delegationTimer.trigger();
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                }

                            }
                            if (requesttype == 54) {
                                System.out.println("Verifying OTK");
                                String userKey = (String) Lrequest.get("otk");
                                String userName = (String) Lrequest.get("recoverUser");
                                String serverUserName;
                                  userKey = userKey.toUpperCase();
                                  System.out.println(userKey);
                                Document accountServer;
                                try {
                                    accountServer = accountS.find(eq("tempKey", userKey)).first();
                                    serverUserName = (String) accountServer.get("User");
                                    if (accountServer.get("Status").equals(true))
                                    {
                                        if (userName.equalsIgnoreCase(serverUserName))
                                        {
                                    System.out.println("This key is correct.");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type",55));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequest(ClientID);

                                        }
                                        else
                                        {
                                            System.out.println("This key is incorrect");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type",56));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequest(ClientID);
                                        }
                                    }
                                } catch (Exception ERC) {
                                    System.out.println("This key is incorrect." + ERC);
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type",56));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                }

                            }
                            if (requesttype == 57)
                            {
                                System.out.println("Verifying email with account tied to OTK");
                              try {
                                  String userKey = (String) Lrequest.get("otk");
                                  String requestedPassword = (String) Lrequest.get("paw");
                                  String email = (String) Lrequest.get("email");
                                  String serverEmail;
                                  userKey = userKey.toUpperCase();
                                  Document accountServer;
                                  accountServer = accountS.find(eq("tempKey", userKey)).first();
                                  serverEmail = (String) accountServer.get("Email");
                                  String userName = (String) accountServer.get("User");
                                  String serverKey = (String) accountServer.get("tempKey");
                                  System.out.println("Requested Password Hash: " + requestedPassword);
                                  System.out.println("Email Stored On Server: " + serverEmail);
                                  System.out.println("Email from client: " + email);
                                  System.out.println("otk stored on server: " + serverKey);
                                  System.out.println("otk from client: " + userKey);
                                  if (email.equalsIgnoreCase(serverEmail) && userKey.equals(serverKey)) {
                                      System.out.println("All Matching, lets go!");
                                      BasicDBObject searchQuery = new BasicDBObject();
                                      BasicDBObject searchQuery1 = new BasicDBObject();
                                      searchQuery.append("Email", serverEmail);
                                      searchQuery1.append("clientid", ClientID);
                                    System.out.println("Send indexes are ready.");
                                      BasicDBObject updateQuery = new BasicDBObject();
                                      BasicDBObject updateQuery1 = new BasicDBObject();
                                      BasicDBObject updateQuery2 = new BasicDBObject();
                                      BasicDBObject updateQuery3 = new BasicDBObject();
                                      System.out.println("Objects are ready.");
                                      updateQuery.append("$set",
                                              new BasicDBObject().append("Password",requestedPassword));
                                      updateQuery1.append("$unset",
                                              new BasicDBObject().append("tempKey", ""));
                                      updateQuery2.append("$set",
                                              new BasicDBObject().append("Version","2"));
                                      updateQuery3.append("$set",
                                              new BasicDBObject().append("keyStatus",false));
                                      System.out.println("Objects set");
                                      accountS.updateOne(searchQuery, updateQuery);
                                      accountS.updateOne(searchQuery, updateQuery1);
                                      accountS.updateOne(searchQuery, updateQuery2);
                                      accountS.updateOne(searchQuery, updateQuery3);
                                      System.out.println("Objects send");
                                      BasicDBObject closeRequestType = new BasicDBObject();
                                      BasicDBObject finalizeRequest = new BasicDBObject();
                                      System.out.println("Objects close init");
                                      closeRequestType.append("$set",
                                              new BasicDBObject().append("type",58));
                                      finalizeRequest.append("$set",
                                              new BasicDBObject().append("status", true));
                                      dCollection.updateOne(searchQuery1, closeRequestType);
                                      dCollection.updateOne(searchQuery1, finalizeRequest);
                                      System.out.println("Objects close send");
                                      delegationTimer.DeleteTargetRequest(ClientID);
                                      System.out.println("request finished correctly");
                                      accountMigrationComplete(serverEmail, userName);
                                  }
                                  else
                                  {
                                      System.out.println("request denied");
                                      BasicDBObject searchQuery = new BasicDBObject();
                                      searchQuery.append("clientid", ClientID);

                                      BasicDBObject updateQuery = new BasicDBObject();
                                      BasicDBObject updateQuery1 = new BasicDBObject();
                                      updateQuery.append("$set",
                                              new BasicDBObject().append("type",59));
                                      updateQuery1.append("$set",
                                              new BasicDBObject().append("status", true));
                                      dCollection.updateOne(searchQuery, updateQuery);
                                      dCollection.updateOne(searchQuery, updateQuery1);
                                      delegationTimer.DeleteTargetRequest(ClientID);
                                  }
                              } catch (Exception ex) {
                                  System.out.println("Unable to reset password, making that known." + ex);
                                  BasicDBObject searchQuery = new BasicDBObject();
                                  searchQuery.append("clientid", ClientID);

                                  BasicDBObject updateQuery = new BasicDBObject();
                                  BasicDBObject updateQuery1 = new BasicDBObject();
                                  updateQuery.append("$set",
                                          new BasicDBObject().append("type",59));
                                  updateQuery1.append("$set",
                                          new BasicDBObject().append("status", true));
                                  dCollection.updateOne(searchQuery, updateQuery);
                                  dCollection.updateOne(searchQuery, updateQuery1);
                                  delegationTimer.DeleteTargetRequest(ClientID);
                              }
                              }
                            if (requesttype == 3) {
                                System.out.println("Login Request (TKN)");
                                int CTOKEN = (int) Lrequest.get("Token");
                                // Document TResolve = dCollection.find(eq("type", 3)).first();
                                Document accountServer;
                                int TKN;
                                String Password;
                                String Fname;
                                String Path;
                                String UserName;
                                String Email;
                                String keychainUUID;
                                try {
                                    accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                    TKN = (int) accountServer.get("Token");
                                    if (accountServer.get("Status").equals(true)) {
                                        if (TKN == CTOKEN) {
                                            TKN = (int) accountServer.get("Token");
                                            Password = (String) accountServer.get("Password");
                                            Fname = (String) accountServer.get("FName");
                                            Path = (String) accountServer.get("Path");
                                            Email = (String) accountServer.get("Email");
                                            UserName = (String) accountServer.get("User");
                                            lastNet = (String) accountServer.get("lastNet");
                                            keychainUUID = (String) accountServer.get("UUID");
                                            localNet.macRead(Macid, lastNet, Email, UserName, TKN);
                                            // com.jamesquinley.Asecure.emailVerify.SendEmailThroughGmail(Email, UserName);
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery2 = new BasicDBObject();
                                            BasicDBObject updateQuery3 = new BasicDBObject();
                                            BasicDBObject updateQuery4 = new BasicDBObject();
                                            BasicDBObject updateQuery5 = new BasicDBObject();
                                            BasicDBObject updateQuery6 = new BasicDBObject();
                                            BasicDBObject updateQuery7 = new BasicDBObject();
                                            BasicDBObject updateQuery8 = new BasicDBObject();
                                            BasicDBObject updateQuery9 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 8));
                                            updateQuery2.append("$set",
                                                    new BasicDBObject().append("Fname", Fname));
                                            updateQuery3.append("$set",
                                                    new BasicDBObject().append("Path", Path));
                                            updateQuery4.append("$set",
                                                    new BasicDBObject().append("User", UserName));
                                            updateQuery5.append("$set",
                                                    new BasicDBObject().append("Password", Password));
                                            updateQuery7.append("$set",
                                                    new BasicDBObject().append("Email", Email));
                                            updateQuery8.append("$set",
                                                    new BasicDBObject().append("Token", TKN));
                                            updateQuery9.append("$set",
                                                    new BasicDBObject().append("keychainUUID", keychainUUID));
                                            updateQuery6.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            System.out.println("Sending Info To Forwarding Server");
                                            dCollection.updateOne(searchQuery, updateQuery8);
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery2);
                                            dCollection.updateOne(searchQuery, updateQuery3);
                                            dCollection.updateOne(searchQuery, updateQuery4);
                                            dCollection.updateOne(searchQuery, updateQuery5);
                                            dCollection.updateOne(searchQuery, updateQuery8);
                                            dCollection.updateOne(searchQuery, updateQuery7);
                                            dCollection.updateOne(searchQuery, updateQuery9);
                                            dCollection.updateOne(searchQuery, updateQuery6);
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequest(ClientID);
                                        } else {
                                            System.out.println("Login Failure");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 9));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequest(ClientID);

                                        }
                                    } else {
                                        System.out.println("Banned Account");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("clientid", ClientID);

                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 11));
                                        updateQuery1.append("$set",
                                                new BasicDBObject().append("status", true));
                                        dCollection.updateOne(searchQuery, updateQuery);
                                        dCollection.updateOne(searchQuery, updateQuery1);
                                        delegationTimer.DeleteTargetRequest(ClientID);

                                    }
                                } catch (MongoCommandException ERC) {
                                    System.out.println("Malformed Request");
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 7));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                    //delegationTimer.trigger();
                                }
                            }
                            if (requesttype == 18) {
                                //TOKEN LOGIN FOR GAME, DOES NOT SEND EMAIL, LAUNCHER WILL NOT USE THIS.
                                System.out.println("Game Login");
                                int CTOKEN = (int) Lrequest.get("Token");
                                Document accountServer;
                                int TKN;
                                String Password;
                                String Fname;
                                String Path;
                                String UserName;
                                String Email;
                                String Uid;
                                System.out.println("VarInit");
                                try {
                                    accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                    System.out.println("PollServer");
                                    TKN = (int) accountServer.get("Token");
                                    System.out.println("TokenPulled");
                                    if (accountServer.get("Status").equals(true)) {
                                        if (TKN == CTOKEN) {
                                            System.out.println("TokenGood");
                                            TKN = (int) accountServer.get("Token");
                                            Password = (String) accountServer.get("Password");
                                            Fname = (String) accountServer.get("FName");
                                            Path = (String) accountServer.get("Path");
                                            Email = (String) accountServer.get("Email");
                                            //  Uid = (String) accountServer.get("Uid");
                                            UserName = (String) accountServer.get("User");
                                            System.out.println("GotAccount");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);
                                            Filter = RGFilter.find(eq("rgkey", "UAROCKS")).first();
                                            String apiV = (String) Filter.get("gameAPI");
                                            String MOTD = (String) Filter.get("motd");
                                            System.out.println("ApiGrabbed");


                                            System.out.println("initBasicDBObject");
                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery2 = new BasicDBObject();
                                            BasicDBObject updateQuery3 = new BasicDBObject();
                                            BasicDBObject updateQuery4 = new BasicDBObject();
                                            BasicDBObject updateQuery5 = new BasicDBObject();
                                            BasicDBObject updateQuery6 = new BasicDBObject();
                                            BasicDBObject updateQuery7 = new BasicDBObject();
                                            BasicDBObject updateQuery8 = new BasicDBObject();
                                            BasicDBObject updateQuery9 = new BasicDBObject();
                                            BasicDBObject updateQuery10 = new BasicDBObject();
                                            //       BasicDBObject updateQuery11 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 8));
                                            updateQuery2.append("$set",
                                                    new BasicDBObject().append("Fname", Fname));
                                            updateQuery3.append("$set",
                                                    new BasicDBObject().append("Path", Path));
                                            updateQuery4.append("$set",
                                                    new BasicDBObject().append("User", UserName));
                                            updateQuery5.append("$set",
                                                    new BasicDBObject().append("Password", Password));
                                            updateQuery7.append("$set",
                                                    new BasicDBObject().append("Email", Email));
                                            updateQuery6.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            updateQuery8.append("$set",
                                                    new BasicDBObject().append("Token", TKN));
                                            updateQuery9.append("$set",
                                                    new BasicDBObject().append("api", apiV));
                                            updateQuery10.append("$set",
                                                    new BasicDBObject().append("motd", MOTD));
                                            System.out.println("Sending Info To Forwarding Server");
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery10);
                                            dCollection.updateOne(searchQuery, updateQuery2);
                                            dCollection.updateOne(searchQuery, updateQuery3);
                                            dCollection.updateOne(searchQuery, updateQuery4);
                                            dCollection.updateOne(searchQuery, updateQuery5);
                                            dCollection.updateOne(searchQuery, updateQuery8);
                                            dCollection.updateOne(searchQuery, updateQuery7);
                                            dCollection.updateOne(searchQuery, updateQuery9);
                                            dCollection.updateOne(searchQuery, updateQuery6);
                                            //delegationTimer.trigger();
                                            System.out.println("Pushed");
                                            delegationTimer.DeleteTargetRequest(ClientID);
                                        } else {
                                            System.out.println("Login Failure");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("clientid", ClientID);

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 9));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequest(ClientID);

                                        }
                                    } else {
                                        System.out.println("Banned Account");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("clientid", ClientID);

                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 11));
                                        updateQuery1.append("$set",
                                                new BasicDBObject().append("status", true));
                                        dCollection.updateOne(searchQuery, updateQuery);
                                        dCollection.updateOne(searchQuery, updateQuery1);
                                        delegationTimer.DeleteTargetRequest(ClientID);
                                    }
                                } catch (MongoCommandException ERC) {
                                    System.out.println("Mongodb Error " + ERC);
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 7));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                    //delegationTimer.trigger();
                                }
                            }
                            if (requesttype == 10) {
                                System.out.println("Account Creation Request");
                                Document DServer = dCollection.find(eq("clientid", ClientID)).first();
                                String User = (String) DServer.get("User");
                                String Password = (String) DServer.get("Password");
                                String Email = (String) DServer.get("Email");
                                String FName = (String) DServer.get("FName");
                                int min = 100000000;
                                int max = 999999999;
                                double tokenGEN = Math.random() * (max - min + 1) + min;
                                int tokenSTGEN = (int) tokenGEN;
                                //Above makes token, it will be remade if it already exists
                                String source = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
                                StringBuilder sb = new StringBuilder();
                                Random random = new Random();
                                int length = 40;
                                for (int i = 0; i < length; i++) {
                                    int index = random.nextInt(source.length());
                                    char randomChar = source.charAt(index);
                                    sb.append(randomChar);
                                }
                                String UUID = sb.toString();
                                //Above makes UUID, will be remade if it already exists.

                                try {
                                    Document DupeUser = accountS.find(eq("User", User)).first();
                                    String DUPE = (String) DupeUser.get("User");
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 6));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                } catch (Exception exr) {
                                    System.out.println("Username Is Open");
                                    try {
                                        Document DupeToken = accountS.find(eq("Token", tokenSTGEN)).first();
                                        int DupeToke1n = (int) DupeToken.get("Token");
                                        System.out.println("Got Token from request");
                                        Boolean TokenOpen = false;
                                        while (TokenOpen == false) {
                                            tokenGEN = Math.random() * (max - min + 1) + min;
                                            tokenSTGEN = (int) tokenGEN;
                                            try {
                                                DupeToken = accountS.find(eq("Token", tokenSTGEN)).first();
                                                DupeToke1n = (int) DupeToken.get("Token");
                                                System.out.println("Token Is Reserved, Try Again.");
                                                tokenGEN = Math.random() * (max - min + 1) + min;
                                                tokenSTGEN = (int) tokenGEN;
                                            } catch (Exception exDr) {
                                                TokenOpen = true;
                                                System.out.println("Token Free (While EXP)");
                                            }
                                        }
                                    } catch (Exception token) {
                                        System.out.println("Working on UUID");
                                        try {
                                            Document DupeUUID = accountS.find(eq("UUID", UUID)).first();
                                            String DupeUUIDS = (String) DupeUUID.get("UUID");
                                            System.out.println("Got Gen UUID");
                                            Boolean UUIDOPEN = false;
                                            while (UUIDOPEN == false) {
                                                length = 40;
                                                 sb = new StringBuilder();
                                                for (int i = 0; i < length; i++) {
                                                    int index = random.nextInt(source.length());
                                                    char randomChar = source.charAt(index);
                                                    sb.append(randomChar);
                                                }
                                                String UUIDGEN = sb.toString();
                                                try {
                                                    System.out.println("Retry UUID");
                                                    DupeUUID = accountS.find(eq("UUID", UUID)).first();
                                                    DupeUUIDS = (String) DupeUUID.get("UUID");
                                                    System.out.println("UUID Is Reserved, Try Again.");
                                                    length = 40;
                                                    sb = new StringBuilder();
                                                    for (int i = 0; i < length; i++) {
                                                        int index = random.nextInt(source.length());
                                                        char randomChar = source.charAt(index);
                                                        sb.append(randomChar);
                                                    }
                                                    UUIDGEN = sb.toString();
                                                   UUID = UUIDGEN;
                                                } catch (Exception exDr) {
                                                    UUIDOPEN = true;
                                                    System.out.println("UUID Free (While EXP)" + exDr);
                                                }
                                            }
                                        } catch (NullPointerException uuid) {
                                            System.out.println("UUID Free");
                                        }
                                        System.out.println("Token Free");
                                        System.out.println("Token & UUID Free (Main)");
                                        System.out.println("Creating.");
                                        Document createForm = new Document();
                                        Document FnetInit = new Document();
                                        createForm.append("User", User);
                                        createForm.append("Password", Password);
                                        createForm.append("Status", true);
                                        createForm.append("Flagged", false);
                                        createForm.append("Email", Email);
                                        createForm.append("FName", FName);
                                        createForm.append("Entitlements", "NA");
                                        createForm.append("Path", "C:\\ObsidianCoreStudios\\Application\\");
                                        createForm.append("Freinds", " ");
                                        createForm.append("Token", tokenSTGEN);
                                        createForm.append("UUID", UUID);
                                        createForm.append("Control", 1);
                                        createForm.append("Upgrade", 0);
                                        createForm.append("Version","2");
                                        createForm.append("keyStatus", false);
                                        //createForm.append("Uid",uid);
                                        createForm.append("lastNet", Macid);
                                        accountS.insertOne(createForm);
                                        FnetInit.append("User", User);
                                        FnetInit.append("Status", true);
                                        FnetInit.append("Friends", " ");
                                        FnetInit.append("Token", tokenSTGEN);
                                        FnetInit.append("UUID", UUID);
                                        FnetInit.append("Control", 1);
                                        FNETDOC.insertOne(FnetInit);
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("clientid", ClientID);
                                        electronicMailHandler.Onboarding(Email, User,UUID);
                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 4));
                                        updateQuery1.append("$set",
                                                new BasicDBObject().append("status", true));
                                        dCollection.updateOne(searchQuery, updateQuery);
                                        dCollection.updateOne(searchQuery, updateQuery1);
                                        System.out.println("Update Request With Finished Status");
                                        delegationTimer.DeleteTargetRequest(ClientID);
                                        }

                                }
                            }
                            if (requesttype == 20)
                            //TODO rewrite to just need username, password will be set by system later
                            {
                                delegationTimer.DeleteTargetRequest(ClientID);
                                System.out.println("Shadow Account Creation Request");
                                Document DServer = dCollection.find(eq("clientid", ClientID)).first();
                                String User = (String) DServer.get("User");
                                String Password = (String) DServer.get("Password");
                                //      String Email = (String) DServer.get("Email");
                                String FName = User;
                                int min = 100000000;
                                int max = 999999999;
                                double tokenGEN = Math.random() * (max - min + 1) + min;
                                int tokenSTGEN = (int) tokenGEN;

//verify open cert
                                try {
                                    Document DupeUser = accountS.find(eq("User", User)).first();
                                    String DUPE = (String) DupeUser.get("User");
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 6));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    System.out.println("User Exists");
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                } catch (Exception exr) {
                                    System.out.println("Username Is Open");
                                    try {
                                        Document DupeToken = accountS.find(eq("Token", tokenSTGEN)).first();
                                        int DupeToke1n = (int) DupeToken.get("Token");

                                        Boolean TokenOpen = false;
                                        while (TokenOpen == false) {
                                            tokenGEN = Math.random() * (max - min + 1) + min;
                                            tokenSTGEN = (int) tokenGEN;
                                            try {
                                                DupeToken = accountS.find(eq("Token", tokenSTGEN)).first();
                                                DupeToke1n = (int) DupeToken.get("Token");
                                                System.out.println("Token Is Reserved, Try Again.");
                                                tokenGEN = Math.random() * (max - min + 1) + min;
                                                tokenSTGEN = (int) tokenGEN;
                                            } catch (Exception exDr) {
                                                TokenOpen = true;
                                                System.out.println("Token Free (While EXP)");
                                            }
                                        }
                                    } catch (Exception exrs) {
                                        System.out.println("Token Free (Main)");
                                        System.out.println("Creating.");
                                        Document createForm = new Document();
                                        Document FnetInit = new Document();
                                        createForm.append("User", User);
                                        createForm.append("Status", true);
                                        createForm.append("limited", true);
                                        createForm.append("Flagged", false);
                                        createForm.append("Password", Password);
                                        createForm.append("FName", FName);
                                        createForm.append("Entitlements", "NA");
                                        createForm.append("Path", "C:\\ObsidianCoreStudios\\Launcher\\AOTSK\\");
                                        createForm.append("Token", tokenSTGEN);
                                        createForm.append("Control", 1);
                                        accountS.insertOne(createForm);
                                        //create Fnet user
                                        FnetInit.append("User", User);
                                        FnetInit.append("Status", true);
                                        FnetInit.append("Freinds", " ");
                                        FnetInit.append("Token", tokenSTGEN);
                                        FnetInit.append("Control", 1);
                                        FNETDOC.insertOne(FnetInit);

                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("clientid", ClientID);
                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 4));
                                        updateQuery1.append("$set",
                                                new BasicDBObject().append("status", true));
                                        dCollection.updateOne(searchQuery, updateQuery);
                                        dCollection.updateOne(searchQuery, updateQuery1);
                                        System.out.println("Update Request With Finished Status");
                                        delegationTimer.DeleteTargetRequest(ClientID);

                                    }

                                }
                            }
                            if (requesttype == 21) {
                                //Friends Network Login Goes Here, Fun.
                            }
                            if (requesttype == 48) {

                                System.out.println("Launcher Startup Request");
                                String lV = (String) Lrequest.get("version");
                                String platKey = (String) Lrequest.get("key");
                                System.out.println("GrabbedInfo");
                                try {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);
                                    Filter = RGFilter.find(eq("rgkey", "UAROCKS")).first();
                                    String pKey = (String) Filter.get("platformKey");
                                    String version = (String) Filter.get("platformVersion");
                                    String platformUpdateNotes = (String) Filter.get("platformUpdateNotes");
                                    String dr = (String) Filter.get("deniedmsg");
                                    String nw = (String) Filter.get("lnews");
                                    System.out.println("ApiGrabbed");


                                    System.out.println("initBasicDBObject");
                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery2 = new BasicDBObject();
                                    BasicDBObject updateQuery3 = new BasicDBObject();
                                    BasicDBObject updateQuery4 = new BasicDBObject();
                                    BasicDBObject updateQuery6 = new BasicDBObject();
                                    BasicDBObject updateQuery7 = new BasicDBObject();
                                    BasicDBObject updateQuery8 = new BasicDBObject();
                                    //       BasicDBObject updateQuery11 = new BasicDBObject();
                                    if (pKey.equals(platKey)) {
                                        if (lV.equals(version)) {
                                            System.out.println("Approved");
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 49));
                                        } else {
                                            System.out.println("UpdateRequred");
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 51));
                                        }
                                    } else {
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 50));
                                        updateQuery7.append("$set",
                                                new BasicDBObject().append("dn", dr));
                                        System.out.println("Denied");
                                    }

                                    updateQuery2.append("$set",
                                            new BasicDBObject().append("uNotes", platformUpdateNotes));
                                    updateQuery3.append("$set",
                                            new BasicDBObject().append("pushV", version));
                                    updateQuery4.append("$set",
                                            new BasicDBObject().append("keyReq", pKey));
                                    updateQuery8.append("$set",
                                            new BasicDBObject().append("news", nw));
                                    updateQuery6.append("$set",
                                            new BasicDBObject().append("status", true));
                                    updateQuery7.append("$set",
                                            new BasicDBObject().append("dn", dr));
                                    System.out.println("Sending Info To Forwarding Server");
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery2);
                                    dCollection.updateOne(searchQuery, updateQuery3);
                                    dCollection.updateOne(searchQuery, updateQuery4);
                                    dCollection.updateOne(searchQuery, updateQuery7);
                                    dCollection.updateOne(searchQuery, updateQuery8);
                                    dCollection.updateOne(searchQuery, updateQuery6);

                                    //delegationTimer.trigger();
                                    System.out.println("Pushed");
                                    delegationTimer.DeleteTargetRequest(ClientID);

                                } catch (MongoCommandException ERC) {
                                    System.out.println("Mongodb Error " + ERC);
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("clientid", ClientID);

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 7));
                                    updateQuery1.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery1);
                                    delegationTimer.DeleteTargetRequest(ClientID);
                                    //delegationTimer.trigger();
                                }
                            }
                            if (requesttype == 14)
                            {
                                //TODO Finish making a secure deletion process.
                                String requestClientUUID = (String) Lrequest.get("UUID");
                                String requestClientToken = (String) Lrequest.get("token");
                                String requestClientMAC = (String) Lrequest.get("mac");
                            }
                        } else {
                            System.out.println("Malformed Request, Non Recoverable (Request Type Not Found)");
                            BasicDBObject searchQuery = new BasicDBObject();
                            searchQuery.append("clientid", ClientID);

                            BasicDBObject updateQuery = new BasicDBObject();
                            BasicDBObject updateQuery1 = new BasicDBObject();
                            updateQuery.append("$set",
                                    new BasicDBObject().append("type", 7));
                            updateQuery1.append("$set",
                                    new BasicDBObject().append("status", true));
                            Lrequest.append("status", true);
                            dCollection.updateOne(searchQuery, updateQuery1);
                            dCollection.updateOne(searchQuery, updateQuery);
                            delegationTimer.DeleteTargetRequest(ClientID);

                        }
                    }
                }
                } catch (Exception Erp) {
                    System.out.println("Malformed Request, Non Recoverable ErrorInfo: " +Erp);
                    BasicDBObject searchQuery = new BasicDBObject();
                    searchQuery.append("clientid", ClientID);

                    BasicDBObject updateQuery = new BasicDBObject();
                    BasicDBObject updateQuery1 = new BasicDBObject();
                    updateQuery.append("$set",
                            new BasicDBObject().append("type", 7));
                    updateQuery1.append("$set",
                            new BasicDBObject().append("status", true));
                    updateQuery1.append("$set",
                            new BasicDBObject().append("pos", "934"));
                    Lrequest.append("status",true);
                    dCollection.updateOne(searchQuery, updateQuery1);
                    dCollection.updateOne(searchQuery, updateQuery);
                    dCollection.updateOne(searchQuery,updateQuery);
                    delegationTimer.DeleteTargetRequest(ClientID);
                }
            }



        //above is finding one request and starting wheels
        //delegationTimer.trigger();
        delegate();
    }
    public static void Purge () {
        BasicDBObject searchQueryT = new BasicDBObject();
        BasicDBObject searchQueryF = new BasicDBObject();
        searchQueryT.append("status", true);
        searchQueryF.append("status", false);
        dCollection.deleteMany(searchQueryT);
        dCollection.deleteMany(searchQueryF);
        System.out.println("Flushed Server");
    }

    public static void TargetDelete (int CID) {
        BasicDBObject searchQuery = new BasicDBObject();
        searchQuery.append("clientid",CID);
        dCollection.deleteMany(searchQuery);
        System.out.println("Flushed a targeted request (CID) from the server");


    }

    public static void TargetDeleteRID (int CID) {
        BasicDBObject searchQuery = new BasicDBObject();
        searchQuery.append("rid",CID);
        dCollection.deleteMany(searchQuery);
        System.out.println("Flushed a targeted request (RID) from the server");


    }        public static void delegate ()
        {
                userAuthetication();
        }
        public static void userAuthetication (){
            try {
                delegationProcesser();
            } catch (Exception exr) {
               delegationTimer.trigger();
            }
        }
    }