// Create a new Game of Life with a 50x25 grid
// Why: Initializes the game with a specific grid size to define the simulation area.
GameOfLife game = new(50, 25);

StatisticsCalculator statisticsCalculator = new(game);

// Initialize with a glider pattern
// Why: Sets a known pattern to observe its behavior in the simulation.
game.SetPattern([(1, 0), (2, 1), (0, 2), (1, 2), (2, 2)]);

// Initialize with a random pattern
// Why: Optionally randomizes the initial state to introduce variability.
//game.InitializeRandomly(0.1);

// Run the simulation for 100 generations
// Why: Iterates through a fixed number of generations to observe the evolution of the grid.
for (int i = 0; i < 100; i++)
{
    Console.Clear();

    // Why: Clears the console to display the updated grid for the current generation.
    PrintGrid(game.GetCurrentState());

    Console.WriteLine($"Generation {i}");

    // Display statistics using LINQ
    // Why: Retrieves and displays statistics to provide insights into the current state of the grid.
    GameStatistics statistics = statisticsCalculator.GetStatistics();

    Console.WriteLine($"Population: {statistics.PopulationCount}");

    Console.WriteLine($"Changing cells: {statistics.ChangingCells}");

    // Why: Advances the simulation to the next generation to continue the evolution.
    game.AdvanceGeneration();

    // Why: Introduces a delay to control the speed of the simulation for better visualization.
    await Task.Delay(75).ConfigureAwait(false);
}

static void PrintGrid(bool[][] grid)
{
    int width = grid.Length;
    int height = grid[0].Length;

    // Why: Iterates through the grid to print its current state for visualization.
    for (int y = 0; y < height; y++)
    {
        for (int x = 0; x < width; x++)
        {
            Console.Write(grid[x][y] ? "■" : "·");
        }

        Console.WriteLine();
    }
}

namespace ConwaysGameOfLife;

/// <summary>
/// A game of life abstraction.
/// </summary>
internal sealed class GameOfLife(int width, int height)
{
    /// <summary>
    /// Live cells
    /// </summary>
    /// <value cref="HashSet{T}">HashSet&lt;(int x, int y)&gt;</value>
    // Why: Stores the coordinates of live cells to track the state of the grid.
    public HashSet<(int x, int y)> LiveCells { get; set; } = [];

    // Why: Defines the height of the grid to set the vertical boundaries.
    private int GridHeight { get; } = height;

    // Why: Defines the width of the grid to set the horizontal boundaries.
    private int GridWidth { get; } = width;

    /// <summary>
    /// Advances the simulation by one generation to observe the evolution of the grid.
    /// </summary>
    public void AdvanceGeneration()
    {
        // Why: Identifies all relevant cells to evaluate for the next generation.
        IEnumerable<(int x, int y)> cellsToEvaluate = LiveCells
            .SelectMany(GetAllNeighbors)
            .Concat(LiveCells)
            .Distinct();

        // Why: Applies Conway's rules to determine the state of each cell in the next generation.
        LiveCells = [.. cellsToEvaluate
            .Select(cell => new
            {
                Cell = cell,
                IsAlive = LiveCells.Contains(cell),
                Neighbors = CountLiveNeighbors(cell)
            })
            .Where(info =>
                (info.IsAlive && (info.Neighbors == 2 || info.Neighbors == 3)) ||
                (!info.IsAlive && info.Neighbors == 3))
            .Select(info => info.Cell)];
    }

    /// <summary>
    /// Counts how many live neighbors a cell has to apply Conway's rules.
    /// </summary>
    /// <param name="cell">The cell to count neighbors for.</param>
    /// <returns>The number of live neighbors.</returns>
    public int CountLiveNeighbors((int x, int y) cell) => GetAllNeighbors(cell).Count(LiveCells.Contains);

    /// <summary>
    /// Finds all cells that will change in the next generation to track dynamic behavior.
    /// </summary>
    /// <returns>A set of coordinates for cells that will change.</returns>
    public HashSet<(int x, int y)> GetChangingCells()
    {
        IEnumerable<(int x, int y)> cellsToCheck = LiveCells
            .SelectMany(GetAllNeighbors)
            .Concat(LiveCells)
            .Distinct();

        // Why: Identifies cells that will change state in the next generation to understand dynamic changes.
        return [.. cellsToCheck
            .Where(cell =>
            {
                int neighbors = CountLiveNeighbors(cell);
                bool isAlive = LiveCells.Contains(cell);

                return (isAlive && neighbors != 2 && neighbors != 3) || (!isAlive && neighbors == 3);
            })];
    }

    /// <summary>
    /// Returns the current state as a jagged array of booleans for visualization.
    /// </summary>
    /// <returns>A jagged array representing the current state of the grid.</returns>
    public bool[][] GetCurrentState()
    {
        bool[][] state = new bool[GridWidth][];

        for (int x = 0; x < GridWidth; x++)
        {
            state[x] = new bool[GridHeight];
        }

        // Why: Converts the set of live cells into a jagged array for easy visualization.
        foreach ((int x, int y) in LiveCells)
        {
            state[x][y] = true;
        }

        return state;
    }

    /// <summary>
    /// Randomizes the grid to introduce variability in the initial state.
    /// </summary>
    /// <param name="probability">The probability of each cell being alive.</param>
    public void InitializeRandomly(double probability = 0.3)
    {
        using RandomNumberGenerator rng = RandomNumberGenerator.Create();

        byte[] randomNumber = new byte[4];

        LiveCells = [.. Enumerable
            .Range(0, GridWidth)
            .SelectMany(x => Enumerable.Range(0, GridHeight).Select(y => (x, y)))
            .Where(_ =>
            {
                rng.GetBytes(randomNumber);

                return BitConverter.ToUInt32(randomNumber, 0) / (double)uint.MaxValue < probability;
            })];
    }

    /// <summary>
    /// Sets a specific pattern of live cells to start the simulation with a known configuration.
    /// </summary>
    /// <param name="pattern">The pattern of live cells to set.</param>
    public void SetPattern(IEnumerable<(int x, int y)> pattern) =>
        LiveCells = [.. pattern.Where(pos => pos.x >= 0 && pos.x < GridWidth && pos.y >= 0 && pos.y < GridHeight)];

    /// <summary>
    /// Gets all eight potential neighbors of a cell to determine its next state.
    /// </summary>
    /// <param name="cell">The cell to get neighbors for.</param>
    /// <returns>An enumerable of neighboring cell coordinates.</returns>
    private IEnumerable<(int x, int y)> GetAllNeighbors((int x, int y) cell)
    {
        int cellX = cell.x;
        int cellY = cell.y;

        // Why: Generates the coordinates of all potential neighbors to evaluate their states.
        return Enumerable
            .Range(-1, 3)
            .SelectMany(dx =>
            {
                int newX = cellX + dx;
                return Enumerable.Range(-1, 3).Select(dy => (newX, cellY + dy));
            })
            .Where(pos => pos != cell && pos.newX >= 0 && pos.newX < GridWidth && pos.Item2 >= 0 && pos.Item2 < GridHeight);
    }
}

namespace ConwaysGameOfLife;

/// <summary>
/// A class to calculate statistics for the Game of Life.
/// </summary>
internal sealed class StatisticsCalculator(GameOfLife game)
{
    /// <summary>
    /// Game of life
    /// </summary>
    /// <value cref="GameOfLife">GameOfLife</value>
    internal GameOfLife GameOfLife { get; } = game;

    /// <summary>
    /// Gets statistics about the current generation to analyze the state of the grid.
    /// </summary>
    /// <returns>A GameStatistics object containing various metrics.</returns>
    public GameStatistics GetStatistics()
    {
        Dictionary<int, int> cellsByNeighborCount = GameOfLife.LiveCells
            .Select(GameOfLife.CountLiveNeighbors)
            .GroupBy(count => count)
            .ToDictionary(
                group => group.Key,
                group => group.Count()
            );

        // Why: Provides various metrics to analyze the current state of the grid.
        return new GameStatistics
        {
            PopulationCount = GameOfLife.LiveCells.Count,
            AverageNeighbors = GameOfLife.LiveCells.Count != 0
                ? GameOfLife.LiveCells.Average(GameOfLife.CountLiveNeighbors)
                : 0,
            NeighborDistribution = cellsByNeighborCount,
            ChangingCells = GameOfLife.GetChangingCells().Count,
            StablePatternCount = new PatternDetector(GameOfLife).IdentifyStablePatterns()
        };
    }
}

namespace ConwaysGameOfLife;

/// <summary>
/// A game statistics abstraction.
/// </summary>
internal sealed class GameStatistics
{
    /// <summary>
    /// Gets or sets the average number of neighbors per live cell to analyze cell density.
    /// </summary>
    public double AverageNeighbors { get; set; }

    /// <summary>
    /// Gets or sets the number of cells that will change state in the next generation to track dynamic changes.
    /// </summary>
    public int ChangingCells { get; set; }

    /// <summary>
    /// Gets or sets the distribution of live cells by their neighbor count to understand the spread of cells.
    /// </summary>
    public required Dictionary<int, int> NeighborDistribution { get; set; }

    /// <summary>
    /// Gets or sets the total number of live cells to understand the population size.
    /// </summary>
    public int PopulationCount { get; set; }

    /// <summary>
    /// Gets or sets the count of stable patterns detected to identify static structures.
    /// </summary>
    public int StablePatternCount { get; set; }
}

namespace ConwaysGameOfLife;

/// <summary>
/// A class to detect patterns in the Game of Life.
/// </summary>
internal sealed class PatternDetector(GameOfLife game)
{
    /// <summary>
    /// Game of life
    /// </summary>
    /// <value cref="GameOfLife">GameOfLife</value>
    internal GameOfLife GameOfLife { get; } = game;

    /// <summary>
    /// Detects common stable patterns like blocks, beehives, etc., to identify static structures.
    /// </summary>
    /// <returns>The count of detected stable patterns.</returns>
    public int IdentifyStablePatterns()
    {
        // Common patterns (relative coordinates)
        Dictionary<string, HashSet<(int, int)>> patterns = new(2)
    {
        {
            "Block", new HashSet<(int, int)> { (0, 0), (0, 1), (1, 0), (1, 1) }
        },
        {
            "Beehive", new HashSet<(int, int)> { (0, 1), (0, 2), (1, 0), (1, 3), (2, 1), (2, 2) }
        }
    };

        HashSet<(int x, int y)> liveCells = GameOfLife.LiveCells;

        // Why: Identifies known stable patterns to understand static structures in the grid.
        return liveCells.SelectMany(cell => patterns.Where(pattern => VerifyPattern(pattern.Value, cell))
            .Select(pattern => pattern.Key))
            .Count();
    }

    /// <summary>
    /// Checks if a specific pattern exists at the given coordinates to identify known structures.
    /// </summary>
    /// <param name="pattern">The pattern to check for.</param>
    /// <param name="anchor">The anchor coordinates to check from.</param>
    /// <returns>True if the pattern exists at the given coordinates, otherwise false.</returns>
    private bool VerifyPattern(HashSet<(int, int)> pattern, (int x, int y) anchor)
    {
        int anchorX = anchor.x;
        int anchorY = anchor.y;

        HashSet<(int x, int y)> liveCells = GameOfLife.LiveCells;

        // Why: Verifies the presence of a specific pattern at given coordinates to identify structures.
        return pattern.All(offset => liveCells.Contains((anchorX + offset.Item1, anchorY + offset.Item2)));
    }
}