using Microsoft.EntityFrameworkCore;
using OOO_WriteAndClear.DBModels;
using OOO_WriteAndClear.MVP.MVPInterfaces;
using System;
using System.Collections.Generic;
using System.DirectoryServices;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace OOO_WriteAndClear.MVP.Models.ProductsUserControlModel
{
    public class ProductsUserControlModel : IProductsUserControlContract.IModel
    {
        public ProductsUserControlModel() 
        {
            _products = new List<Product>();
            _immutableProducts = new List<Product>();
            _orderFormerer = new OrderFormerer.OrderFormerer();
        }


        #region Реализация IProductsUserControlContract.IModel
        public ICollection<Product> Products => _products;


        public int GetAllProductsCount() => _immutableProducts.Count;

        public void FilterSearchSortProducts(FilterSearchSortParameters parameters)
        {
            _products = SortProductsCollection(parameters.SortDirection, SearchByProductName(parameters.SearchQuerry, FilterByDiscount(parameters.FilterBy, _immutableProducts)));
        }

        public async Task UpdateProductsList(FilterSearchSortParameters parameters)
        {
            using (VorobiewTradeContext db = new VorobiewTradeContext())
                _immutableProducts = await db.Products.Include(a => a.ProductManufacturer).ToListAsync();
            FilterSearchSortProducts(parameters);
        }

        public void AddProductIntoOrder(Product product, Action<Order> CallbackIfAddedInOrder)
        {
            bool isAdded = _orderFormerer.AddProductIntoOrder(product);
            if (!isAdded) return;
            CallbackIfAddedInOrder?.Invoke(_orderFormerer.Order);
        }

        public void RemoveProductFromOrder(Product product, Action<Order> CallBackIfProductRemovedInOrder)
        {
            bool isRemoved = _orderFormerer.RemoveProductFromOrder(product);
            if (!isRemoved) return;
            CallBackIfProductRemovedInOrder?.Invoke(_orderFormerer.Order);
        }

        public OrderFormerer.OrderFormerer GetCurrentOrderFormerer() 
            => _orderFormerer;

        #endregion


        private ICollection<Product> _products;
        private ICollection<Product> _immutableProducts;

        private OrderFormerer.OrderFormerer _orderFormerer;


        public ICollection<Product> SortProductsCollection(SortDirection sortDirection, ICollection<Product> products)
        {
            switch (sortDirection)
            {
                case SortDirection.Ascending:
                    return products.OrderBy(a => a.CurrentPrice).ToList();
                case SortDirection.Descending:
                    return products.OrderByDescending(a => a.CurrentPrice).ToList();
                default: return products;
            }
        }

        private ICollection<Product> FilterByDiscount(FilterByDiscountParameters discountParameters
            , ICollection<Product> unfilteredCollection)
        {
            List<Product> filtredProducts = new List<Product>();
            filtredProducts.AddRange(unfilteredCollection.Where
                (product => 
                decimal.ToDouble((product.ProductDiscountMax is null)? 0m : (decimal)product.ProductDiscountMax)
                >= discountParameters.From 
                && decimal.ToDouble((product.ProductDiscountMax is null) ? 0m : (decimal)product.ProductDiscountMax)
                <= discountParameters.Before));
            return filtredProducts;
        }

        private ICollection<Product> SearchByProductName(string query, ICollection<Product> unfilteredCollection)
        {
            List<Product> filtredProducts = new List<Product>();
            filtredProducts.AddRange(unfilteredCollection.Where(product => Regex.IsMatch(product.ProductName, query)));
            return filtredProducts;
        }
    }
}