#50

using System;
using System.Collections.Generic;
using System.Linq;

namespace CarService
{
    public class Program
    {
        static void Main(string[] args)
        {
            AutoService service = new AutoService();
            service.Run();
        }
    }

    public class Detail
    {
        public Detail(string name, decimal price, bool isBroken)
        {
            Name = name;
            Price = price;
            IsBroken = isBroken;
        }

        public string Name { get; private set; }
        public decimal Price { get; private set; }
        public bool IsBroken { get; private set; }
    }

    public class DetailCreator
    {
        private readonly Dictionary<string, Detail> _details;

        public DetailCreator()
        {
            _details = new Dictionary<string, Detail>
            {
                { "Двигатель", new Detail("Двигатель", 5000, false) },
                { "Тормоза", new Detail("Тормоза", 1200, false) },
                { "Фара", new Detail("Фара", 800, false) },
                { "Аккумулятор", new Detail("Аккумулятор", 2500, false) }
            };
        }

        public Detail CreateDetail(string name, bool isBroken = false)
        {
            if (_details.TryGetValue(name, out Detail detail))
            {
                return new Detail(detail.Name, detail.Price, isBroken);
            }
            else
            {
                return null;
            }
        }
    }

    public class DetailStorage
    {
        public DetailStorage(Detail detail, int amount = 1)
        {
            Detail = detail;
            Amount = amount;
        }

        public Detail Detail { get; private set; }
        public int Amount { get; private set; }

        public int RemoveAmount(int amount)
        {
            return Amount -= amount;
        }
    }

    public class Warehouse
    {
        private readonly List<DetailStorage> _partsInStock;

        public Warehouse(DetailCreator detailCreator)
        {
            _partsInStock = new List<DetailStorage>
            {
                new DetailStorage(detailCreator.CreateDetail("Двигатель"), UserUtils.GenerateRandom(10)),
                new DetailStorage(detailCreator.CreateDetail("Тормоза"), UserUtils.GenerateRandom(10)),
                new DetailStorage(detailCreator.CreateDetail("Фара"), UserUtils.GenerateRandom(10)),
                new DetailStorage(detailCreator.CreateDetail("Аккумулятор"), UserUtils.GenerateRandom(10))
            };
        }

        public bool HasPart(string partName)
        {
            return _partsInStock.Any(p => p.Detail.Name == partName && p.Amount > 0);
        }

        public Detail TakePart(string partName)
        {
            DetailStorage storage = _partsInStock.FirstOrDefault(p => p.Detail.Name == partName && p.Amount > 0);

            if (storage != null)
            {
                storage.RemoveAmount(1);
                return new Detail(storage.Detail.Name, storage.Detail.Price, false);
            }

            return null;
        }

        public List<DetailStorage> GetAllParts()
        {
            return _partsInStock;
        }
    }

    public class Car
    {
        private readonly List<Detail> _details;

        public Car(string model, List<Detail> details)
        {
            Model = model;
            _details = details;
        }

        public string Model { get; private set; }

        public List<Detail> GetBrokenParts()
        {
            return _details.Where(detail => detail.IsBroken).ToList();
        }

        public bool IsFullyRepaired()
        {
            return _details.All(d => d.IsBroken == false);
        }

        public bool ReplacePart(Detail newPart)
        {
            for (int i = 0; i < _details.Count; i++)
            {
                if (_details[i].Name == newPart.Name && _details[i].IsBroken)
                {
                    _details[i] = newPart;
                    return true;
                }
            }

            return false;
        }
    }

    public class CarCreator
    {
        private readonly List<Car> _cars;

        public CarCreator(DetailCreator detailCreator)
        {
            _cars = new List<Car>
            {
                CreateCar("Toyota", new List<string> { "Двигатель", "Фара" }, detailCreator),
                CreateCar("Honda", new List<string> { "Аккумулятор" }, detailCreator)
            };
        }

        public List<Car> GetCars()
        {
            return _cars.ToList();
        }

        private Car CreateCar(string model, List<string> brokenParts, DetailCreator detailCreator)
        {
            List<Detail> allDetails = new List<Detail>
            {
                detailCreator.CreateDetail("Двигатель", brokenParts.Contains("Двигатель")),
                detailCreator.CreateDetail("Тормоза", brokenParts.Contains("Тормоза")),
                detailCreator.CreateDetail("Фара", brokenParts.Contains("Фара")),
                detailCreator.CreateDetail("Аккумулятор", brokenParts.Contains("Аккумулятор")),
            };

            return new Car(model, allDetails);
        }
    }

    public class AutoService
    {
        private const decimal RepairFee = 1000;
        private const decimal CancelBeforeRepairFee = 2000;
        private const decimal CancelDuringRepairFeePerPart = 600;

        private readonly CarCreator _carCreator;
        private readonly Warehouse _storage;
        private readonly DetailCreator _detailCreator;
        private readonly Queue<Car> _cars;
        private readonly HashSet<Car> _startedRepairs;

        private decimal _balance;

        public AutoService()
        {
            _detailCreator = new DetailCreator();
            _carCreator = new CarCreator(_detailCreator);
            _storage = new Warehouse(_detailCreator);
            _cars = new Queue<Car>(_carCreator.GetCars());
            _startedRepairs = new HashSet<Car>();
            _balance = UserUtils.GenerateRandom(10000);
        }

        public void Run()
        {
            const string CommandToRepair = "1";
            const string CommandToCancelRepair = "2";
            const string CommandToExit = "3";

            bool isWorking = true;

            while (isWorking && _cars.Count > 0 && _balance > 0)
            {
                Console.Clear();
                ShowServiceStatus();

                Car currentCar = _cars.Peek();

                Console.WriteLine($"\nТекущая машина: {currentCar.Model}");
                ShowBrokenParts(currentCar);

                Console.WriteLine("\nВыберите действие:");
                Console.WriteLine($"{CommandToRepair} - Отремонтировать деталь");
                Console.WriteLine($"{CommandToCancelRepair} - Отказаться от ремонта");
                Console.WriteLine($"{CommandToExit} - Выйти");
                Console.Write("Введите номер команды: ");
                string input = Console.ReadLine();

                switch (input)
                {
                    case CommandToRepair:
                        RepairPart(currentCar, InputPartName());
                        break;

                    case CommandToCancelRepair:
                        CancelRepair(currentCar);
                        break;

                    case CommandToExit:
                        isWorking = false;
                        break;

                    default:
                        Console.WriteLine("Некорректный ввод");
                        break;
                }

                Pause();
            }

            Console.WriteLine("\nРабота сервиса завершена.");
            Console.WriteLine($"Итоговый баланс: {_balance}");
        }

        private void RepairPart(Car car, string partName)
        {
            _startedRepairs.Add(car);

            List<Detail> brokenParts = car.GetBrokenParts();
            Detail targetPart = brokenParts.FirstOrDefault(p => p.Name.Equals(partName, StringComparison.OrdinalIgnoreCase));

            if (targetPart == null)
            {
                Console.WriteLine("Такая деталь не сломана или отсутствует.");
                return;
            }

            if (_storage.HasPart(partName) == false)
            {
                Console.WriteLine($"Нет детали '{partName}' на складые.");
                return;
            }

            Detail replacedPart = _storage.TakePart(partName);

            if (car.ReplacePart(replacedPart))
            {
                decimal income = replacedPart.Price + RepairFee;
                _balance += income;

                Console.WriteLine($"Деталь '{partName}' заменена. Доход: {income}");

                if (car.IsFullyRepaired())
                {
                    Console.WriteLine($"Машина {car.Model} полностью отремонтирована и удалена из очереди.");
                    _cars.Dequeue();
                    _startedRepairs.Remove(car);
                }
            }
        }

        private void CancelRepair(Car car)
        {
            decimal penalty;

            if (_startedRepairs.Contains(car))
            {
                int brokenPartsCount = car.GetBrokenParts().Count;
                penalty = brokenPartsCount * CancelDuringRepairFeePerPart;
                Console.WriteLine($"Отказ от ремонта во время работы. Штраф: {penalty}");
            }
            else
            {
                penalty = CancelBeforeRepairFee;
                Console.WriteLine($"Отказ от ремонта до начала. Штраф: {penalty}");
            }

            _balance -= penalty;
            _cars.Dequeue();
            _startedRepairs.Remove(car);
        }

        private void ShowBrokenParts(Car car)
        {
            List<Detail> brokenParts = car.GetBrokenParts();

            if (brokenParts.Count == 0)
            {
                Console.WriteLine("Все детали исправны.");
            }
            else
            {
                Console.WriteLine("Сломанные детали:");

                foreach (Detail part in brokenParts)
                {
                    Console.WriteLine($"- {part.Name} (Цена: {part.Price})");
                }
            }
        }

        private void ShowServiceStatus()
        {
            Console.WriteLine($"Баланс: {_balance}");
            Console.WriteLine("\nОчередь машин:");

            foreach (Car car in _cars)
            {
                Console.WriteLine($"- {car.Model} (Сломано: {car.GetBrokenParts().Count})");
            }

            Console.WriteLine("\nСклад деталей:");

            foreach (DetailStorage item in _storage.GetAllParts())
            {
                Console.WriteLine($"- {item.Detail.Name}: {item.Amount} шт. (Цена: {item.Detail.Price})");
            }
        }

        private void Pause()
        {
            Console.WriteLine("\nНажмите любую клавишу для продолжения...");
            Console.ReadKey();
        }

        private string InputPartName()
        {
            Console.Write("Введите название детали для ремонта: ");
            string partName = Console.ReadLine();

            return partName;
        }
    }

    class UserUtils
    {
        private static Random s_random = new Random();

        public static int GenerateRandom(int maxValue)
        {
            return s_random.Next(0, maxValue + 1);
        }
    }
}