namespace AdventOfCode.Solutions._2022.Day_11
{
    internal class Monkey
    {
        internal int MonkeyId;

        internal int TotalInspections = 0;

        internal List<long> Items;

        internal int TestDevision;
        private int WorryDevision;
        internal int lcm;

        private OperationEnum Operation;

        private long? OperationValue;

        private Monkey ThrowTrueMonkey;
        private Monkey ThrowFalseMonkey;

        /*
           Monkey 0:
           Starting items: 79, 98
           Operation: new = old * 19
           Test: divisible by 23
           If true: throw to monkey 2
           If false: throw to monkey 3
        */
        internal Monkey (int monkeyId,  int worryDivideNumber, string[] monkeyData)
        {
            MonkeyId = monkeyId;
            WorryDevision = worryDivideNumber;

            Items = monkeyData[1].Split(':')[^1].Split(',').Select(s => Convert.ToInt64(s.Trim())).ToList();
            string[] operation = monkeyData[2].Split(' ');
            SetOperation(operation[^2][0], operation[^1]);
            SetTestValue(Convert.ToInt32(monkeyData[3].Split(' ')[^1]));
        }

        internal void DoTurn(bool calcByWorryDivision = true)
        {
            for (int worryIndex = 0; worryIndex < Items.Count; worryIndex++)
            {
                long item = Items[worryIndex];
                item = GetNewWorry(item, calcByWorryDivision);
                ThrowToMonkey(item);
                TotalInspections++;
            }

            Items.Clear();
        }

        internal long GetNewWorry(long oldWorry, bool calcByWorryDivision)
        {
            long secondValue = OperationValue ?? oldWorry;

            switch (Operation)
            {
                case OperationEnum.Add:
                    secondValue = oldWorry + secondValue;
                    break;
                case OperationEnum.Subtract:
                    secondValue = oldWorry - secondValue;
                    break;
                case OperationEnum.Divide:
                    secondValue = oldWorry / secondValue;
                    break;
                case OperationEnum.Multiply:
                    secondValue = oldWorry * secondValue;
                    break;
            }

            if (calcByWorryDivision)
            {
                return secondValue / WorryDevision;
            }

            return secondValue % lcm;

        }

        internal void ThrowToMonkey(long worry)
        {
            if (worry % TestDevision == 0)
            {
                ThrowTrueMonkey.Items.Add(worry);
            }
            else
            {
                ThrowFalseMonkey.Items.Add(worry);
            }

        }

        internal void SetOperation(char operation, string value)
        {
            switch (operation)
            {
                case '+': Operation = OperationEnum.Add;
                    break;
                case '-':
                    Operation = OperationEnum.Subtract;
                    break;
                case '/':
                    Operation = OperationEnum.Divide;
                    break;
                case '*':
                    Operation = OperationEnum.Multiply;
                    break;
            }

            if (!value.Equals("old"))
            {
                OperationValue = Convert.ToInt64(value);
            }
        }

        internal void SetTestValue(int value)
        {
            TestDevision = value;
        }

        internal void SetThrowTargets(Monkey trueMonkey, Monkey falseMonkey)
        {
            ThrowTrueMonkey = trueMonkey;
            ThrowFalseMonkey = falseMonkey;
        }
    }

    internal enum OperationEnum
    {
        Add,
        Subtract,
        Multiply,
        Divide
    }
}