using System;
using InABox.Core;

namespace Comal.Classes
{
    [AutoEntity(typeof(StockHoldingSummaryGenerator))]
    [UserTracking(typeof(StockMovement))]
    public class StockHolding : StockEntity, IRemotable, IPersistent, IOneToMany<StockLocation>, IOneToMany<Product>, 
        IStockHolding, ILicense<WarehouseLicense>
    {
        [Editable(Editable.Disabled)]
        [EditorSequence(1)]
        public StockLocationLink Location { get; set; }
        
        private class ProductLookupGenerator : LookupDefinitionGenerator<Product, StockHolding>
        {
            public override Filter<Product>? DefineFilter(StockHolding[] items)
                => LookupFactory.DefineFilter<Product>().And(x => x.NonStock).IsEqualTo(false);
        }
        [Editable(Editable.Disabled)]
        [EditorSequence(2)]
        [LookupDefinition(typeof(ProductLookupGenerator))]
        public override ProductLink Product { get; set; }
        
        [DimensionsEditor(typeof(StockDimensions))]
        [Editable(Editable.Disabled)]
        [EditorSequence(3)]
        public override StockDimensions Dimensions { get; set; }

        [Editable(Editable.Disabled)]
        [EditorSequence(4)]
        public ProductStyleLink Style { get; set; }
        
        [Editable(Editable.Disabled)]
        [EditorSequence(4)]
        public JobLink Job { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(5)]
        public double Units { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(6)]
        public double Qty { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(7)]
        public double Weight { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(8)]
        public double Available { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(9)]
        public double Allocated { get; set; }
        
        [DoubleEditor(Editable = Editable.Disabled, Summary = Summary.Sum)]
        [EditorSequence(10)]
        public double Value { get; set; }
        
        private class AverageValueFormula : ComplexFormulaGenerator<StockHolding, double>
        {
            public override IComplexFormulaNode<StockHolding, double> GetFormula() =>
                Formula(
                    FormulaOperator.Divide,
                    Property(x => x.Value),
                    Property(x => x.Units)
                );
        }
        
        [ComplexFormula(typeof(AverageValueFormula))]
        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence(11)]
        public double AverageValue { get; set; }
        
        [DateEditor(Editable = Editable.Disabled)]
        [EditorSequence(11)]
        public DateTime LastStockTake { get; set; }
        
        public static Column<IStockHolding>[] Columns => new Column<IStockHolding>[]
        {
            new Column<IStockHolding>(x => x.Job.ID),
            new Column<IStockHolding>(x => x.Location.ID),
            new Column<IStockHolding>(x => x.Product.ID),
            new Column<IStockHolding>(x => x.Style.ID),
            new Column<IStockHolding>(x => x.Dimensions.Unit.ID),
            new Column<IStockHolding>(x => x.Dimensions.Quantity),
            new Column<IStockHolding>(x => x.Dimensions.Length),
            new Column<IStockHolding>(x => x.Dimensions.Width),
            new Column<IStockHolding>(x => x.Dimensions.Height),
            new Column<IStockHolding>(x => x.Dimensions.Weight),
        };
        
        public static Filter<StockMovement>? GetFilter(IStockHolding holding)
        {
            var filter = new Filters<StockMovement>();
        
            foreach(var column in Columns)
            {
                filter.Add(new Filter<StockMovement>(column.Cast<StockMovement>()).IsEqualTo(CoreUtils.GetPropertyValue(holding, column.Property)));
            }
        
            return filter.Combine();
        }
        

    }
}