package com.jamesquinley.DelegationServices;
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.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDateTime;
import java.util.Random;

import static com.jamesquinley.Asecure.electronicMailHandler.*;
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;
    static Document Lrequest = null;
    public static void connectionInit(Boolean beta) {
        //TODO Send Server Version As Standard.
        if (beta) {
            scReadconnectionString = new ConnectionString("mongodb+srv://betaServer:fi0tZ6yvJjTm16yA@obsidiancorebetaapi.s0mzauh.mongodb.net/?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("accountRequest");
            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://accountserver:x2sJ8Qu0VVMifNLX@192.168.1.5:27017/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 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() {
        Boolean cid = false;
        Boolean mac = false;
        Document Filter;
        Object ClientID = null;
            try {
                try {
                    ClientID = Lrequest.get("_id");
                    cid = true;
                } catch (Exception exrp) {
                    System.out.println("This request has opted out of CID.");
                }
                try {
                    Macid = (String) Lrequest.get("net");
                    mac = true;
                } catch (Exception exrp) {
                    System.out.println("This request has opted out of CID.");
                }

                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.DeleteTargetRequestByID(Lrequest.get("_id"));
                    } 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                    }

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

                        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.DeleteTargetRequestByID(Lrequest.get("_id"));
                    } 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(RG);
                        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 || requesttype == 61 || requesttype == 63 || requesttype == 65 || requesttype == 66 || requesttype == 67 || requesttype == 68 || requesttype == 71 || requesttype == 72 || requesttype == 73 || requesttype == 74 || requesttype == 75 || requesttype ==78 || requesttype == 79 || requesttype == 81
                            ) {
                                if (requesttype == 47) {
                                    System.out.println("Self Updater download Request");
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    BasicDBObject SqS = new BasicDBObject();
                                    SqS.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                }

                                if (requesttype == 41) {
                                    System.out.println("Internal Launcher Download Request");
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    BasicDBObject SqS = new BasicDBObject();
                                    SqS.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));

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

                                                Token = (String) accountServer.get("Token");
                                                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("_id", ClientID);
                                                BasicDBObject updateQuery = new BasicDBObject();
                                                BasicDBObject updateQuery1 = new BasicDBObject();
                                                BasicDBObject updateQuery2 = new BasicDBObject();
                                                BasicDBObject updateQuery3 = new BasicDBObject();
                                                BasicDBObject updateQuery4 = 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));
                                                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, updateQuery6);
                                                dCollection.updateOne(searchQuery, updateQuery7);
                                                delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                //delegationTimer.trigger();
                                            }
                                        } else {
                                            System.out.println("Banned Account");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (MongoCommandException ERC) {
                                        System.out.println("Malformed Request");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    }
                                }
                                //sync write request
                                if (requesttype == 1) {
                                    System.out.println("Sync Request (Write)");
                                    String CTOKEN = (String) Lrequest.get("Token");
                                    Document accountServer;
                                    String Token;
                                    String Fname;
                                    String Path;
                                    String UserName;
                                    try {
                                        accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                        if (!(accountServer == null)) {
                                            Token = (String) accountServer.get("Token");
                                            if (accountServer.get("Status").equals(true)) {
                                                if (Token.equals(CTOKEN)) {
                                                    Token = (String) Lrequest.get("Token");
                                                    Path = (String) Lrequest.get("Path");
                                                    System.out.println("Got info.");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("Token", Token);
                                                    BasicDBObject SqS = new BasicDBObject();
                                                    SqS.append("_id", ClientID);

                                                    BasicDBObject updateQuery = new BasicDBObject();
                                                    BasicDBObject updateQuery3 = new BasicDBObject();
                                                    BasicDBObject updateQuery6 = new BasicDBObject();
                                                    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);
                                                    //delegationTimer.trigger();
                                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                } else {
                                                    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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                }
                                            } else {
                                                System.out.println("Banned Account");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                            }
                                        } else {
                                            System.out.println("Malformed Request");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (MongoCommandException ERC) {
                                        System.out.println("Malformed Request");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    }
                                }
                                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;
                                    String 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("_id", 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("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                }

                                            } else {
                                                System.out.println("RSC");
                                                if (Password.equals(password)) {
                                                    System.out.println("R3c");
                                                    Token = (String) 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");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", 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();
                                                    BasicDBObject updateQuery10 = new BasicDBObject();
                                                    //below if is used for custom greetings, and home messages, for holidays and such. (Also right before update ops)
                                                    BasicDBObject updateQuery9 = new BasicDBObject();
                                                    BasicDBObject updateQuery12 = 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));
                                                    if (Filter.get("customHome").equals(true)) {
                                                        BasicDBObject updateQuery11 = new BasicDBObject();
                                                        updateQuery11.append("$set",
                                                                new BasicDBObject().append("home", Filter.get("valHome")));
                                                        updateQuery12.append("$set",
                                                                new BasicDBObject().append("hs",true));
                                                        dCollection.updateOne(searchQuery, updateQuery11);
                                                        dCollection.updateOne(searchQuery, updateQuery12);
                                                    } else {
                                                        updateQuery12.append("$set",
                                                                new BasicDBObject().append("hs",false));
                                                        dCollection.updateOne(searchQuery, updateQuery12);
                                                    }
                                                  /*
                                                  if (Filter.get("customGreeting").equals(true)) {
                                                        BasicDBObject updateQuery12 = new BasicDBObject();
                                                        updateQuery12.append("$set",
                                                                new BasicDBObject().append("greeting", Filter.get("valGreet")));
                                                        updateQuery10.append("$set",
                                                                new BasicDBObject().append("gs",true));
                                                        dCollection.updateOne(searchQuery, updateQuery12);
                                                        dCollection.updateOne(searchQuery, updateQuery10);
                                                    }else {
                                                        updateQuery10.append("$set",
                                                                new BasicDBObject().append("gs",false));
                                                        dCollection.updateOne(searchQuery, updateQuery10);
                                                    }
                                                    Planned for later, current UI wont allow
                                                   */
                                                    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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                    localNet.macRead(Macid, lastNet, Email, UserName, Token);
                                                } else {
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                }
                                            }
                                        } else {
                                            System.out.println("Banned Account");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (Exception ERC) {
                                        System.out.println("Something Went Wrong: " + ERC.getLocalizedMessage());
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    }

                                }
                                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("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                            } else {
                                                System.out.println("This key is incorrect");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                            }
                                        }
                                    } catch (Exception ERC) {
                                        System.out.println("This key is incorrect." + ERC);
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    }

                                }
                                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");
                                        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("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                            System.out.println("request finished correctly");
                                            accountMigrationComplete(serverEmail, userName);
                                        } else {
                                            System.out.println("request denied");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (Exception ex) {
                                        System.out.println("Unable to reset password, making that known." + ex);
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    }
                                }
                                if (requesttype == 3) {
                                    System.out.println("Login Request (TKN)");
                                    String CTOKEN = (String) Lrequest.get("Token");
                                    // Document TResolve = dCollection.find(eq("type", 3)).first();
                                    Document accountServer;
                                    String TKN;
                                    String Password;
                                    String Fname;
                                    String Path;
                                    String UserName;
                                    String Email;
                                    String keychainUUID;
                                    try {
                                        accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                        if (!(accountServer == null)) {
                                            TKN = (String) accountServer.get("Token");
                                            if (accountServer.get("Status").equals(true)) {
                                                if (TKN.equals(CTOKEN)) {
                                                    TKN = (String) 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");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", ClientID);

                                                    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 updateQuery9 = new BasicDBObject();
                                                    BasicDBObject updateQuery10 = 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));
                                                    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));
                                                    if (Filter.get("customHome").equals(true)) {
                                                        BasicDBObject updateQuery11 = new BasicDBObject();
                                                        updateQuery11.append("$set",
                                                                new BasicDBObject().append("home", Filter.get("valHome")));
                                                        updateQuery10.append("$set",
                                                                new BasicDBObject().append("hs",true));
                                                        dCollection.updateOne(searchQuery, updateQuery11);
                                                        dCollection.updateOne(searchQuery, updateQuery10);
                                                    } else {
                                                        updateQuery10.append("$set",
                                                                new BasicDBObject().append("hs",false));
                                                        dCollection.updateOne(searchQuery, updateQuery10);
                                                    }
                                                    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, updateQuery8);
                                                    dCollection.updateOne(searchQuery, updateQuery7);
                                                    dCollection.updateOne(searchQuery, updateQuery9);
                                                    dCollection.updateOne(searchQuery, updateQuery6);
                                                    //delegationTimer.trigger();
                                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                    localNet.macRead(Macid, lastNet, Email, UserName, TKN);
                                                } else {
                                                    System.out.println("Login Failure");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                                }
                                            } else {
                                                System.out.println("Banned Account");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                            }
                                        } else {
                                            System.out.println("Login Failure");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (MongoCommandException ERC) {
                                        System.out.println("Malformed Request");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        //delegationTimer.trigger();
                                    }
                                }
                                if (requesttype == 18) {
                                    if ((Boolean) Filter.get("gameActive") == true) {
                                        //Deprecated, a killswitch has been added under rgcon in the field "gameActive"
                                        //TOKEN LOGIN FOR GAME, DOES NOT SEND EMAIL, LAUNCHER WILL NOT USE THIS.
                                        System.out.println("Game Login");
                                        String CTOKEN = (String) Lrequest.get("Token");
                                        Document accountServer;
                                        String 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 = (String) accountServer.get("Token");
                                            System.out.println("TokenPulled");
                                            if (accountServer.get("Status").equals(true)) {
                                                if (TKN.equals(CTOKEN)) {
                                                    System.out.println("TokenGood");
                                                    TKN = (String) 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("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                } else {
                                                    System.out.println("Login Failure");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                                }
                                            } else {
                                                System.out.println("Banned Account");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                            }
                                        } catch (MongoCommandException ERC) {
                                            System.out.println("Mongodb Error " + ERC);
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                            //delegationTimer.trigger();
                                        }
                                    } else {
                                        System.out.println("Login rejected, game client EOS has been reached.");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    }

                                }
                                if (requesttype == 10) {
                                    System.out.println("Account Creation Request");
                                    Document DServer = dCollection.find(eq("_id", 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");
                                    if ((Boolean) Filter.get("creationEnabled")) {
                                        String sourcet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
                                        StringBuilder sbt = new StringBuilder();
                                        Random random = new Random();
                                        int tokenlength = 60;
                                        for (int i = 0; i < tokenlength; i++) {
                                            int index = random.nextInt(sourcet.length());
                                            char randomChar = sourcet.charAt(index);
                                            sbt.append(randomChar);
                                        }
                                        String Token = "OCST" + sbt.toString();
                                        //Above makes token, it will be remade if it already exists
                                        String source = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
                                        StringBuilder sb = new StringBuilder();
                                        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 DupeEmail = accountS.find(eq("Email", Email)).first();
                                            String DUPEEMAIL = (String) DupeEmail.get("Email");
                                            if (DUPEEMAIL.equals(null)) {
                                                Document DupeUser = accountS.find(eq("User", User)).first();
                                                String DUPE = (String) DupeUser.get("User");
                                            }
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        } catch (Exception exr) {
                                            System.out.println("Username & Email Is Open");
                                            try {
                                                Document DupeToken = accountS.find(eq("Token", Token)).first();
                                                String DupeToke1n = (String) DupeToken.get("Token");
                                                System.out.println("Got Token from request");
                                                Boolean TokenOpen = false;
                                                while (TokenOpen == false) {
                                                    for (int i = 0; i < tokenlength; i++) {
                                                        int index = random.nextInt(sourcet.length());
                                                        char randomChar = sourcet.charAt(index);
                                                        sbt.append(randomChar);
                                                    }
                                                    Token = sbt.toString();
                                                    try {
                                                        DupeToken = accountS.find(eq("Token", Token)).first();
                                                        DupeToke1n = (String) DupeToken.get("Token");
                                                        System.out.println("Token Is Reserved, Try Again.");
                                                        for (int i = 0; i < tokenlength; i++) {
                                                            int index = random.nextInt(sourcet.length());
                                                            char randomChar = sourcet.charAt(index);
                                                            sbt.append(randomChar);
                                                        }
                                                    } 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();
                                                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", Token);
                                                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);
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", ClientID);
                                                secureCalls.accountCreationComplete(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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                            }

                                        }
                                    } else {
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", ClientID);
                                       try {   secureCalls.accountCreationDisabled(Email, User);} catch (Exception ex) {System.out.println("Unable to send disabled msg to user");
                                       }
                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 52));
                                        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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    }
                                }
                                if (requesttype == 20)
                                //TODO rewrite to just need username, password will be set by system later
                                {
                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    System.out.println("Shadow Account Creation Request");
                                    Document DServer = dCollection.find(eq("_id", ClientID)).first();
                                    String User = (String) DServer.get("User");
                                    String Password = (String) DServer.get("Password");
                                    //      String Email = (String) DServer.get("Email");
                                    String FName = User;
                                    String sourcet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
                                    StringBuilder sbt = new StringBuilder();
                                    Random random = new Random();
                                    int tokenlength = 60;
                                    for (int i = 0; i < tokenlength; i++) {
                                        int index = random.nextInt(sourcet.length());
                                        char randomChar = sourcet.charAt(index);
                                        sbt.append(randomChar);
                                    }
                                    String Token = "OCST" + sbt.toString();
                                    try {
                                        Document DupeUser = accountS.find(eq("User", User)).first();
                                        String DUPE = (String) DupeUser.get("User");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    } catch (Exception exr) {
                                        System.out.println("Username Is Open");
                                        try {
                                            Document DupeToken = accountS.find(eq("Token", Token)).first();
                                            String DupeToke1n = (String) DupeToken.get("Token");
                                            System.out.println("Got Token from request");
                                            Boolean TokenOpen = false;
                                            while (TokenOpen == false) {
                                                for (int i = 0; i < tokenlength; i++) {
                                                    int index = random.nextInt(sourcet.length());
                                                    char randomChar = sourcet.charAt(index);
                                                    sbt.append(randomChar);
                                                }
                                                Token = sbt.toString();
                                                try {
                                                    DupeToken = accountS.find(eq("Token", Token)).first();
                                                    DupeToke1n = (String) DupeToken.get("Token");
                                                    System.out.println("Token Is Reserved, Try Again.");
                                                    for (int i = 0; i < tokenlength; i++) {
                                                        int index = random.nextInt(sourcet.length());
                                                        char randomChar = sourcet.charAt(index);
                                                        sbt.append(randomChar);
                                                    }
                                                } 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();
                                            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", Token);
                                            createForm.append("Control", 1);
                                            accountS.insertOne(createForm);
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                        }

                                    }
                                }
                                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("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                    } catch (MongoCommandException ERC) {
                                        System.out.println("Mongodb Error " + ERC);
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", 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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        //delegationTimer.trigger();
                                    }
                                }
                                if (requesttype == 61) {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("_id", ClientID);
                                    System.out.println("Init ClientTraceback");
                                    String policyDocument;
                                    try {
                                        policyDocument = Files.readString(Path.of(System.getProperty("user.home") + "/ocs/policy/launcher/legal/eula.txt"));
                                    } catch (Exception EXR) {
                                        System.out.println("Unable to pull file, fallback.");
                                        policyDocument = "Policy file does not exist on server. This is an issue on our end. Error ID: " + EXR;
                                    }

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery2 = new BasicDBObject();
                                    BasicDBObject updateQuery3 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 62));
                                    updateQuery2.append("$set",
                                            new BasicDBObject().append("policyDocument", policyDocument));
                                    updateQuery3.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery2);
                                    dCollection.updateOne(searchQuery, updateQuery3);
                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                }
                                if (requesttype == 63) {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("_id", ClientID);
                                    System.out.println("Init ClientTraceback");
                                    String policyDocument;
                                    try {
                                        // File homedir = new File(System.getProperty("user.home"));
                                        policyDocument = Files.readString(Path.of(System.getProperty("user.home") + "/ocs/policy/launcher/legal/eula.txt"));
                                    } catch (Exception EXR) {
                                        System.out.println("Unable to pull file, fallback.");
                                        policyDocument = "Policy file does not exist on server. This is an issue on our end. Error ID: " + EXR;
                                    }

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery2 = new BasicDBObject();
                                    BasicDBObject updateQuery3 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 64));
                                    updateQuery2.append("$set",
                                            new BasicDBObject().append("policyDocument", policyDocument));
                                    updateQuery3.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery2);
                                    dCollection.updateOne(searchQuery, updateQuery3);
                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                }
                                if (requesttype == 65) {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("_id", ClientID);
                                    System.out.println("Collecting Error Data");
                                    File homedir = new File(System.getProperty("user.home"));
                                    String applicationName = Lrequest.get("applicationName").toString();
                                    String bugType = Lrequest.get("bugType").toString();
                                    String bugDetails = Lrequest.get("bugDetails").toString();
                                    String bugSeverity = Lrequest.get("bugSeverity").toString();
                                    String UUID = Lrequest.get("UUID").toString();
                                    String timeCurrent = LocalDateTime.now().toString(); //ISO-8601: yyyy-MM-ddTHH:mm:ss.S
                                    try {
                                        File myObj = new File(homedir + "/ocs/logs/" + applicationName + UUID + timeCurrent + ".txt");
                                        if (myObj.createNewFile()) {
                                            System.out.println("Log File created: " + myObj.getName());
                                            FileWriter writer = new FileWriter(homedir + "/ocs/logs/" + applicationName + UUID + timeCurrent + ".txt", true);
                                            writer.write("This bug report is for: " + applicationName);
                                            writer.write("\r\n");
                                            writer.write("The bug severity is level: " + bugSeverity);
                                            writer.write("\r\n");
                                            writer.write("The bug type is: " + bugType);
                                            writer.write("\r\n");
                                            writer.write("More bug details: " + bugDetails);
                                            writer.write("\r\n");
                                            writer.write("This is auto generated by the Obsidian Core backend services");
                                            writer.write("\r\n");
                                            writer.write("Submission Time (Local To Server): " + timeCurrent);
                                            writer.close();

                                        } else {
                                            System.out.println("Log already exists.");
                                        }
                                    } catch (IOException e) {
                                        System.out.println("An error occurred when attempting to log." + e);
                                    }
                                    BasicDBObject updateQuery = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    delegationServices.TargetDelete(Lrequest.get("_id"));
                                }
                                if (requesttype == 66) {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("_id", ClientID);
                                    System.out.println("Collecting Error Data");
                                    File homedir = new File(System.getProperty("user.home"));
                                    String applicationName = Lrequest.get("applicationName").toString();
                                    String bugType = Lrequest.get("bugType").toString();
                                    String bugDetails = Lrequest.get("bugDetails").toString();
                                    String bugSeverity = Lrequest.get("bugSeverity").toString();
                                    String bugLog = Lrequest.get("bugLog").toString();
                                    String UUID = Lrequest.get("UUID").toString();
                                    String timeCurrent = LocalDateTime.now().toString(); //ISO-8601: yyyy-MM-ddTHH:mm:ss.S
                                    try {
                                        File myObj = new File(homedir + "/ocs/logs/" + applicationName + UUID + timeCurrent + ".txt");
                                        if (myObj.createNewFile()) {
                                            System.out.println("Log File created: " + myObj.getName());
                                            FileWriter writer = new FileWriter(homedir + "/ocs/logs/" + applicationName + UUID + timeCurrent + ".txt", true);
                                            writer.write("This bug report is for: " + applicationName);
                                            writer.write("\r\n");
                                            writer.write("The bug severity is level: " + bugSeverity);
                                            writer.write("\r\n");
                                            writer.write("The bug type is: " + bugType);
                                            writer.write("\r\n");
                                            writer.write("More bug details: " + bugDetails);
                                            writer.write("\r\n");
                                            writer.write("This is auto generated by the Obsidian Core backend services");
                                            writer.write("\r\n");
                                            writer.write("Submission Time (Local To Server): " + timeCurrent);
                                            writer.write("\r\n");
                                            writer.write("Full log file:");
                                            writer.write("\r\n");
                                            writer.write(bugLog);
                                            writer.close();
                                        } else {
                                            System.out.println("Log already exists.");
                                        }
                                    } catch (IOException e) {
                                        System.out.println("An error occurred while attempting to log." + e);
                                    }
                                    BasicDBObject updateQuery = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    delegationServices.TargetDelete(Lrequest.get("_id"));
                                }
                                if (requesttype == 71) {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("_id", ClientID);
                                    System.out.println("Collecting Telemetry Data");
                                    File homedir = new File(System.getProperty("user.home"));
                                    String applicationName = Lrequest.get("applicationName").toString();
                                    String telemetryType = Lrequest.get("TelemetryType").toString();
                                    String telemetryDetails = Lrequest.get("TelemetryDetails").toString();
                                    String UUID = Lrequest.get("UUID").toString();
                                    String timeCurrent = LocalDateTime.now().toString(); //ISO-8601: yyyy-MM-ddTHH:mm:ss.S
                                    try {
                                        File myObj = new File(homedir + "/ocs/telemetry/" + UUID + "/" + applicationName  + timeCurrent + ".txt");
                                        File myFold = new File(homedir + "/ocs/telemetry/" + UUID);
                                        myFold.mkdir();
                                        if (myObj.createNewFile()) {
                                            System.out.println("Log File created: " + myObj.getName());
                                            FileWriter writer = new FileWriter(homedir + "/ocs/telemetry/" + UUID + "/" + applicationName + timeCurrent + ".txt", true);
                                            writer.write("This Telemetry report is for: " + applicationName);
                                            writer.write("\r\n");
                                            writer.write("Type of telemetry: " + telemetryType);
                                            writer.write("\r\n");
                                            writer.write("Telemetry: " + telemetryDetails);
                                            writer.write("\r\n");
                                            writer.write("This is auto generated by the Obsidian Core backend services");
                                            writer.write("\r\n");
                                            writer.write("Submission Time (Local To Server): " + timeCurrent);
                                            writer.close();

                                        } else {
                                            System.out.println("Log already exists.");
                                        }
                                    } catch (IOException e) {
                                        System.out.println("An error occurred when attempting to log." + e);
                                    }
                                    BasicDBObject updateQuery = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    delegationServices.TargetDelete(Lrequest.get("_id"));
                                }
                                if (requesttype == 72) {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("_id", ClientID);
                                    System.out.println("Collecting Telemetry Data");
                                    File homedir = new File(System.getProperty("user.home"));
                                    String applicationName = Lrequest.get("applicationName").toString();
                                    String telemetryType = Lrequest.get("telemetryType").toString();
                                    String telemetryDetails = Lrequest.get("telemetryDetails").toString();
                                    String telemetryLog = Lrequest.get("telemetryLog").toString();
                                    String UUID = Lrequest.get("UUID").toString();
                                    String timeCurrent = LocalDateTime.now().toString(); //ISO-8601: yyyy-MM-ddTHH:mm:ss.S
                                    try {
                                        File myObj = new File(homedir + "/ocs/telemetry/" + UUID + "/" + applicationName  + "logfile" +  timeCurrent + ".txt");
                                        File myFold = new File(homedir + "/ocs/telemetry/" + UUID);
                                        myFold.mkdir();
                                        if (myObj.createNewFile()) {
                                            System.out.println("Log File created: " + myObj.getName());
                                            FileWriter writer = new FileWriter(homedir + "/ocs/telemetry/" + UUID + "/" + applicationName + "logfile" + timeCurrent + ".txt", true);
                                            writer.write("This telemetry report is for: " + applicationName);
                                            writer.write("\r\n");
                                            writer.write("The telemetry type is: " + telemetryType);
                                            writer.write("\r\n");
                                            writer.write("More telemetry details: " + telemetryDetails);
                                            writer.write("\r\n");
                                            writer.write("This is auto generated by the Obsidian Core backend services");
                                            writer.write("\r\n");
                                            writer.write("Submission Time (Local To Server): " + timeCurrent);
                                            writer.write("\r\n");
                                            writer.write("Full log file:");
                                            writer.write("\r\n");
                                            writer.write(telemetryLog);
                                            writer.close();
                                        } else {
                                            System.out.println("telemetry already exists. (wow that's rare)");
                                        }
                                    } catch (IOException e) {
                                        System.out.println("An error occurred while attempting to save telemetry." + e);
                                    }
                                    BasicDBObject updateQuery = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    delegationServices.TargetDelete(Lrequest.get("_id"));
                                }
                                if (requesttype == 68) {
                                    System.out.println("Verifying OTK");
                                    String userKey = (String) Lrequest.get("otk");
                                    String clientUUID = (String) Lrequest.get("uuid");
                                    String serverUUID;
                                    userKey = userKey.toUpperCase();
                                    Document accountServer;
                                    try {
                                        accountServer = accountS.find(eq("delOTK", userKey)).first();
                                        serverUUID = (String) accountServer.get("UUID");
                                        if (accountServer.get("Status").equals(true)) {
                                            if (clientUUID.equalsIgnoreCase(serverUUID)) {
                                                System.out.println("This key is correct.");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", ClientID);

                                                BasicDBObject updateQuery = new BasicDBObject();
                                                BasicDBObject updateQuery1 = new BasicDBObject();
                                                updateQuery.append("$set",
                                                        new BasicDBObject().append("type", 69));
                                                updateQuery1.append("$set",
                                                        new BasicDBObject().append("status", true));
                                                dCollection.updateOne(searchQuery, updateQuery);
                                                dCollection.updateOne(searchQuery, updateQuery1);
                                                //delegationTimer.trigger();
                                                offBoarding((String) accountServer.get("Email"), (String) accountServer.get("User"), (String) accountServer.get("FName"));
                                                delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                accountS.deleteOne(accountServer);
                                            } else {
                                                System.out.println("This key is incorrect");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", ClientID);

                                                BasicDBObject updateQuery = new BasicDBObject();
                                                BasicDBObject updateQuery1 = new BasicDBObject();
                                                updateQuery.append("$set",
                                                        new BasicDBObject().append("type", 70));
                                                updateQuery1.append("$set",
                                                        new BasicDBObject().append("status", true));
                                                dCollection.updateOne(searchQuery, updateQuery);
                                                dCollection.updateOne(searchQuery, updateQuery1);
                                                //delegationTimer.trigger();
                                                delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                            }
                                        } else
                                        {
                                            System.out.println("This key is incorrect, account is banned.");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", ClientID);

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 70));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (Exception ERC) {
                                        System.out.println("This key is incorrect." + ERC);
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", ClientID);

                                        BasicDBObject updateQuery = new BasicDBObject();
                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                        updateQuery.append("$set",
                                                new BasicDBObject().append("type", 70));
                                        updateQuery1.append("$set",
                                                new BasicDBObject().append("status", true));
                                        dCollection.updateOne(searchQuery, updateQuery);
                                        dCollection.updateOne(searchQuery, updateQuery1);
                                        delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                    }

                                }
                                if (requesttype == 67) {
                                    String OTK = "keyNotSetDueToError(ERR24)";
                                    Boolean keyStatus = false;
                                    //default false, since will be set to true if the measurement exists on linked account
                                    String accountUUID = (String) Lrequest.get("uuid");
                                    Document linkedAccount = accountS.find(eq("UUID", accountUUID)).first();
                                    try {
                                        keyStatus = (boolean) linkedAccount.get("delStatus");
                                    } catch (Exception NPE) {
                                        keyStatus = false;
                                    }
                                    if (keyStatus == false) {
                                        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);
                                        }
                                        OTK = sb.toString();
                                        BasicDBObject deleteKey = new BasicDBObject();
                                        BasicDBObject deleteKeyStatus = new BasicDBObject();
                                        BasicDBObject deleteTie = new BasicDBObject();
                                        deleteTie.append("UUID", accountUUID);
                                        deleteKey.append("$set",
                                                new BasicDBObject().append("delOTK", OTK));
                                        deleteKeyStatus.append("$set",
                                                new BasicDBObject().append("delStatus", true));
                                        accountS.updateOne(deleteTie, deleteKey);
                                        accountS.updateOne(deleteTie, deleteKeyStatus);
                                        otkDeletionEmail((String) linkedAccount.get("Email"), OTK, (String) linkedAccount.get("User"));
                                    } else {
                                        otkDeletionEmailResend((String) linkedAccount.get("Email"), (String) linkedAccount.get("delOTK"), (String) linkedAccount.get("User"));
                                    }
                                    BasicDBObject clearCL = new BasicDBObject();
                                    clearCL.append("_id", ClientID);
                                    BasicDBObject clearUO = new BasicDBObject();
                                    clearUO.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(clearCL, clearUO);
                                    TargetDelete(ClientID);
                                }
                                if (requesttype == 81) {
                                    System.out.println("Login Request (TKN)");
                                    String CTOKEN = (String) Lrequest.get("token");
                                    // Document TResolve = dCollection.find(eq("type", 3)).first();
                                    Document accountServer;
                                    String TKN;
                                    String Password;
                                    String Fname;
                                    String UserName;
                                    String Email;
                                    String keychainUUID;
                                    //String validSession;
                                    try {
                                        accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                        if (!(accountServer == null)) {
                                            TKN = (String) accountServer.get("Token");
                                          /*
                                           validSession = (String) accountServer.get("websession");
                                           This may be added later to serve session tokens, this however will be added before chat is released to the public.
                                           */

                                          if (accountServer.get("Status").equals(true)) {
                                                if (TKN.equals(CTOKEN)) {
                                                    Fname = (String) accountServer.get("FName");
                                                    UserName = (String) accountServer.get("User");
                                                    keychainUUID = (String) accountServer.get("UUID");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", Lrequest.get("_id"));
                                                    BasicDBObject updateQuery = new BasicDBObject();
                                                    BasicDBObject updateQuery2 = new BasicDBObject();
                                                    BasicDBObject updateQuery4 = new BasicDBObject();
                                                    BasicDBObject updateQuery6 = new BasicDBObject();
                                                    BasicDBObject updateQuery9 = new BasicDBObject();
                                                    updateQuery.append("$set",
                                                            new BasicDBObject().append("type", 82));
                                                    updateQuery2.append("$set",
                                                            new BasicDBObject().append("Fname", Fname));
                                                    updateQuery4.append("$set",
                                                            new BasicDBObject().append("User", UserName));
                                                    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, updateQuery);
                                                    dCollection.updateOne(searchQuery, updateQuery2);
                                                    dCollection.updateOne(searchQuery, updateQuery4);
                                                    dCollection.updateOne(searchQuery, updateQuery9);
                                                    dCollection.updateOne(searchQuery, updateQuery6);
                                                    //delegationTimer.trigger();
                                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                } else {
                                                    System.out.println("Login Failure");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", Lrequest.get("_id"));

                                                    BasicDBObject updateQuery = new BasicDBObject();
                                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                                    updateQuery.append("$set",
                                                            new BasicDBObject().append("type", 86));
                                                    updateQuery1.append("$set",
                                                            new BasicDBObject().append("status", true));
                                                    dCollection.updateOne(searchQuery, updateQuery);
                                                    dCollection.updateOne(searchQuery, updateQuery1);
                                                    //delegationTimer.trigger();
                                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));

                                                }
                                            } else {
                                                System.out.println("Banned Account");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", Lrequest.get("_id"));

                                                BasicDBObject updateQuery = new BasicDBObject();
                                                BasicDBObject updateQuery1 = new BasicDBObject();
                                                updateQuery.append("$set",
                                                        new BasicDBObject().append("type", 85));
                                                updateQuery1.append("$set",
                                                        new BasicDBObject().append("status", true));
                                                dCollection.updateOne(searchQuery, updateQuery);
                                                dCollection.updateOne(searchQuery, updateQuery1);
                                                delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));

                                            }
                                        } else {
                                            System.out.println("Login Failure");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", Lrequest.get("_id"));

                                            BasicDBObject updateQuery = new BasicDBObject();
                                            BasicDBObject updateQuery1 = new BasicDBObject();
                                            updateQuery.append("$set",
                                                    new BasicDBObject().append("type", 86));
                                            updateQuery1.append("$set",
                                                    new BasicDBObject().append("status", true));
                                            dCollection.updateOne(searchQuery, updateQuery);
                                            dCollection.updateOne(searchQuery, updateQuery1);
                                            //delegationTimer.trigger();
                                            delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (MongoCommandException ERC) {
                                        System.out.println("Malformed Request");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", Lrequest.get("_id"));

                                        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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        //delegationTimer.trigger();
                                    }
                                }
                                if (requesttype == 73) {
                                    System.out.println("Login Request (USR&PASS)");
                                    String username = (String) Lrequest.get("user");
                                    String password = (String) Lrequest.get("password");
                                    String session;
                                    String sourcet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
                                    StringBuilder sbt = new StringBuilder();
                                    Random srandom = new Random();
                                    int sidl = 100;
                                    for (int i = 0; i < sidl; i++) {
                                        int index = srandom.nextInt(sourcet.length());
                                        char randomChar = sourcet.charAt(index);
                                        sbt.append(randomChar);
                                    }
                                    session = sbt.toString();
                                    Object objid = Lrequest.get("_id");
                                    System.out.println(objid);
                                    Document accountServer;
                                    String Password; String 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("_id", objid);
                                                    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("_id", objid);
                                                    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.DeleteTargetRequestByID(objid);
                                                    System.out.println("Deleted");
                                                }

                                            } else {
                                                System.out.println("RSC");
                                                if (Password.equals(password)) {
                                                    System.out.println("R3c");
                                                    Token = (String) 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");
                                                    System.out.println("4");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    BasicDBObject searchQueryAD = new BasicDBObject();
                                                    searchQuery.append("_id", objid);
                                                    searchQueryAD.append("UUID", keychainUUID);
                                                    BasicDBObject updateQuery = new BasicDBObject();
                                                    BasicDBObject updateQuery1 = 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 updateQuery9 = new BasicDBObject();
                                                    BasicDBObject updateQueryAD = 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));
                                                    updateQuery7.append("$set",
                                                            new BasicDBObject().append("Email", Email));
                                                    updateQuery6.append("$set",
                                                            new BasicDBObject().append("status", true));
                                                    updateQuery8.append("$set",
                                                            new BasicDBObject().append("keychainUUID", keychainUUID));
                                                    updateQuery9.append("$set",
                                                            new BasicDBObject().append("session", session));
                                                    updateQueryAD.append("$set",
                                                            new BasicDBObject().append("websession", session));
                                                    System.out.println("3");
                                                    dCollection.updateOne(searchQuery, updateQuery);
                                                    dCollection.updateOne(searchQuery, updateQuery1);
                                                    dCollection.updateOne(searchQuery, updateQuery2);
                                                    dCollection.updateOne(searchQuery, updateQuery3);
                                                    dCollection.updateOne(searchQuery, updateQuery4);
                                                    dCollection.updateOne(searchQuery, updateQuery9);
                                                    dCollection.updateOne(searchQuery, updateQuery7);
                                                    dCollection.updateOne(searchQuery, updateQuery8);
                                                    dCollection.updateOne(searchQuery, updateQuery6);
                                                    accountS.updateOne(searchQueryAD,updateQueryAD);
                                                   /*The last update allows the server to add the current authed web session, home page
                                                   will verify session staus, if it is invalid the user will be pushed to create a new session.
                                                   */
                                                    System.out.println("2");
                                                    //delegationTimer.trigger();
                                                    System.out.println("1");
                                                    delegationTimer.DeleteTargetRequestByID(objid);
                                                    System.out.println("clear");
                                                } else {
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", objid);

                                                    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.DeleteTargetRequestByID(objid);
                                                }
                                            }
                                        } else {
                                            System.out.println("Banned Account");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id",Lrequest.get("_id"));

                                            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.DeleteTargetRequestByID(objid);
                                        }
                                    } catch (Exception ERC) {
                                        System.out.println("Something Went Wrong: " + ERC.getLocalizedMessage());
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id",Lrequest.get("_id"));

                                        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.DeleteTargetRequestByID(objid);
                                    }

                                }
                                if (requesttype == 74) {
                                    System.out.println("Login Request (TKN-WB)");
                                    String CTOKEN = (String) Lrequest.get("token");
                                    // Document TResolve = dCollection.find(eq("type", 3)).first();
                                    Document accountServer;
                                    String TKN;
                                    String Password;
                                    String Fname;
                                    String Path;
                                    String UserName;
                                    String Email;
                                    String keychainUUID;
                                    String validSession;
                                    try {
                                        accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                        if (!(accountServer == null)) {
                                            TKN = (String) accountServer.get("Token");
                                            validSession = (String) accountServer.get("websession");
                                            if (accountServer.get("Status").equals(true)) {
                                                if (TKN.equals(CTOKEN) && Lrequest.get("sessionID").equals(validSession)) {
                                                    TKN = (String) 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");
                                                    validSession = (String) accountServer.get("session");
                                                    keychainUUID = (String) accountServer.get("UUID");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", Lrequest.get("_id"));

                                                    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 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));
                                                    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, updateQuery8);
                                                    dCollection.updateOne(searchQuery, updateQuery7);
                                                    dCollection.updateOne(searchQuery, updateQuery9);
                                                    dCollection.updateOne(searchQuery, updateQuery6);
                                                    //delegationTimer.trigger();
                                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                                } else {
                                                    System.out.println("Login Failure");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", Lrequest.get("_id"));

                                                    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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                                }
                                            } else {
                                                System.out.println("Banned Account");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", Lrequest.get("_id"));

                                                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.DeleteTargetRequestByID(Lrequest.get("_id"));

                                            }
                                        } else {
                                            System.out.println("Login Failure");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", Lrequest.get("_id"));

                                            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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (MongoCommandException ERC) {
                                        System.out.println("Malformed Request");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", Lrequest.get("_id"));

                                        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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        //delegationTimer.trigger();
                                    }
                                }
                                if (requesttype == 75) {
                                    System.out.println("Link request");
                                    String CTOKEN = (String) Lrequest.get("token");
                                    String platform = (String) Lrequest.get("linkplatform");
                                    String email = (String) Lrequest.get("emailtoken");
                                    String id = (String) Lrequest.get("linktoken");
                                    Document accountServer;
                                    String TKN;
                                    String Password;
                                    String Fname;
                                    String Path;
                                    String UserName;
                                    String Email;
                                    String keychainUUID;
                                    String validSession;
                                    try {
                                        accountServer = accountS.find(eq("Token", CTOKEN)).first();
                                        if (!(accountServer == null)) {
                                            TKN = (String) accountServer.get("Token");
                                            if (accountServer.get("Status").equals(true)) {
                                                if (TKN.equals(CTOKEN)) {
                                                    if (accountServer.get(platform+"idstatus") == null) {
                                                        Email = (String) accountServer.get("Email");
                                                        UserName = (String) accountServer.get("User");
                                                        BasicDBObject searchQuery = new BasicDBObject();
                                                        searchQuery.append("_id", Lrequest.get("_id"));
                                                        BasicDBObject searchQueryASC = new BasicDBObject();
                                                        searchQueryASC.append("Token", TKN);

                                                        BasicDBObject updateQuery = new BasicDBObject();
                                                        BasicDBObject updateQuery3 = new BasicDBObject();
                                                        BasicDBObject updateQuery4 = new BasicDBObject();
                                                        BasicDBObject updateQueryAD = new BasicDBObject();
                                                        BasicDBObject updateQueryADBS = new BasicDBObject();
                                                        BasicDBObject externalEmail = new BasicDBObject();
                                                        updateQuery.append("$set",
                                                                new BasicDBObject().append("type", 76));
                                                        updateQuery4.append("$set",
                                                                new BasicDBObject().append("status", true));
                                                        updateQueryAD.append("$set",
                                                                new BasicDBObject().append(platform + "id", id));
                                                        updateQueryADBS.append("$set",
                                                                new BasicDBObject().append(platform + "idstatus", true));
                                                        externalEmail.append("$set",
                                                                new BasicDBObject().append(platform + "email", email));
                                                        System.out.println("Sending Info To Forwarding Server");
                                                        dCollection.updateOne(searchQuery, updateQuery);
                                                        accountS.updateOne(searchQueryASC, updateQueryAD);
                                                        accountS.updateOne(searchQueryASC, externalEmail);
                                                        accountS.updateOne(searchQueryASC, updateQueryADBS);
                                                        dCollection.updateOne(searchQuery, updateQuery4);
                                                        secureCalls.accountLinked(Email, platform, UserName);
                                                        delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));

                                                    } else {
                                                        System.out.println("Already linked");
                                                        BasicDBObject searchQuery = new BasicDBObject();
                                                        searchQuery.append("_id", Lrequest.get("_id"));

                                                        BasicDBObject updateQuery = new BasicDBObject();
                                                        BasicDBObject updateQuery1 = new BasicDBObject();
                                                        updateQuery.append("$set",
                                                                new BasicDBObject().append("type", 77));
                                                        updateQuery1.append("$set",
                                                                new BasicDBObject().append("status", true));
                                                        dCollection.updateOne(searchQuery, updateQuery);
                                                        dCollection.updateOne(searchQuery, updateQuery1);
                                                        //delegationTimer.trigger();
                                                        delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));

                                                    }
                                                } else {
                                                    System.out.println("Link Failure");
                                                    BasicDBObject searchQuery = new BasicDBObject();
                                                    searchQuery.append("_id", Lrequest.get("_id"));

                                                    BasicDBObject updateQuery = new BasicDBObject();
                                                    BasicDBObject updateQuery1 = new BasicDBObject();
                                                    updateQuery.append("$set",
                                                            new BasicDBObject().append("type", 77));
                                                    updateQuery1.append("$set",
                                                            new BasicDBObject().append("status", true));
                                                    dCollection.updateOne(searchQuery, updateQuery);
                                                    dCollection.updateOne(searchQuery, updateQuery1);
                                                    //delegationTimer.trigger();
                                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));

                                                }
                                            } else {
                                                System.out.println("Banned Account");
                                                BasicDBObject searchQuery = new BasicDBObject();
                                                searchQuery.append("_id", Lrequest.get("_id"));

                                                BasicDBObject updateQuery = new BasicDBObject();
                                                BasicDBObject updateQuery1 = new BasicDBObject();
                                                updateQuery.append("$set",
                                                        new BasicDBObject().append("type", 77));
                                                updateQuery1.append("$set",
                                                        new BasicDBObject().append("status", true));
                                                dCollection.updateOne(searchQuery, updateQuery);
                                                dCollection.updateOne(searchQuery, updateQuery1);
                                                delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));

                                            }
                                        } else {
                                            System.out.println("Login Failure");
                                            BasicDBObject searchQuery = new BasicDBObject();
                                            searchQuery.append("_id", Lrequest.get("_id"));

                                            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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        }
                                    } catch (MongoCommandException ERC) {
                                        System.out.println("Malformed Request");
                                        BasicDBObject searchQuery = new BasicDBObject();
                                        searchQuery.append("_id", Lrequest.get("_id"));

                                        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.DeleteTargetRequestByID(Lrequest.get("_id"));
                                        //delegationTimer.trigger();
                                    }
                                }
                                if (requesttype == 78) {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("_id", ClientID);
                                    System.out.println("Collecting Telemetry Data");
                                    File homedir = new File(System.getProperty("user.home"));
                                    String applicationName = Lrequest.get("useragent").toString();
                                    // String telemetryType = Lrequest.get("telemetryType").toString();
                                    String mclog = Lrequest.get("log").toString();
                                    String IGN = Lrequest.get("ign").toString();
                                    String timeCurrent = LocalDateTime.now().toString(); //ISO-8601: yyyy-MM-ddTHH:mm:ss.S
                                    try {
                                        File myObj = new File(homedir + "/crad/telemetry/" + IGN + "/" + timeCurrent + ".txt");
                                        File myFold = new File(homedir + "/crad/telemetry/" + IGN);
                                        myFold.mkdir();
                                        if (myObj.createNewFile()) {
                                            System.out.println("Log File created: " + myObj.getName());
                                            FileWriter writer = new FileWriter(homedir + "/crad/telemetry/" + IGN + "/" + timeCurrent + ".txt", true);
                                            writer.write("This telemetry report is for: " + applicationName);
                                            writer.write("\r\n");
                                            writer.write("\r\n");
                                            writer.write("This is auto generated by the Obsidian Core backend services (For Create Research & Development.");
                                            writer.write("\r\n");
                                            writer.write("Submission Time (Local To Server): " + timeCurrent);
                                            writer.write("\r\n");
                                            writer.write("Full log file:");
                                            writer.write("\r\n");
                                            writer.write(mclog);
                                            writer.close();
                                        } else {
                                            System.out.println("telemetry already exists. (wow that's rare)");
                                        }
                                    } catch (IOException e) {
                                        System.out.println("An error occurred while attempting to save telemetry." + e);
                                    }
                                    BasicDBObject updateQuery = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                }
                                if (requesttype == 79) {
                                    BasicDBObject searchQuery = new BasicDBObject();
                                    searchQuery.append("_id", ClientID);
                                    System.out.println("Init ClientTraceback");
                                    String policyDocument;
                                    try {
                                        policyDocument = Files.readString(Path.of(System.getProperty("user.home") + "/ocs/policy/launcher/legal/eula.txt"));
                                    } catch (Exception EXR) {
                                        System.out.println("Unable to pull file, fallback.");
                                        policyDocument = "Policy file does not exist on server. This is an issue on our end. Error ID: " + EXR;
                                    }

                                    BasicDBObject updateQuery = new BasicDBObject();
                                    BasicDBObject updateQuery2 = new BasicDBObject();
                                    BasicDBObject updateQuery3 = new BasicDBObject();
                                    updateQuery.append("$set",
                                            new BasicDBObject().append("type", 80));
                                    updateQuery2.append("$set",
                                            new BasicDBObject().append("policyDocument", policyDocument));
                                    updateQuery3.append("$set",
                                            new BasicDBObject().append("status", true));
                                    dCollection.updateOne(searchQuery, updateQuery);
                                    dCollection.updateOne(searchQuery, updateQuery2);
                                    dCollection.updateOne(searchQuery, updateQuery3);
                                    delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
                                }
                            } else {
                                System.out.println("Malformed Request, Non Recoverable (Request Type Not Found)");
                                BasicDBObject searchQuery = new BasicDBObject();
                                searchQuery.append("_id", 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);
                                BasicDBObject clearCL = new BasicDBObject();
                                clearCL.append("_id", ClientID);
                                delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));

                            }
                    }
                }
            } catch (Exception Erp) {
                System.out.println("Malformed Request, Non Recoverable ErrorInfo: ");
                Erp.printStackTrace();
                BasicDBObject searchQuery = new BasicDBObject();
                searchQuery.append("_id",Lrequest.get("_id"));

                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", "uk"));
                Lrequest.append("status", true);
                dCollection.updateOne(searchQuery, updateQuery1);
                dCollection.updateOne(searchQuery, updateQuery);
                dCollection.updateOne(searchQuery, updateQuery);
                delegationTimer.DeleteTargetRequestByID(Lrequest.get("_id"));
            }
        }

    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(Object ID) {
        BasicDBObject searchQuery = new BasicDBObject();
        searchQuery.append("_id", ID);
        dCollection.deleteMany(searchQuery);
        System.out.println("Flushed a targeted request (CID) from the server");


    }
    public static void TargetDeleteByID(Object ID) {
        BasicDBObject searchQuery = new BasicDBObject();
        searchQuery.append("_id", ID);
        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 userAuthetication() {
        Lrequest = dCollection.find(eq("status", false)).first();
        if (!(Lrequest == null)) {
                      delegationProcesser();
        }


    }
    
}