OrderSystem

using System;
using System.Collections.Generic;
using Wintellect.PowerCollections;
using System.Text;
using System.Linq;

namespace OrderSystem
{
    class Order : IComparable<Order>
    {
        public Order(string name, double price, string consumer)
        {
            this.Name = name;
            this.Price = price;
            this.Consumer = consumer;
        }

        public string Name
        {
            get;
            private set;
        }
        public double Price
        {
            get;
            private set;
        }
        public string Consumer
        {
            get;
            private set;
        }

        public int CompareTo(Order other)
        {
            int comparisson = string.Compare(this.Name, other.Name, StringComparison.Ordinal);
            return comparisson;
        }

        public override string ToString()
        {
            string result = string.Format("{{{0};{1};{2:##.00}}}", this.Name, this.Consumer, this.Price);
            return result;

        }
    }

    class Program
    {
        private static StringBuilder results;
        private static OrderedBag<Order> ordersByPrice;
        private static Dictionary<string, OrderedBag<Order>> ordersByConsumer;

        static void Main(string[] args)
        {
            results = new StringBuilder();
            ordersByPrice = new OrderedBag<Order>();
            ordersByConsumer = new Dictionary<string, OrderedBag<Order>>();

            int n = int.Parse(Console.ReadLine());

            for (int i = 0; i < n; i++)
            {
                string input = Console.ReadLine();
                string command = GetCommand(input);

                switch (command)
                {
                    case "AddOrder":
                        AddOrder(GetCommandArguments(input));
                        break;
                    case "DeleteOrders":
                        DeleteOrders(GetCommandArguments(input));
                        break;
                    case "FindOrdersByConsumer":
                        FindOrdersByConsumer(GetCommandArguments(input));
                        break;
                    case "FindOrdersByPriceRange":
                        FindOrdersByPriceRange(GetCommandArguments(input));
                        break;
                }
            }

            Console.WriteLine(results);
        }

        private static void FindOrdersByPriceRange(string[] args)
        {
            var minPrice = double.Parse(args[0]);
            var maxPrice = double.Parse(args[1]);

            var range = ordersByPrice.Where(x => x.Price >= minPrice && x.Price <= maxPrice).ToList();
            if (range.Count > 0)
            {
                //foreach (var item in range)
                //{
                //    results.AppendLine(item.ToString());
                //}
                results.AppendLine(string.Join(Environment.NewLine,range));
            }
            else
            {
                results.AppendLine("No orders found");
            }

        }

        private static void FindOrdersByConsumer(string[] args)
        {
            string inputConsumer = args[0];
            if (ordersByConsumer.ContainsKey(inputConsumer) && ordersByConsumer[inputConsumer].Count > 0)
            {
                //foreach (var item in ordersByConsumer[inputConsumer])
                //{
                //    results.AppendLine(item.ToString());
                //}

                results.AppendLine(string.Join(Environment.NewLine,ordersByConsumer[inputConsumer]));
            }
            else
            {
                results.AppendLine("No orders found");
            }
        }

        private static void DeleteOrders(string[] args)
        {
            string inputConsumer = args[0];
            if (ordersByConsumer.ContainsKey(inputConsumer))
            {
                var ordersCount = ordersByConsumer[inputConsumer].Count;
                ordersByConsumer[inputConsumer].Clear();
                ordersByPrice.RemoveAll(x => string.Compare(x.Consumer, inputConsumer, StringComparison.Ordinal) == 0);

                results.AppendLine($"{ordersCount} orders deleted");
            }
            else
            {
                results.AppendLine("No orders found");
            }
        }

        private static void AddOrder(string[] args)
        {
            string inputName = args[0];
            double inputPrice = double.Parse(args[1]);
            string inputConsumer = args[2];

            var newOrder = new Order(inputName, inputPrice, inputConsumer);

            ordersByPrice.Add(newOrder);

            if (!ordersByConsumer.ContainsKey(inputConsumer))
            {
                ordersByConsumer.Add(inputConsumer, new OrderedBag<Order>());
            }
            ordersByConsumer[inputConsumer].Add(newOrder);

            results.AppendLine("Order added");
        }

        private static string GetCommand(string input)
        {
            var args = input.Split();
            return args[0];
        }
        private static string[] GetCommandArguments(string input)
        {
            var args = input.Split(new char[] { ';' });
            var startIndex = args[0].IndexOf(' ');
            args[0] = args[0].Substring(startIndex).Trim();

            return args;
        }
    }
}