using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace mmoRL
{
    public static class Input
    {
        public static List<ConsoleKeyInfo> pressedKeys = new List<ConsoleKeyInfo>();
        public static bool locked = false;
        public static string enteringString = "";
        public static Player playerAtLocation = null;

        public static void StoreKey(ConsoleKeyInfo key)
        {
            if(!locked)
                pressedKeys.Add(key);
        }

        public static void HandleKeys()
        {
            locked = true;

            for (int i = 0; i < pressedKeys.Count; i++)
            {
                ConsoleKeyInfo key = pressedKeys[i];
                switch (MainClass.mode)
                {
                    case GameMode.Default:
                        CheckMovement(key);
                        CheckActivateChat(key);
                        CheckEnvironmentalActions(key);
                        CheckOpenMenus(key);
                        CheckFastMode(key);
                        break;
                    case GameMode.Chat:
                        CheckEnterString(key);
                        break;
                    case GameMode.Destroying:
                        CheckDirectionEntry(key);
                        break;
                    case GameMode.Inventory:
                    case GameMode.DropItem:
                        CheckMenu(key);
                        break;
                    case GameMode.Crafting:
                    case GameMode.Learning:
                        CheckMenu(key);
                        break;
                    case GameMode.NameEntry:
                    case GameMode.ServerChange:
                    case GameMode.TownEntry:
                    case GameMode.SignEntry:
                        CheckEnterString(key);
                        break;
                    case GameMode.TextScreen:
                        CheckMenu(key);
                        break;
                    case GameMode.Quitting:
                        CheckMenu(key);
                        break;
                    case GameMode.Dead:
                        CheckOpenMenus(key);
                        CheckActivateChat(key);
                        break;
                    case GameMode.LeaveParty:
                        {
                            int result = CheckYesNo(key);
                            if (result == -1) //No
                            {
                                Graphics.SetStatus("Canceled.", true);
                                MainClass.ReturnToMain();
                            }
                            else if (result == 1) //Yes
                            {
                                Graphics.SetStatus("Left the party!", true);
                                MainClass.client.LeaveParty();
                                MainClass.ReturnToMain();
                            }
                        }
                        break;
                    case GameMode.DisbandParty:
                        {
                            int result = CheckYesNo(key);
                            if (result == -1) //No
                            {
                                Graphics.SetStatus("Canceled.", true);
                                MainClass.ReturnToMain();
                            }
                            else if (result == 1) //Yes
                            {
                                Graphics.SetStatus("Disbanded party!", true);
                                MainClass.client.DisbandParty();
                                MainClass.ReturnToMain();
                            }
                        }
                        break;
                    case GameMode.Looking:
                        if (CheckLookAround(key))
                        {
                            MainClass.DescribeLocation(MainClass.lookX, MainClass.lookY);
                        }

                        if (key.Key == ConsoleKey.Escape || key.Key == ConsoleKey.X || key.Key == ConsoleKey.Z || key.Key == ConsoleKey.Enter)
                        {
                            Graphics.SetStatus("", true);
                            MainClass.ReturnToMain();
                        }
                        break;
                    case GameMode.InviteParty:
                        if (CheckLookAround(key))
                        {
                            string msg = "";
                            playerAtLocation = null;

                            foreach (KeyValuePair<int, Player> kp in MainClass.otherPlayers)
                            {
                                Player p = kp.Value;
                                if (p.location == MainClass.player.location)
                                {
                                    if (p.x == MainClass.lookX && p.y == MainClass.lookY)
                                    {
                                        playerAtLocation = p;
                                    }
                                }
                            }

                            if (playerAtLocation != null)
                            {
                                msg = "Invite " + playerAtLocation.name + "?";
                            }

                            if (MainClass.player.x == MainClass.lookX && MainClass.player.y == MainClass.lookY && MainClass.partyMembers.Count > 1)
                            {
                                msg = "Disband party?";
                            }

                            if (msg == "")
                            {
                                if (MainClass.partyMembers.Count <= 1)
                                {
                                    msg = "Who do you want to party up with?";
                                }
                                else
                                {
                                    msg = "Who do you want to invite? (Choose self to disband party.)";
                                }
                            }

                            Graphics.SetStatus(msg);
                        }

                        if (key.Key == ConsoleKey.Escape || key.Key == ConsoleKey.X || key.Key == ConsoleKey.Z)
                        {
                            playerAtLocation = null;
                            if (MainClass.partyMembers.Count <= 1)
                            {
                                MainClass.partyLeader = ""; //Disband one-man party
                            }
                            Graphics.SetStatus("Canceled invitation.", true);
                            MainClass.ReturnToMain();
                        }
                        else if (key.Key == ConsoleKey.Enter)
                        {
                            if (MainClass.lookX == MainClass.player.x && MainClass.lookY == MainClass.player.y && MainClass.partyMembers.Count > 1)
                            {
                                Graphics.SetStatus("Do you wish to disband your party? (Y/N)", true);
                                MainClass.mode = GameMode.DisbandParty;
                            }
                            else if(playerAtLocation != null)
                            {
                                Graphics.SetStatus("Inviting...", true);
                                if (MainClass.partyMembers.Count <= 1)
                                {
                                    MainClass.client.StartParty(playerAtLocation.name);
                                }
                                else
                                {
                                    MainClass.client.InviteToParty(playerAtLocation.name);
                                }
                                MainClass.ReturnToMain();
                            }
                            playerAtLocation = null;
                        }
                        break;
                    case GameMode.IntroScreen:
                        if (key.Key == ConsoleKey.Enter)
                        {
                            MainClass.mode = GameMode.Connecting;
                            Console.Clear();
                            Console.ForegroundColor = ConsoleColor.White;
                            Console.WriteLine("");
                            Console.WriteLine("Connecting...");
                            Console.WriteLine("");
                            try
                            {
                                MainClass.client = new Client(MainClass.host, MainClass.port);
                                MainClass.client.SendVersion();
                            }
                            catch
                            {
                                MainClass.Crash("Could not connect to server.");
                            }
                        }
                        else if (key.Key == ConsoleKey.S)
                        {
                            Input.enteringString = "";
                            MainClass.mode = GameMode.ServerChange;
                        }
                        break;
                    case GameMode.KeyEntry:
                        CheckEnterString(key);
                        break;
                }
            }

            pressedKeys.Clear();

            locked = false;
        }

        public static void CheckMovement(ConsoleKeyInfo key)
        {
            if (!MainClass.actionLock)
            {
                switch (key.Key)
                {
                    case ConsoleKey.NumPad8:
                    case ConsoleKey.D8:
                    case ConsoleKey.UpArrow:
                        MainClass.MoveDirection(0, -1);
                        break;
                    case ConsoleKey.NumPad2:
                    case ConsoleKey.D2:
                    case ConsoleKey.DownArrow:
                        MainClass.MoveDirection(0, 1);
                        break;
                    case ConsoleKey.NumPad4:
                    case ConsoleKey.D4:
                    case ConsoleKey.LeftArrow:
                        MainClass.MoveDirection(-1, 0);
                        break;
                    case ConsoleKey.NumPad6:
                    case ConsoleKey.D6:
                    case ConsoleKey.RightArrow:
                        MainClass.MoveDirection(1, 0);
                        break;
                    case ConsoleKey.D5:
                    case ConsoleKey.NumPad5:
                    case ConsoleKey.OemPeriod:
                        if (!(key.Key == ConsoleKey.OemPeriod && key.Modifiers == ConsoleModifiers.Shift))
                        {
                            MainClass.MoveDirection(0, 0);
                        }
                        break;
                    case ConsoleKey.X:
                        if (MainClass.player.HasSkill(15))
                        {
                            if (MainClass.map.monsters.Count == 0)
                            {
                                int targetX = -1;
                                int targetY = -1;
                                for (int iy = 0; iy < Map.MAP_HEIGHT; iy++)
                                {
                                    for (int ix = 0; ix < Map.MAP_WIDTH; ix++)
                                    {
                                        if (MainClass.map.objects[ix, iy].id == 29)
                                        {
                                            targetX = ix;
                                            targetY = iy;
                                        }
                                    }
                                }

                                if (targetX != -1 && targetY != -1)
                                {
                                    MainClass.MoveTo(targetX, targetY);
                                }
                                else
                                {
                                    Graphics.SetStatus("There is no stairs up here.", true);
                                }
                            }
                            else
                            {
                                Graphics.SetStatus("You can only use this skill in safe areas.", true);
                            }
                        }
                        else
                        {
                            Graphics.SetStatus("You need the 'Return' skill for that.", true);
                        }
                        break;
                    case ConsoleKey.C:
                        if (MainClass.player.HasSkill(14))
                        {
                            if (MainClass.map.monsters.Count == 0)
                            {
                                int targetX = -1;
                                int targetY = -1;
                                for (int iy = 0; iy < Map.MAP_HEIGHT; iy++)
                                {
                                    for (int ix = 0; ix < Map.MAP_WIDTH; ix++)
                                    {
                                        if (MainClass.map.objects[ix, iy].id == 28)
                                        {
                                            targetX = ix;
                                            targetY = iy;
                                        }
                                    }
                                }

                                if (targetX != -1 && targetY != -1)
                                {
                                    MainClass.MoveTo(targetX, targetY);
                                }
                                else
                                {
                                    Graphics.SetStatus("There is no stairs down here.", true);
                                }
                            }
                            else
                            {
                                Graphics.SetStatus("You can only use this skill in safe areas.", true);
                            }
                        }
                        else
                        {
                            Graphics.SetStatus("You need the 'Advance' skill for that.", true);
                        }
                        break;
                }
            }
        }

        public static void CheckDirectionEntry(ConsoleKeyInfo key)
        {
            switch (key.Key)
            {
                case ConsoleKey.UpArrow: MainClass.ChooseDirection(0, -1); break;
                case ConsoleKey.DownArrow: MainClass.ChooseDirection(0, 1); break;
                case ConsoleKey.LeftArrow: MainClass.ChooseDirection(-1, 0); break;
                case ConsoleKey.RightArrow: MainClass.ChooseDirection(1, 0); break;
                case ConsoleKey.OemPeriod:
                case ConsoleKey.D5:
                case ConsoleKey.NumPad5:
                    MainClass.ChooseDirection(0, 0);
                    break;
                case ConsoleKey.Escape:
                case ConsoleKey.X:
                    MainClass.ChooseDirection(0, 0, true);
                    break;
            }
        }

        public static bool CheckLookAround(ConsoleKeyInfo key)
        {
            bool change = false;
            if (key.Key == ConsoleKey.LeftArrow) { MainClass.lookX--; change = true; }
            if (key.Key == ConsoleKey.RightArrow) { MainClass.lookX++; change = true; }
            if (key.Key == ConsoleKey.UpArrow) { MainClass.lookY--; change = true; }
            if (key.Key == ConsoleKey.DownArrow) { MainClass.lookY++; change = true; }
            if (change)
            {
                if (MainClass.lookX < 0) MainClass.lookX = 0;
                if (MainClass.lookX > 69) MainClass.lookX = 69;
                if (MainClass.lookY < 0) MainClass.lookY = 0;
                if (MainClass.lookY > 14) MainClass.lookY = 14;
            }

            return change;
        }

        public static void CheckActivateChat(ConsoleKeyInfo key)
        {
            if (key.Key == ConsoleKey.T) MainClass.ActivateChat();
        }

        public static void CheckEnvironmentalActions(ConsoleKeyInfo key)
        {
            if (!MainClass.actionLock && MainClass.map != null)
            {
                if (key.Modifiers != ConsoleModifiers.Shift)
                {
                    if (key.Key == ConsoleKey.S)
                    {
                        if (MainClass.player.HasSkill(5))
                        {
                            MainClass.StartDestroying();
                        }
                        else
                        {
                            Graphics.SetStatus("You need the Destruction skill to destroy objects.", true);
                        }
                    }
                    else if ((key.Key == ConsoleKey.OemComma && key.Modifiers != ConsoleModifiers.Shift) || key.Key == ConsoleKey.O)
                    {
                        List<Item> toPickUp = new List<Item>();
                        for (int i = 0; i < MainClass.map.items.Count; i++)
                        {
                            Item item = MainClass.map.items[i];
                            if (item.x == MainClass.player.x && item.y == MainClass.player.y)
                            {
                                toPickUp.Add(item);
                            }
                        }

                        if (toPickUp.Count == 0)
                        {
                            Graphics.SetStatus("There is no item to pick up here.", true);
                        }
                        else if (toPickUp.Count == 1)
                        {
                            Graphics.SetStatus("You pick up the " + toPickUp[0].Describe() + ".");
                            MainClass.TakeItem(toPickUp[0], toPickUp[0].x, toPickUp[0].y);
                        }
                        else
                        {
                            List<Item> atYourFeet = MainClass.GetItemsAtPosition(MainClass.player.x, MainClass.player.y);
                            string pickedUp = "";
                            for (int i = 0; i < atYourFeet.Count; i++)
                            {
                                if (i != 0)
                                {
                                    if (i == atYourFeet.Count - 1)
                                    {
                                        pickedUp += " and ";
                                    }
                                    else
                                    {
                                        pickedUp += ", ";
                                    }
                                }
                                pickedUp += atYourFeet[i].Describe();

                            }
                            for (int i = 0; i < toPickUp.Count; i++)
                            {
                                MainClass.TakeItem(toPickUp[i], toPickUp[i].x, toPickUp[i].y);
                            }

                            Graphics.SetStatus("You pick up " + pickedUp + ".");
                        }
                    }
                    else if (key.Key == ConsoleKey.D)
                    {
                        MainClass.mode = GameMode.DropItem;

                        //Convert items
                        List<string> itemNames = new List<string>();
                        List<int> itemIDs = new List<int>();
                        for (int i = 0; i < MainClass.inventory.Count; i++)
                        {
                            itemNames.Add("$pic " + MainClass.inventory[i].Describe());
                            itemIDs.Add(MainClass.inventory[i].id);
                        }
                        if (MainClass.inventory.Count > 0)
                        {
                            Menu.SetupMenu(itemNames.ToArray(), itemIDs.ToArray(),
                                "You are currently carrying the following items:\n ",
                                " \nPress the corresponding key to drop the item.");
                            Menu.numberOfOptions = 9;
                            int displayingAmount = Menu.numberOfOptions;
                            if (MainClass.inventory.Count < displayingAmount) displayingAmount = MainClass.inventory.Count;
                            Graphics.SetStatus("Displaying items " + (Menu.offset + 1) + "-" +
                                (Menu.offset + displayingAmount) + " out of " + MainClass.inventory.Count + ".", true);
                        }
                        else
                        {
                            Menu.SetupMenu(new string[] { "    (You are not carrying any items.)" }, new int[] { -1 },
                                "You are currently carrying the following items:\n ",
                                " \nPress the corresponding key to drop the item.",
                                "");
                            Graphics.SetStatus("You don't have any items.", true);
                        }
                        Menu.active = true;
                    }
                    else if (key.Key == ConsoleKey.R)
                    {
                        switch (MainClass.repeat)
                        {
                            case RepeatType.Craft:
                                bool hasStuff = true;
                                Recipe rec = Crafting.recipes[MainClass.repeatParameter];
                                for (int i = 0; i < rec.materials.Count; i++)
                                {
                                    if (!MainClass.HasItem(rec.materials[i].id, rec.materials[i].amount)) hasStuff = false;
                                }

                                if (hasStuff) Crafting.Craft(rec);
                                else
                                {
                                    Graphics.SetStatus("Not enough materials for another " + rec.name + ".", true);
                                }
                                break;
                            case RepeatType.Use:
                                int foundItem = -1;
                                for (int i = 0; i < MainClass.inventory.Count; i++)
                                {
                                    if (MainClass.inventory[i].id == MainClass.repeatParameter) foundItem = i;
                                }

                                if (foundItem != -1)
                                {
                                    MainClass.UseItem(foundItem);
                                }
                                else
                                {
                                    Graphics.SetStatus("You have none of that item left.", true);
                                }
                                break;
                        }
                    }
                    else if (key.Key == ConsoleKey.L)
                    {
                        MainClass.lookX = MainClass.player.x;
                        MainClass.lookY = MainClass.player.y;
                        MainClass.mode = GameMode.Looking;
                        MainClass.DescribeLocation(MainClass.lookX, MainClass.lookY);
                    }
                    else if (key.Key == ConsoleKey.P)
                    {
                        bool askLeave = true;
                        if (MainClass.map.instanceOwner != "") //If you're in an instance...
                        {
                            Graphics.SetStatus("Cannot form, leave or disband a party while in a dungeon.", true);
                        }
                        else //You're in the overworld
                        {
                            if (MainClass.partyLeader == "")
                            {
                                MainClass.partyMembers.Clear();
                                MainClass.partyMembers.Add(MainClass.player.name);
                                MainClass.partyLeader = MainClass.player.name;
                                MainClass.lookX = MainClass.player.x;
                                MainClass.lookY = MainClass.player.y;
                                MainClass.mode = GameMode.InviteParty;
                                Graphics.SetStatus("Who do you want to party up with?", true);
                                askLeave = false;
                            }
                            else
                            {
                                if (MainClass.partyLeader == MainClass.player.name)
                                {
                                    MainClass.lookX = MainClass.player.x;
                                    MainClass.lookY = MainClass.player.y;
                                    MainClass.mode = GameMode.InviteParty;
                                    Graphics.SetStatus("Who do you want to invite? (Choose self to disband party.)", true);
                                    askLeave = false;
                                }
                            }

                            if (askLeave)
                            {
                                if (MainClass.partyLeader != "")
                                {
                                    Graphics.SetStatus("Do you wish to leave the party? (Y/N), true");
                                    MainClass.mode = GameMode.LeaveParty;
                                }
                            }
                        }
                    }
                    else if (key.Key == ConsoleKey.Enter)
                    {
                        CheckEnterArea();
                    }
                }
                else //Shift
                {
                    if (key.Key == ConsoleKey.OemPeriod || key.Key == ConsoleKey.OemComma) //>, go down/up/inside/outside
                    {
                        CheckEnterArea();
                    }
                }
            }
        }

        public static void CheckEnterArea()
        {
            Object objAtFeet = MainClass.map.objects[MainClass.player.x, MainClass.player.y];
            if (objAtFeet.link != "")
            {
                string status = "You move to a new area.";
                switch (objAtFeet.id)
                {
                    case 27: status = "You enter the cave."; break;
                    case 28: status = "You go down the stairs."; break;
                    case 29: status = "You go up the stairs."; break;
                    case 31:
                        status = "You enter the forest.";
                        MainClass.player.x = 35;
                        MainClass.player.y = 14;
                        MainClass.client.SendPosition(MainClass.player.x, MainClass.player.y, true);
                        break;
                    case 33:
                        status = "You leave the forest.";
                        MainClass.player.x = 21;
                        MainClass.player.y = 0;
                        MainClass.client.SendPosition(MainClass.player.x, MainClass.player.y, true);
                        break;
                    case 34:
                    case 35:
                    case 36:
                    case 37:
                        status = "You move through the forest.";
                        switch(objAtFeet.id)
                        {
                            case 34: MainClass.player.y = 14; break; //North
                            case 35: MainClass.player.y = 0; break; //South
                            case 36: MainClass.player.x = 0; break; //East
                            case 37: MainClass.player.x = 69; break; //West
                        }
                        MainClass.client.SendPosition(MainClass.player.x, MainClass.player.y, true);
                        break;
                    case 39:
                        status = "You walk onto the beach.";
                        MainClass.player.x = 28;
                        MainClass.player.y = 0;
                        MainClass.client.SendPosition(MainClass.player.x, MainClass.player.y, true);
                        break;
                    case 41:
                        status = "You leave the beach.";
                        MainClass.player.x = 60;
                        MainClass.player.y = 12;
                        MainClass.client.SendPosition(MainClass.player.x, MainClass.player.y, true);
                        break;
                    case 42:
                        status = "You leave the area.";
                        MainClass.player.x = 58;
                        MainClass.player.y = 4;
                        MainClass.client.SendPosition(MainClass.player.x, MainClass.player.y, true);
                        break;
                    case 44: status = "You leave the cave."; break;
                }
                Graphics.SetStatus(status);
                MainClass.moveToArea(objAtFeet.link);
            }
            else if (objAtFeet.id == 40)
            {
                Input.enteringString = "";
                MainClass.mode = GameMode.TownEntry;
            }
        }

        public static void CheckEnterString(ConsoleKeyInfo key)
        {
            switch(key.Key)
            {
                case ConsoleKey.Backspace:
                case ConsoleKey.Enter:
                    break;
                case ConsoleKey.Escape:
                    MainClass.EndStringEntry("");
                    break;
                default:
                    string chara = Convert.ToString(key.KeyChar);
                    bool special = true;
                    switch (chara.ToLower())
                    {
                        case "a":
                        case "b":
                        case "c":
                        case "d":
                        case "e":
                        case "f":
                        case "g":
                        case "h":
                        case "i":
                        case "j":
                        case "k":
                        case "l":
                        case "m":
                        case "n":
                        case "o":
                        case "p":
                        case "q":
                        case "r":
                        case "s":
                        case "t":
                        case "u":
                        case "v":
                        case "w":
                        case "x":
                        case "y":
                        case "z":
                        case "0":
                        case "1":
                        case "2":
                        case "3":
                        case "4":
                        case "5":
                        case "6":
                        case "7":
                        case "8":
                        case "9":
                            special = false;
                            break;

                    }
                    if (!(special && (MainClass.mode == GameMode.NameEntry || MainClass.mode == GameMode.KeyEntry || MainClass.mode == GameMode.TownEntry)))
                    {
                        enteringString += chara;
                    }
                    break;
            }
            if (true)//enteringString.Length > 0)
            {
                if (key.Key == ConsoleKey.Backspace)
                {
                    if (enteringString.Length > 0)
                    {
                        enteringString = enteringString.Substring(0, enteringString.Length - 1);
                    }
                }
                else if (key.Key == ConsoleKey.Enter)
                    MainClass.EndStringEntry(enteringString);
            }

        }

        public static void CheckOpenMenus(ConsoleKeyInfo key)
        {
            if (!MainClass.actionLock)
            {
                //INVENTORY
                if (key.Key == ConsoleKey.I)
                {
                    MainClass.mode = GameMode.Inventory;

                    //Convert items
                    List<string> itemNames = new List<string>();
                    List<int> itemIDs = new List<int>();
                    for (int i = 0; i < MainClass.inventory.Count; i++)
                    {
                        Item theItem = MainClass.inventory[i];

                        string suffix = "";
                        if (theItem.type == ItemType.Discovery)
                        {
                            if (!MainClass.player.HasSkill(theItem.parameter1)) suffix = " [!]";
                        }
                        itemNames.Add("$pic " + theItem.Describe() + suffix);
                        itemIDs.Add(theItem.id);
                    }
                    if (MainClass.inventory.Count > 0)
                    {
                        Menu.SetupMenu(itemNames.ToArray(), itemIDs.ToArray(),
                            "You are currently carrying the following items:\n ",
                            " \nPress the corresponding key to use the item, if applicable.");
                        Menu.numberOfOptions = 9;
                        int displayingAmount = Menu.numberOfOptions;
                        if (MainClass.inventory.Count < displayingAmount) displayingAmount = MainClass.inventory.Count;
                        Graphics.SetStatus("Displaying items " + (Menu.offset + 1) + "-" +
                            (Menu.offset + displayingAmount) + " out of " + MainClass.inventory.Count + ".", true);
                    }
                    else
                    {
                        Menu.SetupMenu(new string[] { "    (You are not carrying any items.)" }, new int[] { -1 },
                            "You are currently carrying the following items:\n ",
                            " \nPress the corresponding key to use the item, if applicable.",
                            "");
                        Graphics.SetStatus("You don't have any items.", true);
                    }
                    Menu.active = true;
                }
                //CRAFTING MENU
                else if (key.Key == ConsoleKey.M)
                {
                    if (!MainClass.player.HasSkill(3)) //You need the crafting skill
                    {
                        Graphics.SetStatus("You need the Crafting skill to craft items.", true);
                    }
                    else
                    {
                        MainClass.mode = GameMode.Crafting;

                        List<Recipe> possibleRecipes = Crafting.GetPossibleRecipes();
                        //Convert recipes
                        List<string> recipeDescriptions = new List<string>();
                        List<int> recipeIDs = new List<int>();

                        for (int i = 0; i < possibleRecipes.Count; i++)
                        {
                            string materialString = "";
                            for (int ii = 0; ii < possibleRecipes[i].materials.Count; ii++)
                            {
                                if (ii > 0) materialString += " + ";
                                materialString += possibleRecipes[i].materials[ii].Describe();
                            }

                            string interfix = "";
                            if (possibleRecipes[i].result.type == ItemType.Discovery)
                            {
                                if (!MainClass.player.HasSkill(possibleRecipes[i].result.parameter1)) interfix = " [!] ";
                            }

                            recipeDescriptions.Add("$pic " + possibleRecipes[i].name + interfix + " (" + materialString + ")");
                            recipeIDs.Add(possibleRecipes[i].id);
                        }

                        if (possibleRecipes.Count > 0)
                        {
                            Menu.SetupMenu(recipeDescriptions.ToArray(), recipeIDs.ToArray(),
                                "You can craft the following items:\n ",
                                " \nPress the corresponding key to craft the item.");
                            Menu.numberOfOptions = 9;
                            int displayingAmount = Menu.numberOfOptions;
                            if (possibleRecipes.Count < displayingAmount) displayingAmount = possibleRecipes.Count;
                            Graphics.SetStatus("Displaying items " + (Menu.offset + 1) + "-" +
                                (Menu.offset + displayingAmount) + " out of " + possibleRecipes.Count + ".", true);
                        }
                        else
                        {
                            Menu.SetupMenu(new string[] { "    (Nothing to craft.)" }, new int[] { -1 },
                                "You can craft the following items:\n ",
                                " \nPress the corresponding key to craft the item.",
                                "");
                            Graphics.SetStatus("You don't have the necessary materials to craft anything.", true);
                        }

                        Menu.active = true;
                    }
                }
            }

            //HELP MENU
            if (key.Key == ConsoleKey.H)
            {
                string[] text = new string[] {
"                    mmoRL     ",
"",
"( a more readable version of this document can be found at )",
"(                 http://pastebin.com/UL7Cc7kq             )",
"",
"==INTRODUCTION==============================================",
"",
"mmoRL is a massively multiplayer online roguelike game. You log",
"in to a central server and play together with other players on",
"the server. The overworld is a safe area and everything there",
"happens in realtime, but the dungeons and other non-safe zones",
"are turn-based and unique per player; you will not find other",
"players in your dungeons. However, in the overworld you can choose",
"to party up with other players, and when you are in a party, you",
"will visit the party leader's dungeons instead of your own -",
"together with the other players in your party.",
"",
"==CONTENTS==================================================",
"",
"1. Keybindings",
"2. Beginner tips",
"3. List of skills",
"4. Basic recipes",
"5. List of items",
"",
"==KEYBINDINGS===============================================",
"",
"If a letter is capitalized, that means you need to hold SHIFT.",
"",
"  arrows - move around",
"  up/down - scroll in menus",
"  t - Chat",
"  >/</Enter - Go up/down stairs or enter/leave",
"  ,/o - Pick up item",
"  i - Inventory",
"  L - Learn skill",
"  p - Invite to party/leave party/disband party",
"  Tab - Switch between 'FAST' party mode and 'SLOW' party mode",
"  s - Destroy something (or cut down trees, rocks, etc)",
"  m - Crafting",
"  d - Drop item",
"  ./5 - Wait one turn",
"  r - Repeat last build/craft action",
"  l - Look around",
"  y - View character status",
"  x - Use 'Return' skill",
"  c - Use 'Advance' skill",
"  esc or z - Close menu",
"  q - Quit the game",
"",
"==BEGINNER TIPS=============================================",
"",
" -Simply bump into monsters to attack them.",
"",
" -Contrary to most roguelikes, you do not 'level up' in mmoRL.",
"  Instead, you use your experience to learn new skills, which can",
"  give you new abilities or raise your stats.",
"",
" -You do not recover HP automatically. Learn either the 'Recovery'",
"  or the 'Regeneration' skill in order to restore HP.",
"",
" -If you quit or lose connection, your character remains saved on",
"  the server. You'll be able to continue playing from same location",
"  you disconnected from by entering the same key again when logging",
"  in. However, you will leave the party you are in when you",
"  disconnect.",
"",
" -'Safe zones' are areas with no monsters. They are not turn-based",
"  but realtime, in contrast to non-safe zones.",
"",
" -Death is permanent in this game. Try not to die.",
"",
" -Magic is a useful crafting component. Don't use all of it for",
"  extra experience.",
"",
" -Before you can learn a skill you must first discover it by using",
"  a symbol item. These can usually be obtained through crafting. The",
"  list of recipes give the recipes for some basic symbols.",
"",
" -The forest is a safe area where you can gather some resources.",
"  Be careful not to get lost, though.",
"",
" -Some resources are gathered by destroying objects using the",
"  Destruction skill. For example, destroy a tree to get wood.",
"",
" -To the east you can find the town. When entering it, you type a",
"  town key, and get transported to the (initially empty) area for",
"  that key. As these areas are permanent and shared among all players",
"  who know the key, you can use these areas to store stuff (for if",
"  you die), share things with friends or just to build stuff. A",
"  public area is available using the town key 'public'.",
"",
" -Don't try to solo a dragon. You WILL die.",
"",
"==LIST OF SKILLS============================================",
"",
"Not all skills are listed here, and not all details are listed for",
"each skill. You'll have to figure out the rest on your own!",
"",
"-RECOVERY-",
"Symbol required: None",
"XP cost: 5",
"Heal back to 25 HP when entering a safe area.",
"",
"-REGENERATION-",
"Symbol required: None",
"XP cost: 15",
"Heal 1 HP every turn. Has no effect in safe areas.",
"",
"-CRAFTING-",
"Symbol required: None",
"XP cost: 15",
"Allows you to craft items. Many items will require additional skills",
"to craft, however.",
" Required to craft the following items:",
"  -All craftable items",
"",
"-TOUGHNESS-",
"Symbol required: Symbol of Toughness",
"XP cost: 20",
"Raises your maximum HP by 10.",
"",
"-DESTRUCTION-",
"Symbol required: Symbol of Rage",
"XP cost: 50",
"Allows you to destroy objects. You are unable to destroy objects in",
"certain areas, and some objects are indestructible. Destroying",
"certain objects such as rocks or trees will net you resources such",
"as stones and wood.",
"",
"-CONSTRUCTION-",
"Symbol required: Symbol of Creation",
"XP cost: 10",
"Allows you to craft and place floors and walls. Note that you are",
"unable to build in certain areas, and you cannot build over",
"indestructible objects such as stairs and entrances.",
" Required to craft the following items:",
"  -Wooden Floor",
"  -Wooden Wall",
"  -Stone Floor",
"  -Stone wall",
"  -(More items)",
"",
"-EQUIPMENT CRAFTING-",
"Symbol required: Symbol of the Warrior",
"XP cost: 50",
"Allows you to craft equipment, such as armor and weapons.",
" Required to craft the following items:",
"  -Kobold Armor",
"  -Kobold Helmet",
"  -Kobold Leggings",
"  -Orc-Skin armor",
"  -(More items)",
"",
"-SYNTHESIS-",
"Symbol required: Unknown",
"XP cost: Unknown",
"Allows you to create items from magic.",
" Required to craft the following items:",
"  -Wood",
"  -Stone",
"  -Kobold Scale",
"  -Plantable Tree",
"  -(More items)",
"",
"-LEATHERWORKING-",
"Symbol required: Unknown",
"XP cost: Unknown",
"Allows you to craft leather items.",
" Required to craft the following items:",
"  -Leather",
"  -Leather Armor",
"  -Leather Boots",
"  -Leather Rope",
"  -(More items)",
"",
"==BASIC RECIPES=============================================",
"",
"Some basic recipes. There are many more in the game than just those",
"listed here.",
"",
"-SYMBOL OF TOUGHNESS-",
"Required skills: Crafting",
"Ingredients: 2x Kobold Scale",
"Allows you to learn the skill 'Toughness'.",
"",
"-SYMBOL OF RAGE-",
"Required skills: Crafting",
"Ingredients: 1x Orc Skin",
"Allows you to learn the skill 'Destruction'.",
"",
"-SYMBOL OF CREATION-",
"Required skills: Crafting",
"Ingredients: 2x Wood, 2x Stone",
"Allows you to learn the skill 'Construction'.",
"",
"-STICK-",
"Required skills: Crafting",
"Ingredients: 1x Wood",
"A very basic weapon. Gives +1 strength.",
"",
"-SYMBOL OF THE WARRIOR-",
"Required skills: Crafting",
"Ingredients: 5x Wood",
"Allows you to learn the skill 'Equipment Crafting'.",
"",
"-KOBOLD ARMOR-",
"Required skills: Equipment Crafting",
"Ingredients: 6x Kobold Scale",
"Armor made from Kobold Scales. Gives +1 armor.",
"",
"==LIST OF ITEMS=============================================",
"",
"A full list of obtainable items in the game. Some must be crafted,",
"others must be found.",
"",
"-MATERIALS-",
" -Blue Ink",
" -Blue Plant",
" -Chela",
" -Darkstone",
" -Giant's Arm",
" -Giant's Toe",
" -Green Ink",
" -Green Plant",
" -Kobold Scale",
" -Kobold's Arm",
" -Lavastone",
" -Leather",
" -Leather Rope",
" -Magic",
" -Orc Skin",
" -Orc's Thumb",
" -Red Ink",
" -Red Plant",
" -Sandstone",
" -Stone",
" -White Ink",
" -Wood",
"",
"-SYMBOLS-",
" -Extreme Symbol of the Giant",
" -Extreme Symbol of the Kobold",
" -Extreme Symbol of the Orc",
" -Greater Symbol of the Giant",
" -Greater Symbol of the Kobold",
" -Greater Symbol of the Orc",
" -Symbol of Alchemy",
" -Symbol of Creation",
" -Symbol of Creativity",
" -Symbol of Extreme Toughness",
" -Symbol of Genesis",
" -Symbol of Greater Toughness",
" -Symbol of Progress",
" -Symbol of Rage",
" -Symbol of Return",
" -Symbol of the Giant",
" -Symbol of the Hunt",
" -Symbol of the Kobold",
" -Symbol of the Orc",
" -Symbol of the Warrior",
" -Symbol of Toughness",
"",
"-WEAPONS-",
" -Orcish Spear",
" -Primitive Spear",
" -Stick",
"",
"-ARMOR-",
" -Boots of Water Walking",
" -Enchanted Leather Boots",
" -Kobold Armor",
" -Kobold Helmet",
" -Kobold Leggings",
" -Leather Armor",
" -Leather Boots",
" -Leather Cap",
" -Leather Leggings",
" -Orc-Skin Armor",
" -Orc-Skin Helm",
" -Orc-Skin Leggings",
"",
"-CONSTRUCTION ITEMS-",
" -Blue Floor",
" -Blue Wall",
" -Darkstone Floor",
" -Darkstone Wall",
" -Green Floor",
" -Green Wall",
" -Lavastone Floor",
" -Lavastone Wall",
" -Plantable Tree",
" -Red Floor",
" -Red Wall",
" -Sandstone Floor",
" -Sandstone Wall",
" -Stone Floor",
" -Stone Wall",
" -White Floor",
" -White Wall",
" -Wooden Floor",
" -Wooden Wall"
};
                Menu.TextScreen(text);
            }
            //STATUS MENU
            if (key.Key == ConsoleKey.Y)
            {
                List<string> text = new List<string>();
                text.Add("          STATUS");
                text.Add("");
                text.Add("Name: " + MainClass.player.name);
                text.Add("HP: " + MainClass.player.HP + "/" + MainClass.player.maxHP);
                text.Add("Experience: " + MainClass.player.experience);
                text.Add("Strength: " + MainClass.player.strength);
                text.Add("Armor: " + MainClass.player.armor);
                text.Add("");
                text.Add("Skills");
                text.Add("------");
                for (int i = 0; i < MainClass.player.skills.Count; i++)
                {
                    text.Add(MainClass.player.skills[i].name + " - " + MainClass.player.skills[i].description);
                }
                text.Add("");
                text.Add("Discovered skills");
                text.Add("------");
                for (int i = 0; i < MainClass.player.learnPool.Count; i++)
                {
                    text.Add(MainClass.player.learnPool[i].name + " - " + MainClass.player.learnPool[i].description +
                        " (" + MainClass.player.learnPool[i].expCost + " XP)");
                }

                Menu.TextScreen(text.ToArray());
            }
            //QUIT MENU
            else if (key.Key == ConsoleKey.Q)
            {
                string[] text = new string[]
            {
                "No (cancel)",
                "Yes (quit)",
            };
                int[] results = new int[] { 1, 2, 3 };

                Menu.SetupMenu(text, results,
                    "Do you want to quit?\n ", " \nYour character remains saved on the server (unless you're dead).");
                MainClass.mode = GameMode.Quitting;
                Menu.active = true;
            }
            //Learning menu
            else if (key.Key == ConsoleKey.L && key.Modifiers == ConsoleModifiers.Shift)
            {
                MainClass.mode = GameMode.Learning;

                List<Skill> possibleSkills = MainClass.player.learnPool;
                //Convert recipes
                List<string> skillDescriptions = new List<string>();
                List<int> skillIDs = new List<int>();

                for (int i = 0; i < possibleSkills.Count; i++)
                {
                    skillDescriptions.Add(possibleSkills[i].name + " - " + possibleSkills[i].description + " (" + possibleSkills[i].expCost + " XP)");
                    skillIDs.Add(possibleSkills[i].id);
                }

                if (possibleSkills.Count > 0)
                {
                    Menu.SetupMenu(skillDescriptions.ToArray(), skillIDs.ToArray(),
                        "You can learn the following skills:\n ",
                        " \nPress the corresponding key to learn the skill.");
                    Menu.numberOfOptions = 9;
                    int displayingAmount = Menu.numberOfOptions;
                    if (possibleSkills.Count < displayingAmount) displayingAmount = possibleSkills.Count;
                    Graphics.SetStatus("Displaying items " + (Menu.offset + 1) + "-" +
                        (Menu.offset + displayingAmount) + " out of " + possibleSkills.Count + ".", true);
                }
                else
                {
                    Menu.SetupMenu(new string[] { " (Nothing to learn. Use a Discovery Item to discover new skills.)" }, new int[] { -1 },
                        "You can learn the following skills:\n ",
                        " \nPress the corresponding key to learn the skill.",
                        "");
                    Graphics.SetStatus("No skills to learn.", true);
                }

                Menu.active = true;
            }
        }

        public static void CheckMenu(ConsoleKeyInfo key)
        {
            bool movedList = false;
            bool scrollList = false;
            
            switch (MainClass.mode)
            {
                case GameMode.Inventory:
                case GameMode.DropItem:
                case GameMode.Crafting:
                case GameMode.TextScreen:
                case GameMode.Learning:
                    scrollList = true;
                    break;
            }

            if (key.Key == ConsoleKey.Escape || key.Key == ConsoleKey.X || key.Key == ConsoleKey.Z)
            {
                MainClass.MenuChoice(-1);
            }
            else
            {
                int yourChoice = -1;
                switch (key.Key)
                {
                    case ConsoleKey.A: yourChoice = 0; break;
                    case ConsoleKey.B: yourChoice = 1; break;
                    case ConsoleKey.C: yourChoice = 2; break;
                    case ConsoleKey.D: yourChoice = 3; break;
                    case ConsoleKey.E: yourChoice = 4; break;
                    case ConsoleKey.F: yourChoice = 5; break;
                    case ConsoleKey.G: yourChoice = 6; break;
                    case ConsoleKey.H: yourChoice = 7; break;
                    case ConsoleKey.I: yourChoice = 8; break;
                    case ConsoleKey.J: yourChoice = 9; break;
                    case ConsoleKey.K: yourChoice = 10; break;
                    case ConsoleKey.L: yourChoice = 11; break;
                    case ConsoleKey.M: yourChoice = 12; break;
                    case ConsoleKey.N: yourChoice = 13; break;
                    case ConsoleKey.O: yourChoice = 14; break;

                    case ConsoleKey.DownArrow:
                    case ConsoleKey.OemPlus:
                    case ConsoleKey.Spacebar:
                    case ConsoleKey.Enter:
                    case ConsoleKey.PageDown:
                        if (scrollList)
                        {
                            Menu.offset += Menu.numberOfOptions;
                            movedList = true;
                        }
                        break;
                    case ConsoleKey.UpArrow:
                    case ConsoleKey.OemMinus:
                    case ConsoleKey.PageUp:
                        if (scrollList)
                        {
                            Menu.offset -= Menu.numberOfOptions;
                            movedList = true;
                        }
                        break;
                }

                if (yourChoice != -1)
                {
                    if (Menu.numberOfOptions > yourChoice)
                    {
                        MainClass.MenuChoice(Menu.offset + yourChoice);
                    }
                }
            }

            if (movedList)
            {
                if (Menu.offset < 0) Menu.offset = 0;

                switch(MainClass.mode)
                {
                    case GameMode.Inventory:
                    case GameMode.DropItem:
                    case GameMode.Crafting:
                    case GameMode.Learning:
                        {
                            if (Menu.offset > Menu.options.Count - 1) Menu.offset = Menu.options.Count - 1;

                            int displayingAmount = Menu.numberOfOptions;
                            if (Menu.offset + displayingAmount > Menu.options.Count) displayingAmount = Menu.options.Count - Menu.offset;

                            Graphics.SetStatus("Displaying items " + (Menu.offset + 1) + "-" +
                                    (Menu.offset + displayingAmount) + " out of " + Menu.options.Count + ".", true);
                        }
                    break;
                }
            }
        }

        public static int CheckYesNo(ConsoleKeyInfo key)
        {
            if (key.Key == ConsoleKey.Y) return 1;
            if (key.Key == ConsoleKey.N) return -1;
            return 0; //No result
        }

        public static void CheckFastMode(ConsoleKeyInfo key)
        {
            if (key.Key == ConsoleKey.Tab)
            {
                MainClass.client.ToggleFastMode();
            }
        }

    }
}