Riot Login

async void Login(string username, string pass, BaseRegion selectedRegion, Deletable<UserClient> user)
        {
            user.Instance.Region = selectedRegion;
            user.Instance.calls = new RiotCalls(user.Instance);
            //BaseRegion selectedRegion = BaseRegion.GetRegion((string)RegionComboBox.SelectedValue);
            var authToken = await user.Instance.calls.GetRestToken(username, pass, selectedRegion.LoginQueue);
            if (authToken == "invalid_credentials")
            {
                ErrorTextBox.Text = "Wrong login data";
                user.Delete();
                HideGrid.Visibility = Visibility.Visible;
                ErrorTextBox.Visibility = Visibility.Visible;
                LoggingInLabel.Visibility = Visibility.Hidden;
                LoggingInProgressRing.Visibility = Visibility.Collapsed;
                return;
            }
            user.Instance.RiotConnection = new RtmpClient(new System.Uri("rtmps://" + selectedRegion.Server + ":2099"), user.Instance.calls.RegisterObjects(), ObjectEncoding.Amf3);
            user.Instance.RiotConnection.CallbackException += client_CallbackException;
            user.Instance.RiotConnection.MessageReceived += client_MessageReceived;
            try
            {

                await user.Instance.RiotConnection.ConnectAsync();
            }
            catch
            {
                ErrorTextBox.Text = "Failed to login. SSL error.";
                HideGrid.Visibility = Visibility.Visible;
                ErrorTextBox.Visibility = Visibility.Visible;
                LoggingInLabel.Visibility = Visibility.Hidden;
                LoggingInProgressRing.Visibility = Visibility.Collapsed;
                //user.Delete();
                Login(username, pass, selectedRegion, user);
                return;
            }

            user.Instance.RiotConnection.SetChunkSize(2147483647);
            AuthenticationCredentials newCredentials = new AuthenticationCredentials
            {
                Username = username,
                Password = pass,
                ClientVersion = Client.Version,
                IpAddress = user.Instance.calls.GetIpAddress(),
                Locale = selectedRegion.Locale,
                OperatingSystem = "Windows 7",
                Domain = "lolclient.lol.riotgames.com",
                AuthToken = authToken
            };
            Session login = await user.Instance.calls.Login(newCredentials);
            if (login == null)
            {
                Client.Log("Login session is null.");
                var overlay = new MessageOverlay
                {
                    MessageTextBox = { Text = "Login session is null. Login failed. Please check whether the version number is correct or not.", IsReadOnly = true },
                    MessageTitle = { Content = "Login session is null." }
                };
                Client.OverlayContainer.Content = overlay.Content;
                Client.OverlayContainer.Visibility = Visibility.Visible;
                ErrorTextBox.Text = "Failed to login. Login session is null.";
                HideGrid.Visibility = Visibility.Visible;
                ErrorTextBox.Visibility = Visibility.Visible;
                LoggingInLabel.Visibility = Visibility.Hidden;
                LoggingInProgressRing.Visibility = Visibility.Collapsed;
                return;
            }
            user.Instance.PlayerSession = login;

            var str1 = string.Format("gn-{0}", login.AccountSummary.AccountId);
            var str2 = string.Format("cn-{0}", login.AccountSummary.AccountId);
            var str3 = string.Format("bc-{0}", login.AccountSummary.AccountId);
            Task<bool>[] taskArray = { user.Instance.RiotConnection.SubscribeAsync("my-rtmps", "messagingDestination", str1, str1),
                                                 user.Instance.RiotConnection.SubscribeAsync("my-rtmps", "messagingDestination", str2, str2),
                                                 user.Instance.RiotConnection.SubscribeAsync("my-rtmps", "messagingDestination", "bc", str3) };

            await Task.WhenAll(taskArray);
            //Riot added this for no reason but make it look like the riot client we have to do this
            var plainTextbytes = Encoding.UTF8.GetBytes(login.AccountSummary.Username + ":" + login.Token);
            user.Instance.reconnectToken = Convert.ToBase64String(plainTextbytes);

            var LoggedIn = await user.Instance.RiotConnection.LoginAsync(username.ToLower(), login.Token);

            var packetx = await user.Instance.calls.GetLoginDataPacketForUser();

            if (packetx == null || packetx.AllSummonerData == null)
            {
                user.Instance.RiotConnection.CallbackException -= client_CallbackException;
                user.Instance.RiotConnection.MessageReceived -= client_MessageReceived;
                //Just Created Account, need to put logic here.
                user.Instance.done = false;
                Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
                {
                    var createSummoner = new CreateSummonerNameOverlay(user.Instance);
                    Client.OverlayContainer.Content = createSummoner.Content;
                    Client.OverlayContainer.Visibility = Visibility.Visible;
                }));
                while (!user.Instance.done)
                {
                }
                Login(username, pass, selectedRegion, user);
                return;
            }

            if (saveuser || !string.IsNullOrWhiteSpace(Client.EncrytKey))
            {
                UserList.AddUser(username, pass, packetx.AllSummonerData.Summoner.InternalName,
                                    "Using Sightstone", packetx.AllSummonerData.Summoner.ProfileIconId,
                                    selectedRegion, ShowType.chat, Client.EncrytKey);
                saveuser = false;
            }
            DoGetOnLoginPacket(username, pass, selectedRegion, packetx, user);
        }

        private async void DoGetOnLoginPacket(string username, string pass, BaseRegion selectedRegion, LoginDataPacket packetx, Deletable<UserClient> user)
        {
            //TODO: Finish this so all calls are used

            user.Instance.Queues = await user.Instance.calls.GetAvailableQueues();
            user.Instance.PlayerChampions = await user.Instance.calls.GetAvailableChampions();
            //var runes = await RiotCalls.GetSummonerRuneInventory(packetx.AllSummonerData.Summoner.AcctId);
            user.Instance.StartHeartbeat();
            //var leaguePos = await RiotCalls.GetMyLeaguePositions();
            //var preferences = await RiotCalls.LoadPreferencesByKey();
            //var masterybook = await RiotCalls.GetMasteryBook(packetx.AllSummonerData.Summoner.AcctId);
            //var lobby = await RiotCalls.CheckLobbyStatus();
            var invites = await user.Instance.calls.GetPendingInvitations();
            //var player = await RiotCalls.CreatePlayer();
            GotLoginPacket(packetx, username, pass, selectedRegion, user);

            foreach (var pop in from InvitationRequest invite in invites
                                select new GameInvitePopup(invite, user.Instance)
                                {
                                    HorizontalAlignment = HorizontalAlignment.Right,
                                    VerticalAlignment = VerticalAlignment.Bottom,
                                    Height = 230
                                })
                Client.NotificationGrid.Children.Add(pop);
            if (invites.Length != 0)
                Client.MainWin.FlashWindow();

            user.Instance.LoginPacket = packetx;
            if (!dataLogin.ContainsKey(packetx.AllSummonerData.Summoner.InternalName + ":" + selectedRegion))
            {
                dataLogin.Add(packetx.AllSummonerData.Summoner.InternalName + ":" + selectedRegion, new LoginData
                {
                    Pass = pass,
                    Region = selectedRegion,
                    ShowType = ShowType.chat,
                    Status = "Using Sightstone",
                    SumIcon = packetx.AllSummonerData.Summoner.ProfileIconId,
                    SumName = packetx.AllSummonerData.Summoner.InternalName,
                    User = username
                });

                LoggingInLabel.Visibility = Visibility.Hidden;
                LoggingInProgressRing.Visibility = Visibility.Hidden;
                Encrypt.Visibility = Visibility.Hidden;
                EncryptCheck.Visibility = Visibility.Hidden;
            }
        }

        private void GotLoginPacket(LoginDataPacket packet, string username, string pass, BaseRegion selectedRegion, Deletable<UserClient> user)
        {

            user.Instance.LoginPacket = packet;
            Client.CurrentServer = selectedRegion.Server + ":" + packet.AllSummonerData.Summoner.InternalName;
            UserList.Users.Add(selectedRegion.Server + ":" + packet.AllSummonerData.Summoner.InternalName, new Dictionary<string, UserClient> { { packet.AllSummonerData.Summoner.InternalName, user.Instance } });
            if (packet.AllSummonerData.Summoner.ProfileIconId == -1)
            {
                user.Instance.RiotConnection.CallbackException -= client_CallbackException;
                user.Instance.RiotConnection.MessageReceived -= client_MessageReceived;
                user.Instance.done = false;
                Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
                {
                    Client.OverlayContainer.Content = new ChooseProfilePicturePage().Content;
                    Client.OverlayContainer.Visibility = Visibility.Visible;
                }));
                while (!user.Instance.done)
                {
                }
                Login(username, pass, selectedRegion, user);

                return;
            }

            user.Instance.RiotConnection.MessageReceived += user.Instance.OnMessageReceived;
            user.Instance.RiotConnection.Disconnected += user.Instance.RiotConnection_Disconnected;
            user.Instance.GameConfigs = packet.GameTypeConfigs;
            user.Instance.IsLoggedIn = true;


            Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(async () =>
            {
                //MessageBox.Show("Do not play ANY games. I am not sure if they will work ~eddy", "XMPP", MessageBoxButton.OK, MessageBoxImage.Warning);
                Client.StatusContainer.Visibility = Visibility.Visible;
                Client.Container.Margin = new Thickness(0, 0, 0, 40);
                user.Instance.XmppConnection = new agsXMPP.XmppClientConnection("pvp.net", 5223)
                {
                    AutoResolveConnectServer = false,
                    ConnectServer = "chat." + user.Instance.Region.ChatName + ".lol.riotgames.com",
                    Resource = "xiff",
                    UseSSL = true,
                    KeepAliveInterval = 10,
                    KeepAlive = true,
                    UseCompression = true
                };
                user.Instance.XmppConnection.OnMessage += user.Instance.XmppConnection_OnMessage;
                user.Instance.XmppConnection.OnError += user.Instance.XmppConnection_OnError;
                if (switchpage)
                {
                    user.Instance.XmppConnection.OnLogin += (o) =>
                    {
                        Client.Log("Connected to XMPP Server");
                        //Set up chat
                        Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
                        {
                            user.Instance.XmppConnection.Send(invisibleLoginCheckBox.IsChecked != true
                                ? new Presence(ShowType.chat, user.Instance.GetPresence(), 0)
                                {
                                    Type = PresenceType.available
                                }
                                : new Presence(ShowType.NONE, user.Instance.GetPresence(), 0)
                                {
                                    Type = PresenceType.invisible
                                });
                        }));
                    };
                }
                Client.ready = false;
                Client.loadedGroups = false;
                user.Instance.RostManager = new RosterManager(user.Instance.XmppConnection);
                user.Instance.XmppConnection.OnRosterItem += user.Instance.RostManager_OnRosterItem;

                user.Instance.XmppConnection.OnRosterEnd += user.Instance.XmppConnection_OnRosterEnd;
                user.Instance.PresManager = new PresenceManager(user.Instance.XmppConnection);
                user.Instance.XmppConnection.OnPresence += user.Instance.XmppConnection_OnPresence;
                user.Instance.XmppConnection.OnMessage += Client.statusPage.XmppConnection_OnMessage;
                if (!user.Instance.Garena)
                {
                    user.Instance.userpass = new KeyValuePair<string, string>(username,
                        "AIR_" + pass);

                    user.Instance.XmppConnection.Open(username, "AIR_" + pass);

                    //Client.XmppConnection.OnInvalidCertificate += Client.XmppConnection_OnInvalidCertificate;
                }
                else
                {
                    user.Instance.XmppConnection.ConnectServer = "chat" + user.Instance.Region.ChatName + ".lol.garenanow.com";
                    var gas = getGas(user);
                    user.Instance.XmppConnection.Open(user.Instance.UID, "AIR_" + gas);
                    user.Instance.userpass = new KeyValuePair<string, string>(user.Instance.UID, "AIR_" + gas);
                }

                Client.Log("Connected to " + user.Instance.Region.RegionName + " and logged in as " +
                           user.Instance.LoginPacket.AllSummonerData.Summoner.Name);

                PlatformGameLifecycleDTO data = (PlatformGameLifecycleDTO)user.Instance.LoginPacket.ReconnectInfo;
                Client.CurrentUser = packet.AllSummonerData.Summoner.InternalName;
                Client.MainPage = new MainPage();

                if (data != null && data.Game != null)
                {
                    Client.Log(data.PlayerCredentials.ChampionId.ToString(CultureInfo.InvariantCulture));
                    user.Instance.CurrentGame = data.PlayerCredentials;
                    user.Instance.GameType = data.Game.GameType;
                    if (switchpage)
                        Client.SwitchPage(new InGame());
                }
                else if (switchpage)
                {
                    while (!Client.ready)
                    {
                        await Task.Delay(1000);
                    }
                    Client.SwitchPage(Client.MainPage);

                    Client.loadedGroups = true;
                }
                if (switchpage) return;
                var sum = dataLogin[packet.AllSummonerData.Summoner.InternalName + ":" + selectedRegion];
                user.Instance.presenceStatus = sum.ShowType;
                user.Instance.XmppConnection.Send(sum.ShowType == ShowType.NONE
                    ? new Presence(sum.ShowType, user.Instance.GetPresence(), 0) { Type = PresenceType.invisible }
                    : new Presence(sum.ShowType, user.Instance.GetPresence(), 0) { Type = PresenceType.available });
                UserAccount acc = new UserAccount
                {
                    PlayerName = { Content = packet.AllSummonerData.Summoner.InternalName },
                    StatusColour = { Fill = System.Windows.Media.Brushes.Green },
                    ProfileImage =
                    {
                        Source = new BitmapImage(Client.GetIconUri(sum.SumIcon))
                    },
                    RegionLabel = { Content = sum.Region.RegionName },
                    LevelLabel = { Content = packet.AllSummonerData.SummonerLevel.Level },
                    PlayerStatus = { Content = sum.Status }
                };
                foreach (var lgndata in dataLogin.Where(lgndata => lgndata.Key == packet.AllSummonerData.Summoner.InternalName + ":" + selectedRegion))
                {
                    user.Instance.presenceStatus = lgndata.Value.ShowType;
                    user.Instance.XmppConnection.Send(lgndata.Value.ShowType == ShowType.NONE
                        ? new Presence(sum.ShowType, user.Instance.GetPresence(), 0) { Type = PresenceType.invisible }
                        : new Presence(sum.ShowType, user.Instance.GetPresence(), 0) { Type = PresenceType.available });
                }
                switch (user.Instance.presenceStatus)
                {
                    case ShowType.away:
                    case ShowType.dnd:
                    case ShowType.xa:
                        acc.StatusColour.Fill = System.Windows.Media.Brushes.Red;
                        break;
                    case ShowType.NONE:
                        acc.StatusColour.Fill = System.Windows.Media.Brushes.Silver;
                        break;
                }

                user.Instance.userAccount = acc;
                UserListView.Items.Add(acc);
                acc.MouseDown += async (o, e) =>
                {
                    Client.CurrentServer = selectedRegion.Server + ":" + packet.AllSummonerData.Summoner.InternalName;
                    Client.CurrentUser = packet.AllSummonerData.Summoner.InternalName;
                    Client.SwitchPage(Client.MainPage);
                    while (!Client.ready)
                    {
                        await Task.Delay(1000);
                    }
                    Client.loadedGroups = true;
                };
            }));
        }