using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using Tanshu.Accounts.Contracts;
using Tanshu.Accounts.Entities;
using Tanshu.Accounts.Helpers;
using Tanshu.Accounts.Print;
using Tanshu.Accounts.Repository;
using Tanshu.Common;
using System;

namespace Tanshu.Accounts.PointOfSale
{
    public class BillController
    {
        public readonly BillDict _bill;
        public Voucher _voucher;
        public Guid? _editVoucherID;

        public BillController(Guid? editVoucherID)
        {
            this._editVoucherID = editVoucherID;
            _bill = new BillDict();
            using (var bi = new CustomerBI())
                _voucher = new Voucher(Session.User, bi.Get(x => x.CustomerID == Constants.CASH_CUSTOMER));
        }

        public void AddProduct(Product product)
        {
            var newKey = new BillItemKey(product.ProductID, Guid.Empty, product.HasHappyHour);

            if (_bill.ContainsKey(newKey))
            {
                _bill[newKey].inventory.Quantity += 1;
            }
            else
            {
                var billItemValue = new BillItemValue(product, product.HasHappyHour);
                var old = _bill.FirstOrDefault(x => x.Key.BillItemType == (product.HasHappyHour ? BillItemType.HappyHourProduct : BillItemType.RegularProduct) && x.Key.ProductID == newKey.ProductID);
                if (old.Key != null)
                {
                    billItemValue.inventory.Discount = old.Value.inventory.Discount;
                    billItemValue.inventory.Price = old.Value.inventory.Price;
                }
                _bill.Add(newKey, billItemValue);
            }
        }

        public void ShowModifiers(BillItemValue item)
        {
            using (var frm = new ModifierForm(Cache.ProductGroupModifiers(item.inventory.Product.ProductGroup.ProductGroupID), item.inventory.InventoryModifier))
            {
                frm.ShowDialog();
            }
        }
        public void SetDiscount()
        {
            if (!Session.IsAllowed("Discount"))
                return;

            using (var bi = new ProductGroupBI())
            {
                using (var frm = new DiscountForm(bi.GetProductGroupTypes()))
                {
                    if (frm.ShowDialog() == DialogResult.OK)
                    {
                        HashSet<string> outList;
                        var discount = frm.Selection(out outList);
                        discount = discount / 100;
                        if (discount > 1 || discount < 0)
                            return;

                        foreach (var item in _bill.Where(x => x.Key.BillItemType != BillItemType.Kot && outList.Contains(x.Value.inventory.Product.ProductGroup.GroupType)))
                        {
                            var product = item.Value.inventory.Product;
                            var maxDiscount = product.ProductGroup.DiscountLimit;
                            if (discount > item.Value.inventory.Product.ProductGroup.DiscountLimit)
                                MessageBox.Show(string.Format("Maximum discount for {0} is {1:P}", product.Name, maxDiscount),
                                                "Excessive Discount", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                            item.Value.inventory.Discount = discount;
                        }
                    }
                }
            }
        }
        public void SetQuantity(BillItemKey key, BillItemValue item, decimal quantity, bool prompt)
        {
            if (item == null || key.KotID != Guid.Empty)
                return; // No Product or Old Product
            if (prompt && !GetInput("Quantity", ref quantity))
                return;
            if (!prompt)
                quantity += item.inventory.Quantity;
            if (quantity < 0 && !Session.IsAllowed("Edit Printed Product"))
                return;
            var old = _bill.Where(x => x.Key.ProductID == key.ProductID && x.Key.KotID != Guid.Empty && x.Key.BillItemType == key.BillItemType).Sum(x => x.Value.inventory.Quantity);
            quantity = Math.Max(quantity, -1 * old);
            item.inventory.Quantity = quantity;
        }
        public void SetPrice(BillItemValue item)
        {
            if (item.inventory.IsHappyHour)
                return;
            if (!Session.IsAllowed("Change Rate"))
                return;
            var price = item.inventory.Price;
            if (!GetInput("Price", ref price))
                return;
            if (price == 0 && !Session.IsAllowed("NC Product"))
                throw new PermissionException("NC of Product is not Allowed");
            foreach (var sub in _bill.Where(x => x.Key.BillItemType != BillItemType.Kot && x.Key.ProductID == item.inventory.Product.ProductID))
                sub.Value.inventory.Price = price;
        }
        public void ShowCustomers()
        {
            using (var frm = new CustomerListForm())
            {
                frm.ShowDialog();
                _voucher.Customer = frm.SelectedItem;
            }
        }
        private static bool IsPrintedOrVoid(Voucher voucher)
        {
            using (var bi = new VoucherBI())
            {
                var dbVoucher = bi.Get(x => x.VoucherID == voucher.VoucherID);
                return dbVoucher.Printed || dbVoucher.Void;
            }
        }
        private static bool IsPrintedOrVoid(Guid voucherID)
        {
            using (var bi = new VoucherBI())
            {
                var dbVoucher = bi.Get(x => x.VoucherID == voucherID);
                return dbVoucher.Printed || dbVoucher.Void;
            }
        }
        private void InputBox_Validating(object sender, InputBoxValidatingArgs e)
        {
        }
        private void LoadBill(Guid voucherID)
        {
            using (var bi = new VoucherBI())
            {
                _voucher = bi.Get(x => x.VoucherID == voucherID);
                _bill.Load(_voucher);
                var newKotKey = new BillItemKey(Guid.Empty);
                var newKotItem = new BillItemValue();
                _bill.Add(newKotKey, newKotItem);
            }
        }
        public void LoadBill(string tableName)
        {
            FoodTable table;
            using (var bi = new FoodTableBI())
                table = bi.Get(x => x.Name == tableName);
            if (table != null && table.VoucherID.HasValue)
            {
                LoadBill(table.VoucherID.Value);
            }
            else
            {
                using (var frm = new PaxForm())
                {
                    frm.ShowDialog();
                    _voucher.Table = table;
                    _voucher.Pax = frm.Pax;
                }
            }
        }

        public bool CancelBillChanges()
        {
            if (_bill.Any(x => x.Key.BillItemType != BillItemType.Kot && x.Key.KotID == Guid.Empty) &&
                MessageBox.Show("Abandon Changes?", "Abandon Changes", MessageBoxButtons.YesNo,
                                MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.No)
                return false;
            ClearBill();
            return true;
        }
        private void ClearBill()
        {
            using (var bi = new CustomerBI())
                _voucher = new Voucher(Session.User, bi.Get(x => x.CustomerID == Constants.CASH_CUSTOMER));
            _bill.Clear();
            var newKotKey = new BillItemKey(Guid.Empty);
            var newKotItem = new BillItemValue();
            _bill.Add(newKotKey, newKotItem);
        }
        public SaleFormState FormLoad()
        {
            ClearBill();
            if (_editVoucherID.HasValue)
            {
                FoodTable ft;
                using (var bi = new FoodTableBI())
                    ft = bi.Get(x => x.VoucherID == _editVoucherID.Value);
                LoadBill(_editVoucherID.Value);
                if (ft != null)
                    _editVoucherID = null;
                return SaleFormState.Billing;
            }
            return SaleFormState.Waiting;
        }
        internal bool SettleBill()
        {
            if (_voucher.VoucherID == Guid.Empty || !_voucher.Printed || !Session.IsAllowed("Settle Bill"))
                return false;
            IDictionary<SettleOption, decimal> options;
            var amount = -1 * _voucher.Kots.Sum(x => x.Inventories.Sum(y => y.Amount));
            using (var frm = new SettleChoicesForm(Math.Round(amount) * -1, _voucher.VoucherType))
            {
                frm.ShowDialog();
                options = frm.OptionsChosen;
            }
            if (options.Count == 0)
                return false;
            using (var bi = new VoucherBI())
            {
                bi.SettleVoucher(Session.User, _voucher.VoucherID, options);
                if (!_editVoucherID.HasValue)
                    bi.UpdateTable(x => x.FoodTableID == _voucher.Table.FoodTableID && x.VoucherID == _voucher.VoucherID, null, null);
                bi.SaveChanges();
            }
            ClearBill();
            return true;
        }

        #region Move Table(s) / Kot(s)
        private static FoodTable GetTableForMove(bool allowMerge)
        {
            using (var bi = new FoodTableBI())
            {
                using (var frm = new MoveTableForm(bi.List(x => x.IsActive), allowMerge))
                {
                    frm.ShowDialog();
                    if (frm.Selection != null)
                        return frm.Selection;
                }
                return null;
            }
        }
        internal void MoveKot(BillItemKey currentKot)
        {
            if (_voucher.VoucherID == Guid.Empty || IsPrintedOrVoid(_voucher))
                return;
            var kot = currentKot;
            if (kot == null)
                return;
            var table = GetTableForMove(true);
            if (table == null)
                return;
            if (table.FoodTableID == _voucher.Table.FoodTableID)
                return;
            if (table.VoucherID != null)
                if (IsPrintedOrVoid(table.VoucherID.Value))
                    return;
            var kotCount = _bill.Keys.Count(x => x.BillItemType == BillItemType.Kot && x.KotID != Guid.Empty);
            var voucherID = Guid.Empty;
            if (table.VoucherID == null && kotCount > 1)
                //Move Kot
                voucherID = MoveKot(kot, table);
            else if (table.VoucherID != null && kotCount > 1)
                //Merge Kot
                voucherID = MergeKot(kot, table);
            else if (table.VoucherID == null && kotCount == 1)
                //Move Table
                voucherID = MoveTable(table.FoodTableID);
            else if (table.VoucherID != null && kotCount == 1)
                //Merge Table
                voucherID = MergeTable(table);
            if (voucherID != Guid.Empty)
            {
                LoadBill(voucherID);
            }
        }
        internal void MoveTable()
        {
            if (_voucher.VoucherID == Guid.Empty)
                return;

            var allowMerge = !IsPrintedOrVoid(_voucher);

            var table = GetTableForMove(allowMerge);
            if (table == null)
                return;
            if (table.FoodTableID == _voucher.Table.FoodTableID)
                return;
            if (table.VoucherID.HasValue)
                if (IsPrintedOrVoid(table.VoucherID.Value))
                    return;

            LoadBill(table.VoucherID.HasValue ? MergeTable(table) : MoveTable(table.FoodTableID));
        }
        private Guid MoveKot(BillItemKey kot, FoodTable table)
        {
            if (!Session.IsAllowed("Move Kot to New Table"))
                return Guid.Empty;
            using (var bi = new VoucherBI())
            {
                var newVoucherID = bi.MoveKot(kot.KotID, table.FoodTableID);
                bi.UpdateTable(x => x.FoodTableID == table.FoodTableID && x.VoucherID == null, newVoucherID, "running");
                bi.SaveChanges();
                return newVoucherID;
            }
        }
        private static Guid MergeKot(BillItemKey kot, FoodTable table)
        {
            if (!Session.IsAllowed("Merge Kots"))
                return Guid.Empty;
            using (var bi = new VoucherBI())
            {
                var newVoucherID = bi.MergeKot(kot.KotID, table.Name);
                bi.SaveChanges();
                return newVoucherID;
            }
        }
        private Guid MoveTable(Guid tableID)
        {
            if (!Session.IsAllowed("Move Table"))
                return Guid.Empty;
            using (var bi = new VoucherBI())
            {
                bi.MoveTable(_voucher.VoucherID, tableID);
                bi.UpdateTable(x => x.FoodTableID == tableID && x.VoucherID == null, _voucher.VoucherID, _voucher.Table.Status);
                bi.UpdateTable(x => x.FoodTableID == _voucher.Table.FoodTableID && x.VoucherID == _voucher.VoucherID, null, null);
                bi.SaveChanges();
                return _voucher.VoucherID;
            }
        }
        private Guid MergeTable(FoodTable table)
        {
            if (!Session.IsAllowed("Merge Tables"))
                return Guid.Empty;
            using (var bi = new VoucherBI())
            {
                var newVoucherID = bi.MergeTables(_voucher.VoucherID, table.Name);
                bi.UpdateTable(x => x.FoodTableID == _voucher.Table.FoodTableID && x.VoucherID == _voucher.VoucherID, null, null);
                bi.SaveChanges();
                return newVoucherID;
            }
        }
        #endregion

        #region Save
        public bool SaveAndPrintKot()
        {
            #region Check if Allowed
            if (!Session.IsAllowed("Print Kot") || _bill.Count(x => x.Key.BillItemType != BillItemType.Kot) == 0)
                return false;
            bool isPrinted = false, isVoid = false;
            if (_voucher.VoucherID != Guid.Empty)
                using (var bi = new VoucherBI())
                {
                    var dbVoucher = bi.Get(x => x.VoucherID == _voucher.VoucherID);
                    isPrinted = dbVoucher.Printed;
                    isVoid = dbVoucher.Void;
                }
            if (isVoid)
            {
                MessageBox.Show(string.Format("This Bill is already void.\nReason: {0}", _voucher.VoidReason), "Bill already Voided", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return false;
            }
            if (isPrinted)
            {
                MessageBox.Show(string.Format("This Bill is already printed and a kot cannot be added", _voucher.VoidReason), "Bill already Printed", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return false;
            }
            if (_voucher.VoucherID != Guid.Empty && IsPrintedOrVoid(_voucher))
                return false;
            #endregion

            //Save
            var saved = _voucher.VoucherID == Guid.Empty ? InsertVoucher(false, !_editVoucherID.HasValue) : UpdateVoucher(false, !_editVoucherID.HasValue);

            //Print
            if (!_editVoucherID.HasValue && saved.HasValue)
                Thermal.PrintKot(_voucher.VoucherID, saved.Value);

            //Cleanup
            ClearBill();
            return true;
        }
        public bool CanSaveBill(bool isPrinted, bool isVoid)
        {
            if (!Session.IsAllowed("Print Bill") || _bill.Count(x => x.Key.BillItemType != BillItemType.Kot) == 0)
                return false;
            if (isVoid)
            {
                MessageBox.Show(string.Format("This Bill is already void.\nReason: {0}", _voucher.VoidReason), "Bill already Voided", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return false;
            }
            if (isPrinted && !Session.IsAllowed("Edit Printed Bill"))
                return false;
            return true;
        }
        public bool SaveAndPrintBill(bool isPrinted, decimal amount)
        {
            if (isPrinted)
            {
                SaveReprintOrDiscountBill(amount);
            }
            else
            {
                // Ask for VoucherType only for new bill, if none, then cancel
                using (var frm = new VoucherTypeForm())
                {
                    frm.ShowDialog();
                    if (!frm.Selection.HasValue)
                        return false;
                    _voucher.VoucherType = frm.Selection.Value;
                }
                if (_voucher.VoucherID == Guid.Empty)
                    InsertVoucher(true, !_editVoucherID.HasValue);
                else
                    UpdateVoucher(true, !_editVoucherID.HasValue);
            }
            Thermal.PrintBill(_voucher.VoucherID);
            ClearBill();
            return true;
        }
        public void SplitBill()
        {
            bool isPrinted = false;
            #region Permissions
            if (!Session.IsAllowed("Split Bill"))
                return;
            if (_voucher.VoucherID == Guid.Empty)
                return; // must be existing non void bill
            using (var bi = new VoucherBI())
            {
                var dbVoucher = bi.Get(x => x.VoucherID == _voucher.VoucherID);
                if (dbVoucher.Void)
                {
                    MessageBox.Show(string.Format("This Bill is already void.\nReason: {0}", _voucher.VoidReason), "Bill already Voided", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;// must be a non void bill
                }
                if (dbVoucher.Printed && !Session.IsAllowed("Edit Printed Bill"))
                {
                    MessageBox.Show("This Bill is already Printed.\nYou do not have the authority to alter it", "Bill already Printed", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;// not allowed to edit printed bill
                }
                isPrinted = dbVoucher.Printed;
            }
            #endregion

            #region Get Move List
            HashSet<string> splitList = null;
            using (var bi = new ProductGroupBI())
            {
                using (var frm = new DiscountForm(bi.GetProductGroupTypes()))
                    if (frm.ShowDialog() == DialogResult.OK)
                        frm.Selection(out splitList);
            }
            if (splitList == null || splitList.Count == 0)
                return;

            var listFirst = _bill.Where(x => x.Key.BillItemType != BillItemType.Kot && x.Key.KotID != Guid.Empty && splitList.Contains(x.Value.inventory.Product.ProductGroup.GroupType));
            var listSecond = _bill.Where(x => x.Key.BillItemType != BillItemType.Kot && x.Key.KotID != Guid.Empty && !splitList.Contains(x.Value.inventory.Product.ProductGroup.GroupType));

            if (listFirst.Count() == 0 || listSecond.Count() == 0)
                return; // all or none items selected to be moved
            #endregion

            var table = GetTableForMove(false);
            if (table == null)
                return;

            #region new voucherFirst
            var voucherFirst = new Voucher(Session.User, _voucher.Customer)
            {
                Table = table,
                Printed = isPrinted,
                Void = false,
                Narration = "",
                VoucherType = _voucher.VoucherType
            };

            var kotFirst = GetKot(listFirst);
            if (kotFirst != null)
                voucherFirst.Kots.Add(kotFirst);
            #endregion

            #region new voucherSecond
            var voucherSecond = new Voucher(Session.User, _voucher.Customer)
            {
                Table = _voucher.Table,
                Printed = isPrinted,
                Void = false,
                Narration = "",
                VoucherType = _voucher.VoucherType
            };

            var kotSecond = GetKot(listSecond);
            if (kotSecond != null)
                voucherSecond.Kots.Add(kotSecond);
            #endregion
            using (var bi = new VoucherBI())
            {
                bi.SplitBill(_voucher.VoucherID, voucherFirst, voucherSecond);
                var status = _voucher.Printed ? "printed" : "running";
                bi.UpdateTable(x => x.FoodTableID == voucherFirst.Table.FoodTableID && x.VoucherID == null, voucherFirst.VoucherID, status);
                bi.UpdateTable(x => x.FoodTableID == voucherSecond.Table.FoodTableID && x.VoucherID == _voucher.VoucherID, voucherSecond.VoucherID, status);
                bi.SaveChanges();
            }
            if (isPrinted)
            {
                Thermal.PrintBill(voucherFirst.VoucherID);
                Thermal.PrintBill(voucherSecond.VoucherID);
            }
            LoadBill(voucherFirst.VoucherID);
        }
        public bool VoidBill()
        {
            #region Check conditions and Permissions
            if (_voucher.VoucherID == Guid.Empty || _voucher.Void || !Session.IsAllowed("Void Bill"))
                return false;
            if (MessageBox.Show("Are you sure you want to void this bill?", "Void Bill", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) != DialogResult.Yes)
                return false;
            #endregion
            var reasons = new string[] { 
                "Discount", 
                "Printing Fault", 
                "Item Changed", 
                "Quantity Reduced", 
                "Costing Bill for Party", 
                "Cashier Mistake", 
                "Management Freesale", 
                "Other" 
            };


            using (var voidReason = new VoidReasonListForm(reasons))
            {
                voidReason.ShowDialog();
                if (voidReason.SelectedItem == null)
                {
                    MessageBox.Show("Please Select a reason if you want to void the bill", "Bill NOT Voided", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                    return false;
                }
                using (var bi = new VoucherBI())
                {
                    bi.VoidBill(_voucher.VoucherID, voidReason.SelectedItem);
                    if (!_editVoucherID.HasValue)
                        bi.UpdateTable(x => x.FoodTableID == _voucher.Table.FoodTableID && x.VoucherID == _voucher.VoucherID, null, null);
                    bi.SaveChanges();
                }
            }
            ClearBill();
            return true;
        }
        private void SaveReprintOrDiscountBill(decimal oldAmount)
        {
            var amountChanged = oldAmount != _bill.Where(x => x.Key.BillItemType != BillItemType.Kot && x.Key.KotID != Guid.Empty).Sum(x => x.Value.inventory.Net);
            var itemsChanged = _bill.Where(x => x.Key.BillItemType != BillItemType.Kot && x.Key.KotID == Guid.Empty).Count() != 0;

            if (amountChanged || itemsChanged) // Discount or Products changed
            {
                #region new voucherFirst
                var newVoucher = new Voucher(Session.User, _voucher.Customer)
                {
                    Table = _voucher.Table,
                    Printed = true,
                    Void = false,
                    Narration = "",
                    VoucherType = _voucher.VoucherType
                };

                var kotNew = GetKot(_bill.Where(x => x.Key.BillItemType != BillItemType.Kot));
                if (kotNew != null)
                    newVoucher.Kots.Add(kotNew);
                #endregion

                using (var bi = new VoucherBI())
                {
                    bi.DiscountPrintedBill(_voucher.VoucherID, newVoucher);
                    bi.UpdateTable(x => x.FoodTableID == _voucher.Table.FoodTableID && (x.VoucherID == _voucher.VoucherID || x.VoucherID == null), newVoucher.VoucherID, "printed");
                    bi.SaveChanges();
                }
                _editVoucherID = null;
                LoadBill(newVoucher.VoucherID);
            }
            else
            {
                using (var bi = new ReprintBI())
                {
                    bi.Insert(new Reprint() { User = Session.User, Voucher = _voucher });
                    bi.SaveChanges();
                }
            }
        }
        private Guid? InsertVoucher(bool finalBill, bool updateTable)
        {
            _voucher.Printed = finalBill;
            _voucher.Void = false;
            _voucher.Narration = "";
            var kot = GetKot(_bill.Where(x => x.Key.KotID == Guid.Empty));
            if (kot == null)
                return null;
            _voucher.Kots.Add(kot);
            using (var bi = new VoucherBI())
            {
                var kotID = bi.Insert(_voucher);
                if (updateTable)
                {
                    var status = !_voucher.Printed ? "running" : "printed";
                    bi.UpdateTable(x => x.FoodTableID == _voucher.Table.FoodTableID && x.VoucherID == null, _voucher.VoucherID, status);
                }
                bi.SaveChanges();
                return kotID;
            }
        }
        private Guid? UpdateVoucher(bool finalBill, bool updateTable)
        {
            using (var bi = new VoucherBI())
            {
                var voucher = bi.Get(x => x.VoucherID == _voucher.VoucherID);
                voucher.User = Session.User;
                voucher.Customer = _voucher.Customer;
                voucher.Printed = finalBill;
                voucher.VoucherType = _voucher.VoucherType;
                foreach (var item in _bill.Where(x => x.Key.BillItemType != BillItemType.Kot && x.Key.KotID != Guid.Empty))
                {
                    var i = voucher.Kots.Single(x => x.KotID == item.Key.KotID).Inventories.Single(x => x.Product.ProductID == item.Key.ProductID && x.IsHappyHour == item.Value.inventory.IsHappyHour);
                    i.Discount = item.Value.inventory.Discount;
                    i.Price = item.Value.inventory.Price;
                }
                if (!_voucher.Printed)
                {
                    var kot = GetKot(_bill.Where(x => x.Key.KotID == Guid.Empty));
                    if (kot != null)
                        voucher.Kots.Add(kot);
                }
                var kotID = bi.Update(voucher);
                if (updateTable)
                {
                    var status = !voucher.Printed ? "running" : "printed";
                    bi.UpdateTable(x => x.FoodTableID == _voucher.Table.FoodTableID && x.VoucherID == _voucher.VoucherID, _voucher.VoucherID, status);
                }

                bi.SaveChanges();
                return kotID;
            }
        }
        private static Kot GetKot(IEnumerable<KeyValuePair<BillItemKey, BillItemValue>> list)
        {
            var kot = new Kot();
            foreach (var item in list)
            {
                if (item.Key.BillItemType == BillItemType.Kot)
                    continue;
                if (item.Value.inventory.Quantity == 0)
                    continue;
                var happyHour = item.Key.BillItemType == BillItemType.HappyHourProduct;
                var productID = item.Key.ProductID;
                var oldInv = kot.Inventories.SingleOrDefault(x => x.Product.ProductID == productID && x.IsHappyHour == happyHour);
                if (oldInv != null)
                {
                    oldInv.Quantity += item.Value.inventory.Quantity;
                    if (oldInv.Quantity == 0)
                        kot.Inventories.Remove(oldInv);
                }
                else
                {
                    var inv = new Inventory
                                  {
                                      Product = item.Value.inventory.Product,
                                      Quantity = item.Value.inventory.Quantity,
                                      Price = item.Value.inventory.Price,
                                      IsHappyHour = item.Value.inventory.IsHappyHour,
                                      Discount = item.Value.inventory.Discount,
                                      ServiceCharge = item.Value.inventory.ServiceCharge,
                                      IsScTaxable = item.Value.inventory.IsScTaxable,
                                      ServiceTaxRate = item.Value.inventory.ServiceTaxRate,
                                      VatRate = item.Value.inventory.VatRate,
                                      ServiceTax = item.Value.inventory.ServiceTax,
                                      Vat = item.Value.inventory.Vat
                                  };
                    foreach (var mod in item.Value.inventory.InventoryModifier)
                        inv.InventoryModifier.Add(new InventoryModifier { Modifier = mod.Modifier });
                    kot.Inventories.Add(inv);
                }
            }

            return kot.Inventories.Count == 0 ? null : kot;
        }
        #endregion

        #region InputBox
        private bool GetInput(string prompt, ref decimal amount)
        {
            var result = InputBox.Show(prompt, amount.ToString(), InputBox_Validating);
            if (!result.OK)
                return false;
            return decimal.TryParse(result.Text, out amount);
        }
        private bool GetInput(string prompt, ref string info)
        {
            var result = InputBox.Show(prompt, info, InputBox_Validating);
            if (!result.OK)
                return false;
            info = result.Text.Trim();
            return !string.IsNullOrEmpty(info);
        }
        #endregion
    }
}