using ProRestaurant.Classes;
using ProRestaurant.Containers;
using ProRestaurant.DBContexts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace ProRestaurant.Repository.Restaurants
{
    public interface IMenuRepository
    {
        RestaurantMenuContainer GetMenu(int restaurantId);
        MenuContainer GetOptions(int MenuID);
    }

    public class MenuRepository : IMenuRepository
    {
        private readonly DBContext dBContext;

        public MenuRepository(DBContext db)
        {
            dBContext = db;
        }

        public RestaurantMenuContainer GetMenu(int restaurantId)
        {            
            var restaurant = dBContext.Restaurants.Where(r => r.Id == restaurantId).FirstOrDefault();

            var menu = new RestaurantMenuContainer
            {
                Id = restaurant.Id,
                Name = restaurant.Name,
                Categories = restaurant.Categories,
                DeliveryTime = restaurant.DeliveryTime,
                DeliveryFee = string.Format("R {0:N}", restaurant.DeliveryFee),
                Suburb = restaurant.Suburb,
                City = restaurant.City,
                Province = restaurant.Province,
                PostalCode = restaurant.PostalCode,
                Latitude = restaurant.Latitude,
                Longitude = restaurant.Longitude,
                Logo = restaurant.Logo.StartsWith("data:image") ? restaurant.Logo : ImageFormatter.ImageToBase64(restaurant.Logo),
                CategoryList = new List<string>(),
                TradingHours = new List<TradingHourContainer>(),
                MenuList = new List<MenuCategoryContainer>()
            };

            var categories = dBContext.MenuCategories.Where(c => c.RestaurantId == restaurantId).ToList();
            foreach (var cat in categories)
            {
                menu.CategoryList.Add(cat.Description);

                MenuCategoryContainer menuItem = new MenuCategoryContainer
                {
                    Category = cat.Description,
                    Items = new List<MenuItemContainer>()
                };

                var MenuItems = dBContext.MenuItems.Where(mi => mi.CategoryId == cat.Id).ToList();
                foreach (var item in MenuItems)
                {
                    menuItem.Items.Add(new MenuItemContainer
                    {
                        MenuId = item.Id,
                        CategoryId = item.CategoryId,
                        Name = item.Name,
                        Description = item.Description,
                        Price = string.Format("{0:C}", item.Price),
                        Image = !string.IsNullOrEmpty(item.Image) ? item.Image.StartsWith("data:image") ? item.Image : ImageFormatter.ImageToBase64(item.Image) : ""
                    });
                }

                if (menuItem.Items.Count > 0)
                    menu.MenuList.Add(menuItem);
            }

            var tradingHours = dBContext.TradingHours.Where(t => t.RestaurantId == restaurantId).ToList();
            foreach (var tHours in tradingHours)
            {
                var hour = new TradingHourContainer()
                {
                    Description = tHours.Description
                };

                if (tHours.Closed)
                    hour.Time = "Closed";
                else if (tHours.Opened24H)
                    hour.Time = "Open 24 Hours";
                else
                    hour.Time = string.Format("{0:hh:mm} - {1:hh:mm}", tHours.OpeningTime, tHours.ClosingTime);

                menu.TradingHours.Add(hour);
            }

            return menu;
        }

        public MenuContainer GetOptions(int MenuID)
        {            
            var mItem = dBContext.MenuItems.Where(m => m.Id == MenuID).FirstOrDefault();

            MenuContainer menu = new MenuContainer
            {
                Id = MenuID,
                Name = mItem.Name,
                Description = mItem.Description,
                Price = mItem.Price,
                DisplayPrice = string.Format("{0:C}", mItem.Price),       
                Image = "",
                Options = new List<OptionContainer>()
            };

            if (!string.IsNullOrEmpty(mItem.Image))
            {
                menu.Image = mItem.Image.StartsWith("data:image") ? mItem.Image : ImageFormatter.ImageToBase64(mItem.Image);
            }

            //Menu's options
            var menuOptions = dBContext.MenuOptions.Where(mo => mo.MenuItemId == mItem.Id).OrderBy(mo => mo.Rank).ToList();

            foreach (var option in menuOptions)
            {
                OptionContainer opt = new OptionContainer
                {
                    Description = option.Description,
                    OptionType = option.OptionType.ToString(),
                    Limit = option.OptionLimit,
                    IsBasePrice = option.IsBasePrice,
                    SpecialInstructions = "",
                    Options = new List<OptionItemContainer>()
                };

                switch (option.OptionType)
                {
                    case OptionType.SingleRequired:
                        opt.SubTitle = "Required";
                        break;
                    case OptionType.MultipleLimit:
                        opt.SubTitle = string.Format("Choose {0}", opt.Limit);
                        break;
                    default:
                        opt.SubTitle = "";
                        break;
                }

                var menuItems = dBContext.MenuOptionItems.Where(i => i.MenuOption == option).OrderBy(i => i.Rank).ToList();
                foreach (var item in menuItems)
                {
                    opt.Options.Add(new OptionItemContainer()
                    {
                        Id = item.Id,
                        Description = item.Description,
                        Price = item.Price
                    });
                }
                menu.Options.Add(opt);
            }

            if (!mItem.OverrideOptions)
            {
                //Category's Options
                menuOptions = dBContext.MenuOptions.Where(mo => mo.CategoryId == mItem.CategoryId).OrderBy(mo => mo.Rank).ToList();

                foreach (var option in menuOptions)
                {
                    OptionContainer opt = new OptionContainer
                    {
                        Description = option.Description,
                        OptionType = option.OptionType.ToString(),
                        Limit = option.OptionLimit,
                        IsBasePrice = option.IsBasePrice,
                        SpecialInstructions = "",
                        Options = new List<OptionItemContainer>()
                    };

                    switch (option.OptionType)
                    {
                        case OptionType.SingleRequired:
                            opt.SubTitle = "Required";
                            break;
                        case OptionType.MultipleLimit:
                            opt.SubTitle = string.Format("Choose {0}", opt.Limit);
                            break;
                        default:
                            opt.SubTitle = "";
                            break;
                    }

                    var menuItems = dBContext.MenuOptionItems.Where(i => i.MenuOption == option).OrderBy(i => i.Rank).ToList();
                    foreach (var item in menuItems)
                    {
                        opt.Options.Add(new OptionItemContainer()
                        {
                            Id = item.Id,
                            Description = item.Description,
                            Price = item.Price                            
                        });
                    }
                    menu.Options.Add(opt);
                }
            }

            //All Cat Options
            menuOptions = dBContext.MenuOptions.Where(mo => mo.CategoryId == 0 && mo.RestaurantId == mItem.RestaurantId).OrderBy(mo => mo.Rank).ToList();

            foreach (var option in menuOptions)
            {
                OptionContainer opt = new OptionContainer
                {
                    Description = option.Description,
                    OptionType = option.OptionType.ToString(),
                    Limit = option.OptionLimit,
                    IsBasePrice = option.IsBasePrice,
                    SpecialInstructions = "",
                    Options = new List<OptionItemContainer>()
                };

                switch (option.OptionType)
                {
                    case OptionType.SingleRequired:
                        opt.SubTitle = "Required";
                        break;
                    case OptionType.MultipleLimit:
                        opt.SubTitle = string.Format("Choose {0}", opt.Limit);
                        break;
                    default:
                        opt.SubTitle = "";
                        break;
                }

                var menuItems = dBContext.MenuOptionItems.Where(i => i.MenuOption == option).OrderBy(i => i.Rank).ToList();
                foreach (var item in menuItems)
                {
                    opt.Options.Add(new OptionItemContainer()
                    {
                        Id = item.Id,
                        Description = item.Description,
                        Price = item.Price
                    });
                }
                menu.Options.Add(opt);
            }


            return menu;
        }
    }
}