namespace CHCKOShoppingApi.Models
{
    interface IShoppingRepository
    {
        Dictionary<string, List<Item>> GetAll();
        IEnumerable<Item> getByType(string itemType);
        Item getItem(string type, string itemName);
        Item getItem(string type, int id);
        List<Item> Add(string itemType, List<Item> items);
        void Delete(string type, int id);
        bool Update(string type, int id, Item item);
    }
}

namespace CHCKOShoppingApi.Models
{
    class ShoppingRepository : IShoppingRepository
    {
        public static ShoppingRepository shoppingBasket= null;
        public static readonly Dictionary<string, List<Item>> Items = new Dictionary<string, List<Item>>();

        static List<Item> items = new List<Item>
             {
                 new Item {Id=1, name = "pepsi", price = 15, quantity = 1 },
                 new Item {Id=2, name = "fanta", price = 15, quantity = 1 },
                 new Item {Id=3, name = "sprite", price = 15, quantity = 1 },
             };

        private ShoppingRepository() {}

        public void initRepository()
        {
            addItems("drinks", items);
        }

        public static ShoppingRepository getInstance()
        {
            if (shoppingBasket == null)
            {
                
                shoppingBasket = new ShoppingRepository();
                Items.Add("drinks", items);
                return shoppingBasket;
            }
            else
                return shoppingBasket;
        }

        public void addItems(string type,List<Item> items)
        {
            if (!Items.ContainsKey(type))
            {
                Items.Add(type, items);
            }
            else
            {
                foreach (Item item in items)
                    Items[type].Add(item);
            }
        }

        public Dictionary<string, List<Item>> GetAll()
        {
            return Items;
        }

        public IEnumerable<Item> getByType(string itemType)
        {
            return Items[itemType];
        }

        public Item getItem(string type, string itemName)
        {
            return Items[type].Find(i => i.name == itemName);
        }

        public Item getItem(string type, int itemId)
        {
            return Items[type].Find(i => i.Id == itemId);

        }

        public List<Item> Add(string itemType,List<Item> items)
        {
            ShoppingRepository.getInstance().addItems(itemType, items);
            return items;
        }

        public void Delete(string type,int id)
        {
            var item = Items[type].FirstOrDefault(i => i.Id == id);
            if (item != null)
            {
                Items[type].Remove(item);
            }
        }

        public bool Update(string type,int id,Item item)
        {
            Item rItem = Items[type].FirstOrDefault(p => p.Id == id);
            if (rItem != null)
            {
                rItem.name = item.name;
                rItem.quantity = item.quantity;
                rItem.price = item.price;
                return true;
            }
            return false;
        }
   
    }
}

namespace CHCKOShoppingApi.Models
{
    public class Item
    {
        private DateTime datePurchased;
        [Key]
        public int Id { get; set; }
        public string name { get; set; }
        public int quantity { get; set; }
        public double price { get; set; }
        public DateTime DatePurchased
        {
            get { return datePurchased; }
            set { datePurchased = new DateTime(); }
        }
    }
}

namespace CHCKOShoppingApi.Controllers
{
    public class ShoppingController : ApiController
    {
        //repo as a singleton 
        ShoppingRepository shoppingRepo = ShoppingRepository.getInstance();
       
        public Dictionary<string,List<Item>> GetShoppingItems()
        {
           //(1a) Get all shopping items. Can be of type drinks, stationary and any types that has been stored.
        }

        public HttpResponseMessage GetItems(string type)
        {
          //(2a Get shopping items of specific type. For example retrieve all drinks that is to be purchased.
        }

        public HttpResponseMessage GetItem(string type, string name)
        {
          //(3a) Get a specific shopping item of specific type given its name. For example retrieve a drink of name pepsi     
        }

        public HttpResponseMessage GetItem(string type, int id)
        {
          //(4a) Get a specific shopping item of specific type given its id. For example retrieve a drink of id 1     
        }

        public HttpResponseMessage PostItem(string type,List<Item> items)
        {
           //(5a) Add items to the shopping list. For example add a pepsi of type drinks.
        }
  
        public HttpResponseMessage Delete(string type,int id)
        {
          //(6a) Delete an item of a praticular type by its id.
        }

        public HttpResponseMessage Put(string type,int id, Item item)
        {
          //(7a) Update an item of a particular type given its id.
        }
    }
}

  public Dictionary<string,List<Item>> GetShoppingItems()
        {
            return shoppingRepo.GetAll();
        }

   public HttpResponseMessage GetItems(string type)
        {
              IEnumerable<Item> items;
              try
              {
                  items = shoppingRepo.getByType(type);
                  return Request.CreateResponse(HttpStatusCode.OK, items);
              }
              catch (Exception e)
              {
                  return Request.CreateResponse(HttpStatusCode.NotFound);
              } 
        }

   public HttpResponseMessage GetItem(string type, string name)
        {
            Item item;
            try
            {
                item = shoppingRepo.getItem(type, name);
                return Request.CreateResponse(HttpStatusCode.OK, item);
            }
            catch (Exception e)
            {
                return Request.CreateResponse(HttpStatusCode.NotFound);
            }     
        }

 public HttpResponseMessage GetItem(string type, int id)
        {
            Item item;
            try
            {
                item = shoppingRepo.getItem(type, id);
                return Request.CreateResponse(HttpStatusCode.OK, item);
            }
            catch (Exception e)
            {
                return Request.CreateResponse(HttpStatusCode.NotFound);
            }
        }

  public HttpResponseMessage PostItem(string type,List<Item> items)
        {
            if (ModelState.IsValid)
            {
                items = shoppingRepo.Add(type,items);
                var response = Request.CreateResponse(HttpStatusCode.Created, items);

                string uri = Url.Link("DefaultApi", items);
                response.Headers.Location = new Uri(uri);
                return response;
            }
            else
            {
                return Request.CreateResponse(HttpStatusCode.BadRequest);
            }
        }

  public HttpResponseMessage Delete(string type,int id)
        {
           Item item;
            try
            {
                item = shoppingRepo.getItem(type, id);
                if (item != null)
                {
                    shoppingRepo.Delete(type, id);
                    return Request.CreateResponse(HttpStatusCode.OK, item);
                }
                else
                    return Request.CreateResponse(HttpStatusCode.NotFound);          
            }
            catch (Exception e)
            {
                return Request.CreateResponse(HttpStatusCode.BadRequest);
            }  
        }

   public HttpResponseMessage Put(string type,int id, Item item)
        {
            if (ModelState.IsValid && id == item.Id)
            {
                var result = shoppingRepo.Update(type,id, item);
                if (result == false)
                {
                    return Request.CreateResponse(HttpStatusCode.NotFound);
                }
                return Request.CreateResponse(HttpStatusCode.OK);
            }
            else
            {
                return Request.CreateResponse(HttpStatusCode.BadRequest);
            }
        }