using System;
using System.IO;


namespace AOCD9
{

    // Using struct is important here because we want Points to be a value type. Otherwise it has
    // to be copied when added to a HashSet so it's not added by reference and then later modified.
    public struct Points
    {
        public int PointValue { get; set; }
        public int CoordX { get; set; }
        public int CoordY { get; set; }

        public Points(int pointValue, int coordX, int coordY)
        {
            PointValue = pointValue;
            CoordX = coordX;
            CoordY = coordY;
        }
    }

    public class Program
    {
        public static void Main()
        {

            var stringArray = ConvertInputToStringArray("sample.txt");
            var matrix = SetMatrix(stringArray);
            PrintMatrix(matrix);
            var lowPoints = GetLowPoints(matrix);
            var risk = GetRiskLevel(lowPoints);
            Console.WriteLine($"The risk level is: {risk}");

            foreach (var item in lowPoints)
            {
                Console.Write($"Coordinates of the Low Points {item.PointValue}: ");
                Console.WriteLine(item.CoordX.ToString()+" "+ item.CoordY.ToString());
            }
            var basins = GetBasins(matrix, lowPoints);
            foreach (var basin in basins) {
              Console.WriteLine("Basin points: ");
              foreach (var k in basin) {
                Console.WriteLine($"{k.CoordX}, {k.CoordY}: {k.PointValue}");
              }
            }
            Console.WriteLine();

            var top3 = basins.Select(x => x.Count).OrderByDescending(x => x).Take(3).ToList();
            long finalResult = 1;
            foreach (var item in top3)
            {
                Console.WriteLine($"item: {item}");
                finalResult *= item;
            }
            Console.WriteLine($"Final result is: \t{finalResult}");
        }


        public static string[] ConvertInputToStringArray (string input)
        {
            return File.ReadAllLines(input);
        }

        public static int[,] SetMatrix(string[] input)
        {
            int[,] result = new int[input.GetLength(0), input[0].Length];
            for (int row = 0; row < input.GetLength(0); row++)
            {
                for (int col = 0; col < input[0].Length; col++)
                {
                    result[row, col] = int.Parse(input[row][col].ToString());
                }

            }
            return result;
        }

        public static void PrintMatrix(int[,] matrix)
        {
            for (int row = 0; row < matrix.GetLength(0); row++)
            {
                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    Console.Write(matrix[row,col]);
                }
                Console.WriteLine();
            }
        }

        public static bool CheckLowPoint (int[,] matrix, int x, int y)
        {
            var up = x - 1;
            var down = x + 1;
            var left = y - 1;
            var right = y + 1;
            if (x == 0) up = 1;
            if (y == 0) left = 1;
            if (y == matrix.GetLength(1)-1) right = matrix.GetLength(1) - 2;
            if (x == matrix.GetLength(0)-1) down = matrix.GetLength(0) - 2;


            if (matrix[x, y] < matrix[up, y] &&
                matrix[x, y] < matrix[down, y] &&
                matrix[x, y] < matrix[x, left] &&
                matrix[x, y] < matrix[x, right]
                )
                return true;
            else return false;
        }


        public static void GetLowPointsBasinLeft(HashSet<Points> result, int[,] matrix, int x, int y)
        {
            var left = y - 1;
            if (y > 0)
                left = y - 1;
            else left = y;
            Points curr = new Points(matrix[x, left], x, left);
            while (curr.PointValue != 9 && !result.Contains(curr))
            {
                result.Add(curr);
                GetLowPointsBasinDown(result, matrix, curr.CoordX, curr.CoordY);
                GetLowPointsBasinUp(result, matrix, curr.CoordX, curr.CoordY);

                if (curr.CoordY == 0) break;
                curr.CoordY--;
                curr.PointValue = matrix[curr.CoordX, curr.CoordY];
            }
        }


        public static void GetLowPointsBasinRight(HashSet<Points> result, int[,] matrix, int x, int y)
        {
            var right = y + 1;
            if (y < matrix.GetLength(1) - 1)
                right = y + 1;
            else right = y;

            Points curr = new Points(matrix[x, right], x, right);
            while (curr.PointValue != 9 && !result.Contains(curr))
            {
                result.Add(curr);
                GetLowPointsBasinDown(result, matrix, curr.CoordX, curr.CoordY);
                GetLowPointsBasinUp(result, matrix, curr.CoordX, curr.CoordY);

                if (curr.CoordY == matrix.GetLength(1) - 1) break;
                curr.CoordY++;
                curr.PointValue = matrix[curr.CoordX, curr.CoordY];
            }
        }



        public static void GetLowPointsBasinUp(HashSet<Points> result, int[,] matrix, int x, int y)
        {
            int up = x - 1;
            if (x > 0)
                up = x - 1;
            else up = x;
            Points curr = new Points(matrix[up, y], up, y);
            while (curr.PointValue != 9 && !result.Contains(curr))
            {
                    result.Add(curr);
                    GetLowPointsBasinLeft(result, matrix, curr.CoordX, curr.CoordY);
                    GetLowPointsBasinRight(result, matrix, curr.CoordX, curr.CoordY);

                if (curr.CoordX == 0) break;
                curr.CoordX--;
                curr.PointValue = matrix[curr.CoordX, curr.CoordY];
            }
        }

        public static void GetLowPointsBasinDown(HashSet<Points> result, int[,] matrix, int x, int y)
        {
            int down = x + 1;
            if (x < matrix.GetLength(0) - 1)
                down = x + 1;
            else down = x;
            Points curr = new Points(matrix[down, y], down, y);
            while (curr.PointValue != 9 && !result.Contains(curr))
            {
                    result.Add(curr);
                    GetLowPointsBasinLeft(result, matrix, curr.CoordX, curr.CoordY);
                    GetLowPointsBasinRight(result, matrix, curr.CoordX, curr.CoordY);

                if (curr.CoordX == matrix.GetLength(0) - 1) break;
                curr.CoordX++;
                curr.PointValue = matrix[curr.CoordX, curr.CoordY];
            }
        }

        public static List<HashSet<Points>> GetBasins(int[,] matrix, List<Points> lowPoints)
        {
            List<HashSet<Points>> result = new List<HashSet<Points>>();
            foreach (var point in lowPoints)
            {
                var x = point.CoordX;
                var y = point.CoordY;
                Console.WriteLine($"{x}, {y}");
                HashSet<Points> basin = new HashSet<Points>();
                basin.Add(new Points(matrix[x, y], x, y));

                //--------------- lowpoint basin on the left ------------------------------
                GetLowPointsBasinLeft(basin, matrix, x, y);

                //----------------lowpoint basin on the right------------------------------
                GetLowPointsBasinRight(basin, matrix, x, y);

                //----------------lowpoint basin on up-------------------------------------
                GetLowPointsBasinUp(basin, matrix, x, y);

                //----------------lowpoint basin on down-----------------------------------
                GetLowPointsBasinDown(basin, matrix, x, y);


                result.Add(basin);
            }
            return result;
        }

        public static List<Points> GetLowPoints (int[,] matrix)
        {
            List<Points> list = new List<Points>();
            for (int row = 0; row < matrix.GetLength(0); row++)
            {
                for (int col = 0; col < matrix.GetLength(1); col++)
                {
                    if (CheckLowPoint(matrix, row, col)) list.Add(new Points(matrix[row, col], row, col));
                }
            }
            return list;
        }


        public static int GetRiskLevel (List<Points> list)
        {
            int result = 0;
            foreach (var item in list)
            {
                result += item.PointValue+1;
            }
            return result;
        }

    }
}