Program.cs

namespace rummikool;

public class Program {
    private static readonly Random Rng = new();
    private static readonly List<Tile> bag = [];
    private static readonly List<List<Tile>> board = [];

    private static Color ParseColor(char c) => c switch {
        'R' => Color.RED,
        'G' => Color.GREEN,
        'B' => Color.BLUE,
        'Y' => Color.YELLOW,
        'J' => Color.JOKER,
        _ => throw new FormatException($"Invalid color: {c}")
    };

    private static Tile ParseTile(string token) {
        if (token == "J")
            return new Tile(0, Color.JOKER);
        if (token.Length < 2)
            throw new FormatException($"Invalid tile token: {token}");
        Color color = ParseColor(token[0]);
        ushort value = ushort.Parse(token[1..]);
        if (value < 1 || value > 13)
            throw new FormatException($"Invalid tile value: {value}");
        return new Tile(value, color);
    }

    private static Player[] ParseGameFile(string path, List<Tile> bag) {
        if (!File.Exists(path))
            throw new FileNotFoundException(path);
        bag.Clear();
        foreach (Color color in Enum.GetValues<Color>()) {
            for (ushort v = 1; v <= 13; v++) {
                bag.Add(new Tile(v, color));
                bag.Add(new Tile(v, color));
            }
        }
        for (int j = 0; j < 4; j++)
            bag.Add(new Tile(0, Color.JOKER));
        List<Player> players = [];
        foreach (string line in File.ReadAllLines(path)) {
            if (string.IsNullOrWhiteSpace(line))
                continue;
            string[] parts = line.Split(':', 2);
            if (parts.Length != 2)
                throw new FormatException($"Invalid line: {line}");
            string name = parts[0];
            string[] tiles = parts[1].Split(',', StringSplitOptions.RemoveEmptyEntries);
            List<Tile> hand = [];
            foreach (string token in tiles) {
                Tile tile = ParseTile(token.Trim());
                Tile? match = bag.FirstOrDefault(
                    t => t.Value == tile.Value && t.Color == tile.Color)
                    ?? throw new InvalidOperationException($"Tile not available: {token}");
                bag.Remove(match);
                hand.Add(match);
            }
            players.Add(new Player(name, hand));
        }
        return [.. players];
    }

    private static void Shuffle(List<Tile> bag) {
        for (int i = bag.Count - 1; i > 0; i--) {
            int j = Rng.Next(i + 1);
            (bag[i], bag[j]) = (bag[j], bag[i]);
        }
    }

    private static List<Tile> TakeTiles(List<Tile> bag, int count = 14) {
        if (bag.Count < count)
            throw new InvalidOperationException("Not enough tiles in bag.");
        List<Tile> hand = bag.GetRange(0, count);
        bag.RemoveRange(0, count);
        return hand;
    }

    private static Tile? TakeTile(List<Tile> bag) {
        if (bag.Count == 0)
            return null;
        Tile taken = bag[0];
        bag.RemoveAt(0);
        return taken;
    }

    private static void PrintPlayers(Player[] players) {
        foreach (Player player in players) {
            Console.Write($"{player.Name}: ");
            foreach (Tile tile in player.Hand)
                Console.Write($"{tile} ");
            Console.WriteLine();
        }
    }

    private static void PrintBoard(List<List<Tile>> board) {
        foreach (List<Tile> group in board) {
            foreach (Tile tile in group)
                Console.Write($"{tile} ");
            Console.WriteLine();
        }
    }

    public static void Main(string[] args) {
        Player[] players;

        if (args.Length > 1) {
            Console.WriteLine("Error: Invalid arguments.");
            return;
        }
        if (args.Length == 1) {
            try {
                players = ParseGameFile(args[0], bag);
            } catch {
                Console.WriteLine("Error: Failed to parse game file.");
                return;
            }
        } else {
            Console.Write("How many players? (2-4) ");
            int playerCount = Convert.ToInt32(Console.ReadLine());
            if (playerCount < 2 || playerCount > 4) {
                Console.WriteLine("Error: Invalid player count.");
                return;
            }
            foreach (Color color in new[] { Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW }) {
                for (ushort j = 1; j <= 13; j++) {
                    bag.Add(new(j, color));
                    bag.Add(new(j, color));
                }
            }
            for (int j = 0; j < 4; j++)
                bag.Add(new Tile(0, Color.JOKER));
            Shuffle(bag);
            players = new Player[playerCount];
            for (int p = 0; p < playerCount; p++)
                players[p] = new($"P{p + 1}", TakeTiles(bag));
        }
        PrintPlayers(players);

        Console.Write("(Start Game...)");
        Console.ReadLine();
        Player? winner = null;
        int turn = 0;
        while (winner == null) {
            Console.WriteLine(Format.BoldText($"Turn {++turn}:"));
            foreach (Player player in players) {
                Console.WriteLine(Format.BoldText($"{player.Name}'s turn."));
                bool played = player.Initiated
                    ? player.TryPlay(board)
                    : player.TryInitiate(board);
                if (!played) {
                    Tile? drawn = TakeTile(bag);
                    if (drawn != null)
                        player.Hand.Add(drawn);
                }
                PrintPlayers(players);
                PrintBoard(board);
                if (player.Hand.Count == 0) {
                    winner = player;
                    break;
                }
                Console.Write("(Next turn...)");
                Console.ReadLine();
            }
        }
        Console.WriteLine($"Winner: {winner!.Name}");
    }
}