using System;

using System.Threading;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Text.RegularExpressions;

using System.Windows.Forms;

​

namespace Rextester

{

    public static class Params

    {

        static public int gameFieldX = 10;

        static public int gameFieldY = 10;

        static public int numberOfMines = 50;

    static public Random rnd;

​

    static public bool firstMoveIsSafe = false;

    static public string failMessage = "BOOM! Wanna start a new game? (Y/N)";

​

    static Params()

    {

        rnd = new Random();

    }

    }

    public class Game

    {

        private List<Mine> mines;

        private Field field;

        int [,] fieldValues;

    int [,] fieldProcessed;

    int numberOfReveals;

    bool shouldRestartGameFirstMoveSafe;

​

    private Point2D cursorPos;

        public Game()

        {

        this.cursorPos = new Point2D(1, 1);

            this.Start();

        }

        public void Start()

        {

            while(true)

            {

        /*Mines generation*/

                GenerateMines();

        this.numberOfReveals = 0;

        this.fieldValues = new int[Params.gameFieldX, Params.gameFieldY];

        this.fieldProcessed = new int[Params.gameFieldX, Params.gameFieldY];

                this.field = new Field();

​

        FillFieldProcessedArrWith0();

                CalculateFieldNumbers();

                field.Draw();

        if(this.shouldRestartGameFirstMoveSafe)

        {

            Console.SetCursorPosition(this.cursorPos.x, this.cursorPos.y);

        }

        else

        {

            Console.SetCursorPosition(1, 1);

        }

        //PrintMines();

        //PrintSolution();  

                var gameResult = true;

                while(true)

                {

            if(this.shouldRestartGameFirstMoveSafe)

            {

                //Simulate SPACE key pressed

                this.shouldRestartGameFirstMoveSafe = false;

                SendKeys.SendWait(" ");

            }

            var userInput = Console.ReadKey(true).Key;

            var newX = this.cursorPos.x;

            var newY = this.cursorPos.y;

            switch(userInput)

            {

                case ConsoleKey.LeftArrow:

                    if(newX - 2 > 0) newX -= 2;

                    break;

                case ConsoleKey.RightArrow:

                    if(newX + 2 < 2 * Params.gameFieldX + 1) newX += 2;

                    break;

                case ConsoleKey.UpArrow:

                    if(newY - 2 > 0) newY -= 2;

                    break;

                case ConsoleKey.DownArrow:

                    if(newY + 2 < 2 * Params.gameFieldY + 1) newY += 2;

                    break;

                case ConsoleKey.Spacebar:

                    gameResult = this.ClickAction(newX, newY);

                    break;

                case ConsoleKey.M:

                    this.MarkMineAction();

                    break;

            }

            this.cursorPos = new Point2D(newX, newY);

            Console.SetCursorPosition(newX, newY);

​

            if(!gameResult)

            {

                break;

            }

            Thread.Sleep(10);

                }

        if(!this.shouldRestartGameFirstMoveSafe)

        {

                    Console.SetCursorPosition(0, 2 * Params.gameFieldY + 2);

                    Console.WriteLine(Params.failMessage);

                    var key = Console.ReadKey(true).Key;

                    if(key != ConsoleKey.Y) break;

        }

            }

        }

    private void FillFieldProcessedArrWith0()

    {

        Console.SetCursorPosition(0, Params.gameFieldY + 2);

        for(int i = 0; i < Params.gameFieldX; i++)

        {

            for(int j = 0; j  < Params.gameFieldY; j++)

            {

                this.fieldProcessed[j, i] = 0;

            }

        }

    }

​

    private void PrintMines()

    {

            Console.WriteLine("Mines");

            for(int i = 0; i < Params.numberOfMines; i++)

                {

                   Console.WriteLine("x: {0}, y:{1}", this.mines[i].location.x /2, this.mines[i].location.y /2);

                }

    }

​

    private void PrintSolution()

    {

                Console.WriteLine("Solution");

            for(int i = 0; i < Params.gameFieldX; i++)

        {

            for(int j = 0; j  < Params.gameFieldY; j++)

            {

                        Console.Write("{0}, ", this.fieldValues[i, j]);

                    }

            Console.Write("\n");

        }

    }

​

    private void CalculateFieldNumbers()

    {

        for(int i = 0; i < Params.gameFieldX; i++)

        {

            for(int j = 0; j  < Params.gameFieldY; j++)

            {

                /*fieldValues buffer is with reular grid size - defined in Params - 

                but mines and cursor position are in extended grid size*/

                this.fieldValues[j, i] = GetNumberOfNearbyMines(2 * j + 1, 2 * i + 1);

            }

        }

    }

    private int GetNumberOfNearbyMines(int x, int y)

    {

        int minesNumber = 0;

        foreach(var mine in this.mines)

        {

            var location = mine.location;

            /*check if it is a mine location*/

            if(x == location.x &&

               y == location.y)

            {

                minesNumber = -1;

                break;

            }

            else

            {

                var mineFound = false;

                for(int k = location.x -2; k <= location.x + 2; k += 2)

                {

                    for(int l = location.y - 2; l <= location.y + 2; l += 2)

                    {

                        if(k == x &&

                           l == y)

                        {

                            mineFound = true;

                        }

                    }

                    if(mineFound) break;

                }

                if(mineFound)

                {

                    minesNumber++;

                }

            }

        }

        return minesNumber;

    }

    private bool ClickAction(int posX, int posY, bool isClickedAuto = false)

    {

        var result = true;

        if(!isClickedAuto)

        {

            this.numberOfReveals++;

        }

​

        if(this.fieldProcessed[posX / 2, posY / 2] == 0)

        {

            this.fieldProcessed[posX / 2, posY / 2] = 1;

​

            /*Check if current position of the cursor is already opened 

            and if it is equal to a position of a mine*/

            Console.SetCursorPosition(posX, posY);

            if(this.fieldValues[posX / 2, posY / 2] == -1 && !isClickedAuto)

            {

                        Console.Write('x');

                if(this.numberOfReveals == 1)

                {

                    this.shouldRestartGameFirstMoveSafe = true;

                }

                result = false;

            }

            else

            {

                var numMines = this.fieldValues[posX / 2, posY / 2];

                if(numMines > 0)

                {

                                Console.Write(numMines);

                }

                else if(numMines == 0)

                {

                    Console.Write('.');

                    for(int i = posX - 2; i <= posX + 2; i += 2)

                    {

                        for(int j = posY - 2; j <= posY + 2; j += 2)

                        {

                            if(i > 0 && 

                               j > 0 && 

                               i <= 2 * Params.gameFieldX && 

                               j <= 2 * Params.gameFieldY)

                            {

                                this.ClickAction(i, j, true);

                            }

                        }

                    }

                }

            }

        }

        return result;

    }

    private void MarkMineAction()

    {

        if(this.fieldProcessed[this.cursorPos.x / 2, this.cursorPos.y / 2] == 0)

        {

            this.fieldProcessed[this.cursorPos.x / 2, this.cursorPos.y / 2] = 1;

        }

    }

        private void GenerateMines()

        {

            this.mines = new List<Mine>();

            for(int i = 0; i < Params.numberOfMines; i++)

            {

                this.mines.Add(new Mine(this.mines));

                //Console.WriteLine("x: {0}, y:{1}", this.mines[i].location.x, this.mines[i].location.y);

            }

        }

    }

    public class Field

    {

    public Field()

    {

    }

        public void Draw()

        {

            ClearField();

            DrawLines();

        }

        private void DrawLines()

        {

            var endYIndex = 2 * Params.gameFieldY + 1;

            var endXIndex = 2 * Params.gameFieldX + 1;

            for(int i = 0; i < endYIndex; i++)

            {

                if(i % 2 == 0)

                {

                    Console.SetCursorPosition(0, i);

                    Console.WriteLine(GetStringRowLength('-'));

                }

                else

                {

                    for(int j = 0; j < endXIndex; j += 2)

                    {

                        Console.SetCursorPosition(j, i);

                        Console.Write('|');

                    }

                }

            }

        }

        private void ClearField()

        {

            for(int i = 0; i < 2 * Params.gameFieldY + 3; i++)

            {

                Console.SetCursorPosition(0, i);

                Console.WriteLine(GetStringRowLength(' '));

            }

        }

        private string GetStringRowLength(char ch)

        {

        var strBuilder = new StringBuilder();

            for(int j = 0; j < 2 * Params.gameFieldX; j++)

            {

                strBuilder.Append(ch);

            }

            return strBuilder.ToString();

        }

    }

    public class Point2D

    {

        public int x;

        public int y;

        public Point2D(int _x, int _y)

        {

            this.x = _x;

            this.y = _y;

        }

    public bool Equals(Point2D other)

    {

        return ((other.x == this.x) &&  (other.y == this.y));

    }

    public Point2D Clone()

    {

        return new Point2D(this.x, this.y);

    }

    }

    public class Mine

    {

        public Point2D location;

        public Mine(List<Mine> existingMines)

        {

            this.location = GetNewMineLocation(existingMines);

        }

        private Point2D GetNewMineLocation(List<Mine> existingMines)

        {

            var x = 0;

            var y = 0;

            while(true)

            {

                x = RandomNumberOdd(1, 2 * Params.gameFieldX);

                y = RandomNumberOdd(1, 2 * Params.gameFieldY);

                var uniqueResult = true;

                foreach(var mine in existingMines)

                {

                   if(mine.location.x == x &&

                      mine.location.y == y)

                   {

                       uniqueResult = false;

                       break;

                   }

                }

                if(uniqueResult) break;

            }

            return new Point2D(x, y);

        }

        private int RandomNumberOdd(int min, int max)

        {

            int ans = Params.rnd.Next(min, max);

            if (ans % 2 == 1) return ans;

            else

            {

                if (ans + 1 <= max)

                    return ans + 1;

                else if (ans - 1 >= min)

                    return ans - 1;

                else return 0;

            }

        }

    }

    public class Program

    {

        public static void Main(string[] args)

        {

            new Game();

        }

    }

}