/*
public interface IAction
{
    void GetAction(Character character);
    void DoNothing(Character character);
    void Attack();
    void HealthPotion();
    Item Items();
}
*/

public sealed class Actions //: IAction
{
    private static readonly Lazy<Actions> _instance = new Lazy<Actions>(() => new Actions());
    private Actions() { }
    public static Actions Instance
    {
        get { return _instance.Value; }
    }

    public void GetAction(Character character)
    {
        /*
        switch (MenuItem.Description)
        {
            
            default:
        }
        */

        while (true)
        {
            var type = character.GetType().ToString();
            switch (type)
            {
                case "Player": PlayerActions(character); break;
                case "Skeleton": MonsterActions(character); break;
                case "UncodedOne": MonsterActions(character); break;
                default:
                    break;
            }
            break;
        }
    }

    public void PlayerActions(Character character) 
    {
        string? action;

        while (true)
        {
            Console.Clear();
            GameState.Instance.DisplayStatus();
            Console.WriteLine($"Current Round: {GameState.Instance.currentRound}");
            Console.WriteLine("\n1. Do Nothing");
            Console.WriteLine("2. Punch");
            if (GameState.Instance.herosAIControl == true)
            {
                action = AIPickAction();
            }
            else
            {
                Console.Write($"\n{character.name}, select an action: ");
                action = Console.ReadLine();
            }
            switch (action)
            {
                case "1": DoNothing(character); break;
                case "2": Punch(character); break;
                default:
                    Console.WriteLine("Sorry, you can't do that..."); 
                    Thread.Sleep(1000);
                    continue;
            }
            break;
        }
    }

    public void MonsterActions(Character character)
    {
        while (true)
        {
            string? action;
            Console.Clear();
            GameState.Instance.DisplayStatus();
            Console.WriteLine($"Current Round: {GameState.Instance.currentRound}");
            if (character.name == "Skeleton")
            {
                Console.WriteLine("\n1. Do Nothing");
                Console.WriteLine("2. Bone Crunch");
                if (GameState.Instance.monstersAIControl == true)
                {
                    action = AIPickAction();
                }
                else
                {
                    Console.Write($"\n{character.name}, select an action: ");
                    action = Console.ReadLine();
                }
                switch (action)
                {
                    case "1": DoNothing(character); break;
                    case "2": BoneCrunch(character); break;
                    default:
                              Console.WriteLine("Sorry, you can't do that..."); 
                              Thread.Sleep(1000);
                              continue;
                }
            }
            if (character.name == "The Uncoded One")
            {
                Console.WriteLine("\n1. Do Nothing");
                Console.WriteLine("2. Unraveling");
                if (GameState.Instance.monstersAIControl == true)
                {
                    action = AIPickAction();
                }
                else
                {
                    Console.Write($"\n{character.name}, select and action: ");
                    action = Console.ReadLine();
                }
                switch (action)
                {
                    case "1": DoNothing(character); break;
                    case "2": Unraveling(character); break;
                    default: Console.WriteLine("Sorry, you can't do that...");
                             Thread.Sleep(1000);
                             continue;
                }
            }
            break;
        }
    }


    public Character SelectTarget(Character character)
    {
        int target;

        while (true)
        {
            if (GameState.Instance.heros.Contains(character))
            {
                Console.WriteLine();
                int number = 1;
                foreach (var monster in GameState.Instance.monsters)
                {
                    Console.WriteLine($"{number}. {monster.name}");
                    number++;
                }
            }
            else if (GameState.Instance.monsters.Contains(character))
            {
                int number = 1;
                Console.WriteLine();
                foreach (var hero in GameState.Instance.heros)
                {
                    Console.WriteLine($"{number}. {hero.name}");
                    number++;
                }
            }
            Console.Write("\nSelect a target: ");
            try
            {
                target = Int32.Parse(Console.ReadLine());
            }
            catch (System.FormatException)
            {
                Console.WriteLine("\nSorry, that's not a valid target...");
                continue;
            }
            try
            {
                if (GameState.Instance.heros.Contains(character))
                {
                    return GameState.Instance.monsters[target - 1];
                }
                else if (GameState.Instance.monsters.Contains(character))
                {
                    return GameState.Instance.heros[target - 1];
                }
            }
            catch (System.ArgumentOutOfRangeException)
            {
                Console.WriteLine("\nSorry, that's not a valid target...");
                continue;
            }
        }
    }

    public void DoNothing(Character character)
    {

        Console.WriteLine($"\n{character.name} does nothing...");
        Thread.Sleep(1000);
    }

    public void Punch(Character character)
    {
        Character target = null;
        if (GameState.Instance.herosAIControl == true)
        {
            target = AIPickTarget(character);
        }
        else
        {
            target = SelectTarget(character);
        }

        Console.WriteLine($"\n{character.name} uses PUNCH on {target.name}!");
        Console.WriteLine($"{target.name} took 1 damage!");
        target.currentHP -= 1;
        Thread.Sleep(1000);
        return;
    }

    public void BoneCrunch(Character character)
    {
        Character target = null;
        if (GameState.Instance.monstersAIControl == true)
        {
            target = AIPickTarget(character);
        }
        else
        {
            target = SelectTarget(character);
        }

        Random random = new Random();
        int coin = random.Next(1, 101);
        Console.WriteLine($"\n{character.name} used Bone Crunch on {target.name}!");
        if (coin > 50)
        {
            Console.WriteLine($"{target.name} took 1 damage!");
            target.currentHP -= 1;
            Thread.Sleep(1000);
            return;
        }
        else
        {
            Console.WriteLine("Nothing happened!");
            Thread.Sleep(1000);
            return;
        }
    }

    public void Unraveling(Character character)
    {
        Character target = null;
        if (GameState.Instance.monstersAIControl == true)
        {
            target = AIPickTarget(character);
        }
        else
        {
            target = SelectTarget(character);
        }
        Random random = new Random();
        Console.WriteLine($"\n{character.name} used Unraveling on {target.name}!");
        int damage = random.Next(3);
        if (damage > 0)
        {
            Console.WriteLine($"{target.name} took {damage} damage!");
            target.currentHP -= damage;
            Thread.Sleep(1000);
            return;
        }
    }

    public Character AIPickTarget(Character character)
    {
        Random random = new Random();
        if (GameState.Instance.heros.Contains(character))
        {
            var lastItem = GameState.Instance.monsters.Count();
            var target = random.Next(1, lastItem + 1);
            return GameState.Instance.monsters[target - 1];
        }
        else 
        {
            var lastItem = GameState.Instance.heros.Count();
            var target = random.Next(1, lastItem + 1);
            return GameState.Instance.heros[target - 1];
        }
    }

    public string AIPickAction()
    {
        Random random = new Random();
        Thread.Sleep(1000);
        return random.Next(1, 3).ToString();
    }
}