private void rev_reversalList_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (rev_reversalList.SelectedIndex < 0)
                {
                    return;
                }

                ReversalMove reversal = (ReversalMove)rev_reversalList.SelectedItem;

                rev_replacementList.Items.Clear();

                //Populate Replacement List
                foreach (Move move in reversal.ReplacementsList)
                {
                    rev_replacementList.Items.Add(move);
                }

                if (rev_replacementList.Items.Count > 0)
                {
                    rev_replacementList.SelectedIndex = 0;
                    rev_replacementList_SelectedIndexChanged(null, null);
                }
            }
            catch (Exception exception)
            {
                L.D("ReversalListIndexChangedError: " + exception);
            }
        }
        private void LoadReversalData()
        {
            try
            {
                String filePath = Path.Combine(saveFolderName, saveFileName);
                if (File.Exists(filePath))
                {
                    using (StreamReader sr = new StreamReader(filePath))
                    {
                        var lines = File.ReadAllLines(filePath);
                        foreach (String line in lines)
                        {
                            ReversalMove move = new ReversalMove();
                            move.LoadReversalData(line);
                            fgrappleMoves.Add(move);
                        }
                    }
                }

                if (fgrappleMoves.Count > 0)
                {
                    rev_moveType_SelectedIndexChanged(null, null);
                }
            }
            catch (Exception e)
            {
                L.D("LoadReversalException: " + e);
            }
        }
        private void rev_reversalAdd_Click(object sender, EventArgs e)
        {
            if (rev_searchResults.SelectedIndex < 0)
            {
                return;
            }

            try
            {
                Move   move = (Move)rev_searchResults.SelectedItem;
                String type = (String)rev_moveType.SelectedItem;
                if (type == MoveType.FGrapple.ToString())
                {
                    //Determine if move already exists
                    if (!CheckMoveUsed(MoveType.FGrapple, move.Name))
                    {
                        ReversalMove reversal = new ReversalMove
                        {
                            ID               = move.ID,
                            Name             = move.Name,
                            Type             = move.Type,
                            ReplacementsList = new List <Move>(),
                        };
                        fgrappleMoves.Add(reversal);

                        //Update control
                        rev_reversalList.Items.Add(reversal);
                    }
                }
                else if (type == MoveType.Corner.ToString())
                {
                    //Determine if move already exists
                    if (!CheckMoveUsed(MoveType.Corner, move.Name))
                    {
                        ReversalMove reversal = new ReversalMove
                        {
                            ID               = move.ID,
                            Name             = move.Name,
                            Type             = move.Type,
                            ReplacementsList = new List <Move>(),
                        };
                        cornerMoves.Add(reversal);

                        //Update control
                        rev_reversalList.Items.Add(reversal);
                    }
                }

                rev_reversalList.SelectedIndex = rev_reversalList.Items.Count - 1;
                rev_reversalList_SelectedIndexChanged(null, null);
            }
            catch (Exception exception)
            {
                L.D("ReversalAddException: " + exception);
            }
        }
        private void rev_removeReplacement_Click(object sender, EventArgs e)
        {
            if (rev_replacementList.SelectedIndex < 0 || rev_reversalList.SelectedIndex < 0)
            {
                return;
            }

            try
            {
                ReversalMove reversal    = (ReversalMove)rev_reversalList.SelectedItem;
                Move         replacement = (Move)rev_replacementList.SelectedItem;
                List <Move>  moves       = reversal.ReplacementsList;
                for (int i = 0; i < moves.Count; i++)
                {
                    if (replacement.Name.Equals(moves[i].Name))
                    {
                        moves.RemoveAt(i);
                        break;
                    }
                }

                //Determine which list to update
                int index;
                if (reversal.Type == MoveType.Corner)
                {
                    index = FindMoveIndex(reversal.Name, cornerMoves);
                    if (index >= 0)
                    {
                        cornerMoves[index].ReplacementsList = moves;
                    }
                }
                else if (reversal.Type == MoveType.FGrapple)
                {
                    index = FindMoveIndex(reversal.Name, fgrappleMoves);
                    if (index >= 0)
                    {
                        fgrappleMoves[index].ReplacementsList = moves;
                    }
                }

                rev_replacementList.Items.RemoveAt(rev_replacementList.SelectedIndex);

                if (rev_replacementList.Items.Count > 0)
                {
                    rev_replacementList.SelectedIndex = rev_replacementList.Items.Count - 1;
                    rev_replacementList_SelectedIndexChanged(null, null);
                }
            }
            catch (Exception exception)
            {
                L.D("RemoveReplacementError: " + exception);
            }
        }
        private void rev_addReplacement_Click(object sender, EventArgs e)
        {
            if (rev_reversalList.SelectedIndex < 0 || rev_searchResults.SelectedIndex < 0)
            {
                return;
            }

            try
            {
                ReversalMove reversal = (ReversalMove)rev_reversalList.SelectedItem;
                Move         move     = (Move)rev_searchResults.SelectedItem;

                //Only add moves if they're the same type as the parent
                if (reversal.Type != move.Type)
                {
                    return;
                }

                if (!CheckReversalUsed(move.Name, reversal.ReplacementsList))
                {
                    int index;
                    if (reversal.Type == MoveType.Corner)
                    {
                        index = FindMoveIndex(reversal.Name, cornerMoves);
                        if (index == -1)
                        {
                            return;
                        }

                        cornerMoves[index].AddReplacement(move);
                    }
                    else if (reversal.Type == MoveType.FGrapple)
                    {
                        index = FindMoveIndex(reversal.Name, fgrappleMoves);
                        if (index == -1)
                        {
                            return;
                        }

                        fgrappleMoves[index].AddReplacement(move);
                    }
                }

                rev_reversalList_SelectedIndexChanged(null, null);
            }
            catch (Exception exception)
            {
                L.D("ReplacementAddException: " + exception);
            }
        }
        private void rev_executor_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (rev_reversalList.SelectedIndex < 0 || rev_replacementList.SelectedIndex < 0)
            {
                return;
            }

            try
            {
                //Save current replacement data
                int          index;
                Move         move     = (Move)rev_replacementList.SelectedItem;
                ReversalMove reversal = (ReversalMove)rev_reversalList.SelectedItem;
                String       type     = (String)rev_executor.SelectedItem;
                move.User = (Executor)Enum.Parse(typeof(Executor), type);

                if (reversal.Type == MoveType.Corner)
                {
                    index = FindMoveIndex(reversal.Name, cornerMoves);
                    if (index < 0)
                    {
                        return;
                    }

                    cornerMoves[index].ReplacementsList[rev_replacementList.SelectedIndex] = move;
                }
                else if (reversal.Type == MoveType.FGrapple)
                {
                    index = FindMoveIndex(reversal.Name, fgrappleMoves);
                    if (index < 0)
                    {
                        return;
                    }

                    fgrappleMoves[index].ReplacementsList[rev_replacementList.SelectedIndex] = move;
                }

                rev_replacementList_SelectedIndexChanged(null, null);
            }
            catch (Exception exception)
            {
                L.D("ExecutorChangedError: " + exception);
            }
        }
        private void rev_reversalRemove_Click(object sender, EventArgs e)
        {
            if (rev_reversalList.SelectedIndex < 0)
            {
                return;
            }

            try
            {
                String       type     = (String)rev_moveType.SelectedItem;
                ReversalMove reversal = (ReversalMove)rev_reversalList.SelectedItem;

                int index;
                if (type == MoveType.FGrapple.ToString())
                {
                    index = FindMoveIndex(reversal.Name, fgrappleMoves);
                    if (index >= 0)
                    {
                        fgrappleMoves.RemoveAt(index);
                    }
                }
                else if (type == MoveType.Corner.ToString())
                {
                    index = FindMoveIndex(reversal.Name, fgrappleMoves);
                    if (index >= 0)
                    {
                        cornerMoves.RemoveAt(index);
                    }
                }

                rev_reversalList.Items.RemoveAt(rev_reversalList.SelectedIndex);

                if (rev_reversalList.Items.Count > 0)
                {
                    rev_reversalList.SelectedIndex = rev_reversalList.Items.Count - 1;
                    rev_reversalList_SelectedIndexChanged(null, null);
                }
            }
            catch (Exception exception)
            {
                L.D("ReversalRemoveException: " + exception);
            }
        }