Program.cs

using System; // Console, DateTime, Random, decimal, object, string
using System.Collections.Concurrent;  // ConcurrentQueue<Operation>
using System.Collections.Generic;  // List<Account>, IEnumerable, Dictionary
using System.Diagnostics;  // Stopwatch
using System.Linq;  // AsParallel(), WithDegreeOfParallelism(), ForAll(), Sum()
using System.Threading;  // Thread.Sleep(), lock
using System.Threading.Tasks;  // ParallelExecutionMode
// https://gist.github.com/sunmeat/13b15075f84cba0765cc8524f6fc6cfa

namespace QuantumBanking
{
    // Типи банківських операцій: внесення, зняття, переказ коштів
    public enum OperationType { Deposit, Withdrawal, Transfer }
    // Статус виконання операції: в обробці, виконано, скасовано
    public enum OperationStatus { Pending, Completed, Cancelled }


    // Банківська операція
    public class Operation(OperationType type, decimal amount,
        Account? fromAccount = null, Account? toAccount = null)
    {
        public OperationType Type { get; } = type;
        public decimal Amount { get; } = amount;
        public Account? FromAccount { get; } = fromAccount;
        public Account? ToAccount { get; } = toAccount;
        public DateTime CreatedAt { get; } = DateTime.Now;
        public OperationStatus Status { get; private set; } =
            OperationStatus.Pending;

        public void SetStatus(OperationStatus status) => Status = status;

        public override string ToString()
        {
            string direction = FromAccount != null && ToAccount != null
                ? $"{FromAccount.Owner.Surname} → {ToAccount.Owner.Surname}"
                : "Операція з одним рахунком";

            return $"{CreatedAt:HH:mm:ss.fff} | {Type,-12} | " +
                $"{Amount,12:C} | {Status,-10} | {direction}";
        }
    }


    // Власник банківського рахунку (клієнт банку)
    public class AccountHolder(string surname, string name, int creditRating)
    {
        public string Surname { get; } = surname;
        public string Name { get; } = name;
        public int CreditRating { get; } = creditRating;
        public DateTime RegistrationDate { get; } = DateTime.Now;

        public override string ToString() => $"{Name} {Surname}";
    }


    // Банківський рахунок з підтримкою потокобезпечних операцій
    public class Account(AccountHolder owner, decimal initialBalance)
    {
        public AccountHolder Owner { get; } = owner;
        public DateTime OpenedAt { get; } = DateTime.Now;
        public DateTime? ClosedAt { get; private set; } = null;
        public decimal Balance { get; private set; } =
            initialBalance > 0 ? initialBalance : 0;

        // Потокобезпечна черга операцій (історія рахунку)
        // https://learn.microsoft.com/en-us/dotnet/api/system.collections.concurrent.concurrentqueue-1?view=net-10.0
        public ConcurrentQueue<Operation> Operations { get; } = new();

        // Об'єкт для синхронізації доступу до балансу (критична секція)
        private readonly Lock _balanceLock = new();

        // Перевірка, чи рахунок наразі активний
        public bool IsActive => ClosedAt == null;

        // Закриття рахунку, після чого операції з ним заборонені
        public void CloseAccount()
        {
            lock (_balanceLock)
            {
                if (ClosedAt == null)
                {
                    ClosedAt = DateTime.Now;
                    Console.WriteLine($"[ЗАКРИТО] Рахунок {Owner.Surname} " +
                        $"закрито о {ClosedAt:HH:mm:ss.fff}");
                }
            }
        }

        // Потокобезпечне поповнення рахунку
        public void Deposit(decimal amount, Operation? operation = null)
        {
            if (amount <= 0 || !IsActive) return;

            lock (_balanceLock)
            {
                Balance += amount;
                operation?.SetStatus(OperationStatus.Completed);
            }
        }

        // Спроба зняття коштів з очікуванням 3 секунди при нестачі коштів
        public bool WithdrawWithWait(decimal amount, Operation operation)
        {
            if (amount <= 0 || !IsActive)
            {
                operation.SetStatus(OperationStatus.Cancelled);
                return false;
            }

            var startTime = DateTime.Now;

            while ((DateTime.Now - startTime).TotalSeconds < 3)
            {
                lock (_balanceLock)
                {
                    if (Balance >= amount)
                    {
                        Balance -= amount;
                        operation.SetStatus(OperationStatus.Completed);
                        return true;
                    }
                }

                // Коротка пауза між перевірками, щоб не завантажувати процесор
                Thread.Sleep(100);
            }

            // Якщо за 3 секунди кошти не надійшли — скасовуємо операцію
            operation.SetStatus(OperationStatus.Cancelled);
            return false;
        }

        // Потокобезпечне отримання поточного балансу
        public decimal GetBalance()
        {
            lock (_balanceLock)
            {
                return Balance;
            }
        }
    }


    // Головний клас банку. Керує рахунками та виконує безпечні перекази
    // з подвійною проводкою
    public class Bank
    {
        public List<Account> Accounts { get; } = [];

        public void AddAccount(Account account) => Accounts.Add(account);

        // Виконує переказ грошей між рахунками з подвійною проводкою.
        // Використовує WithdrawWithWait + Deposit + lock для безпеки.
        public static bool Transfer(Account from, Account to, decimal amount)
        {
            if (from == null || to == null || from == to || amount <= 0)
                return false;

            // Перевірка: рахунки повинні бути активними
            if (!from.IsActive || !to.IsActive)
            {
                Console.WriteLine($"[ПОМИЛКА] Неможливо здійснити переказ: " +
                    $"один з рахунків закритий");
                return false;
            }

            var operation =
                new Operation(OperationType.Transfer, amount, from, to);

            // Спочатку намагаємося списати кошти з рахунку відправника
            // (з очікуванням 3 с)
            bool withdrawn = from.WithdrawWithWait(amount, operation);

            if (withdrawn)
            {
                // Якщо списання вдалося — зараховуємо на рахунок отримувача
                to.Deposit(amount, operation);

                // Подвійна проводка: додаємо одну й ту саму операцію в
                // обидва рахунки
                from.Operations.Enqueue(operation);
                to.Operations.Enqueue(operation);

                Console.WriteLine($"[УСПІШНО] {amount:C} від " +
                    $"{from.Owner.Surname} до {to.Owner.Surname}");
                return true;
            }
            else
            {
                // Операція скасована через недостачу коштів
                from.Operations.Enqueue(operation);
                to.Operations.Enqueue(operation);

                Console.WriteLine($"[СКАСОВАНО] Недостатньо коштів: " +
                    $"{amount:C} з рахунку {from.Owner.Surname}");
                return false;
            }
        }

        // Повертає загальну суму грошей по всіх рахунках (для перевірки 
        // збереження коштів)
        public decimal GetTotalMoney()
        {
            return Accounts.Sum(a => a.GetBalance());
        }
    }


    class Program
    {
        static void Main()
        {
            Console.OutputEncoding = System.Text.Encoding.UTF8;
            var totalSw = Stopwatch.StartNew();

            Console.WriteLine("Банківська система з багатопотоковістю\n");

            var bank = new Bank();
            var rnd = new Random();
            // https://learn.microsoft.com/ru-ru/dotnet/api/system.random?view=net-10.0

            // Створення тестових рахунків
            string[] surnames = { "Петренко", "Іваненко", "Червоненко",
                "Власенко", "Семеренко", "Шевченко", "Ковальчук", "Миронюк" };

            Console.WriteLine("Створення тестових рахунків...");

            foreach (var surname in surnames)
            {
                var holder =
                    new AccountHolder(surname, "Клієнт", rnd.Next(450, 920));
                decimal initialBalance = rnd.Next(10000, 100000);
                bank.AddAccount(new Account(holder, initialBalance));
            }

            decimal initialTotal = bank.GetTotalMoney();
            Console.WriteLine($"Початковий загальний капітал банку: " +
                $"{initialTotal:C}\n");
            // https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings?utm_source=copilot.com

            // Демонстрація закриття рахунку
            var accountToClose = bank.Accounts[2];  // рахунок Червоненка
            accountToClose.CloseAccount();

            // Генерація великої кількості тестових переказів
            var transferRequests = Enumerable.Range(0, 1000)
                // 1000 паралельних переказів
                .Select(_ =>
                {
                    // Вибір двох різних рахунків (from != to)
                    var fromIndex = rnd.Next(bank.Accounts.Count);
                    var toIndex = rnd.Next(bank.Accounts.Count);
                    while (toIndex == fromIndex)
                        toIndex = rnd.Next(bank.Accounts.Count);

                    var from = bank.Accounts[fromIndex];
                    var to = bank.Accounts[toIndex];

                    // 35% переказів — великі суми (для тестування механізму
                    // очікування WithdrawWithWait)
                    // 65% — звичайні перекази
                    decimal amount = rnd.NextDouble() < 0.35
                        ? rnd.Next(5000, 25000)
                        : rnd.Next(100, 5000);

                    return (From: from, To: to, Amount: amount);
                })
                .ToList();

            Console.WriteLine($"Запуск {transferRequests.Count} " +
                $"паралельних переказів за допомогою PLINQ...\n");

            // Визначаємо оптимальну кількість потоків
            // Використовуємо ~75% ядер процесора, але не менше 4
            var degreeOfParallelism =
                Math.Max(Environment.ProcessorCount * 3 / 4, 4);

            Console.WriteLine($"Використовується потоків: " +
                $"{degreeOfParallelism} " +
                $"(з {Environment.ProcessorCount} доступних ядер)\n");

            // Використовуємо PLINQ для паралельного виконання всіх переказів
            // https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/introduction-to-plinq
            // https://learn.microsoft.com/en-us/dotnet/api/system.linq.parallelenumerable.withdegreeofparallelism?view=net-10.0
            transferRequests
                .AsParallel()
                .WithDegreeOfParallelism(degreeOfParallelism)
                // / Примусово запускаємо паралельно
                .WithExecutionMode(ParallelExecutionMode.ForceParallelism)
                // https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/how-to-specify-the-execution-mode-in-plinq
                .ForAll(request =>
                {
                    Bank.Transfer(request.From, request.To, request.Amount);
                });

            Console.WriteLine("\n--- ВСІ ОПЕРАЦІЇ ЗАВЕРШЕНО ---\n");

            decimal finalTotal = bank.GetTotalMoney();

            // Перевірка консервування коштів (сума грошей в банківський
            // системі не повинна змінитися)
            Console.WriteLine($"Початкова сума всіх рахунків: " +
                $"{initialTotal:C}");
            Console.WriteLine($"Фінальна сума всіх рахунків : " +
                $"{finalTotal:C}");
            Console.WriteLine($"Різниця (має бути 0)       : " +
                $"{finalTotal - initialTotal:C}\n");

            // Виведення стану кожного рахунку
            Console.WriteLine("Фінальний стан рахунків:");
            foreach (var account in bank.Accounts.OrderBy(a => a.Owner.Surname))
            {
                var ops = account.Operations.ToList();
                int completed =
                    ops.Count(o => o.Status == OperationStatus.Completed);
                int cancelled =
                    ops.Count(o => o.Status == OperationStatus.Cancelled);

                string status = account.IsActive ? "Активний" : $"Закрито";

                Console.WriteLine($"{account.Owner.Surname,-12} | " +
                                  $"Баланс: {account.GetBalance(),12:C} | " +
                                  $"Статус: {status,-9} | " +
                                  $"Виконано: {completed,3} | " +
                                  $"Скасовано: {cancelled,3}");
            }

            // Статистика за допомогою PLINQ
            var operationStats = bank.Accounts
                .AsParallel()
                .SelectMany(acc => acc.Operations)
                // "Розгортання" всіх операцій з усіх рахунків
                .GroupBy(op => op.Status)
                .ToDictionary(g => g.Key, g => g.Count());
            // https://learn.microsoft.com/en-us/dotnet/api/system.linq.parallelenumerable.selectmany?view=net-10.0
            // https://learn.microsoft.com/en-us/dotnet/api/system.linq.parallelenumerable.todictionary?view=net-10.0

            // Безпечне отримання значень зі словника (якщо статусу немає —
            // повертає 0)
            // https://learn.microsoft.com/en-us/dotnet/api/system.collections.generic.collectionextensions.getvalueordefault?view=net-10.0
            int totalCompleted =
                operationStats.GetValueOrDefault(OperationStatus.Completed, 0);
            int totalCancelled =
                operationStats.GetValueOrDefault(OperationStatus.Cancelled, 0);

            Console.WriteLine($"\nЗагальна статистика операцій:");
            Console.WriteLine($"Виконано переказів : {totalCompleted}");
            Console.WriteLine($"Скасовано переказів: {totalCancelled}");
            Console.WriteLine($"Всього операцій    : {totalCompleted +
                totalCancelled}");

            totalSw.Stop();
            Console.WriteLine($"\nЗагальний час виконання: " +
                $"{totalSw.Elapsed.TotalSeconds:F1} секунд " +
                $"({totalSw.ElapsedMilliseconds} мс)");

            Console.WriteLine("\nНатисніть будь-яку клавішу для завершення...");
            Console.ReadKey();
        }
    }
}