using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using InABox.Core;

namespace Comal.Classes
{
    public class PurchaseOrderExTax : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.ExTax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<PurchaseOrder, object>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<PurchaseOrder, object>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrderLink.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }

    public class PurchaseOrderTax : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.Tax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<PurchaseOrder, object>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<PurchaseOrder, object>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrderLink.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }

    public class PurchaseOrderIncTax : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.IncTax;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<PurchaseOrder, object>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<PurchaseOrder, object>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrderLink.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }

    public class PurchaseOrderBalance : CoreAggregate<PurchaseOrder, PurchaseOrderItem, double>
    {
        public override Expression<Func<PurchaseOrderItem, double>> Aggregate => x => x.Balance;

        public override AggregateCalculation Calculation => AggregateCalculation.Sum;

        public override Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<PurchaseOrder, object>>> Links =>
            new Dictionary<Expression<Func<PurchaseOrderItem, object>>, Expression<Func<PurchaseOrder, object>>>()
            {
                { PurchaseOrderItem => PurchaseOrderItem.PurchaseOrderLink.ID, PurchaseOrder => PurchaseOrder.ID }
            };
    }

    [UserTracking(typeof(Bill))]
    public class PurchaseOrder : Entity, IRemotable, IPersistent, IStringAutoIncrement<PurchaseOrder>, IOneToMany<Supplier>,
        ILicense<AccountsPayableLicense>
    {
        private bool bChanging;

        [UniqueCodeEditor(Visible = Visible.Default, Editable = Editable.Enabled)]
        [EditorSequence(0)]
        public string PONumber { get; set; }

        [EntityRelationship(DeleteAction.SetNull)]
        [EditorSequence(1)]
        public SupplierLink SupplierLink { get; set; }

        [MemoEditor]
        [EditorSequence(2)]
        public string Notes { get; set; }

        [EditorSequence(3)]
        public PurchaseOrderCategoryLink Category { get; set; }

        [EditorSequence(4)]
        public EmployeeLink RaisedBy { get; set; }

        [DateEditor]
        [EditorSequence(5)]
        public DateTime DueDate { get; set; }

        [EditorSequence(6)]
        public EmployeeLink IssuedBy { get; set; }

        [TimestampEditor]
        [EditorSequence(7)]
        public DateTime IssuedDate { get; set; }

        [TimestampEditor]
        [EditorSequence(8)]
        public DateTime ClosedDate { get; set; }

        [EditorSequence(9)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderExTax))]
        public double ExTax { get; set; }

        [EditorSequence(10)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderTax))]
        public double Tax { get; set; }

        [EditorSequence(11)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderIncTax))]
        public double IncTax { get; set; }

        [EditorSequence(12)]
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(PurchaseOrderBalance))]
        public double Balance { get; set; }

        [EditorSequence(13)]
        [EnumLookupEditor(typeof(PurchaseOrderStatus), Editable = Editable.Hidden)]
        public PurchaseOrderStatus Status { get; set; }


        //[CodeEditor(Visible = Visible.Default, Editable = Editable.Hidden)]
        [NullEditor]
        public string SupplierCode { get; set; }

        //[TextBoxEditor]
        [NullEditor]
        public string SupplierName { get; set; }

        public Expression<Func<PurchaseOrder, string>> AutoIncrementField()
        {
            return x => x.PONumber;
        }

        public Filter<PurchaseOrder> AutoIncrementFilter()
        {
            return null;
        }

        public string AutoIncrementFormat()
        {
            return "{0:D6}";
        }

        protected override void DoPropertyChanged(string name, object before, object after)
        {
            base.DoPropertyChanged(name, before, after);
            if (bChanging)
                return;
            bChanging = true;

            if (name.Equals("Status"))
            {
                var status = (PurchaseOrderStatus)after;
                if (status.Equals(PurchaseOrderStatus.Closed))
                {
                    if (ClosedDate == DateTime.MinValue)
                        ClosedDate = DateTime.Now;
                    if (IssuedDate == DateTime.MinValue)
                        IssuedDate = DateTime.Now;
                }
                else if (status == PurchaseOrderStatus.Issued)
                {
                    if (ClosedDate != DateTime.MinValue)
                        ClosedDate = DateTime.MinValue;
                    if (IssuedDate == DateTime.MinValue)
                        IssuedDate = DateTime.Now;
                }
                else
                {
                    if (ClosedDate != DateTime.MinValue)
                        ClosedDate = DateTime.MinValue;
                    if (IssuedDate != DateTime.MinValue)
                        IssuedDate = DateTime.MinValue;
                }
            }
            else
            {
                var closed = name.Equals("ClosedDate") ? (DateTime)after : ClosedDate;
                var issued = name.Equals("IssuedDate") ? (DateTime)after : IssuedDate;
                var status = PurchaseOrderStatus.Closed;
                if (closed != DateTime.MinValue)
                    status = PurchaseOrderStatus.Closed;
                else if (issued != DateTime.MinValue)
                    status = PurchaseOrderStatus.Issued;
                else
                    status = PurchaseOrderStatus.Draft;
                if (Status != status)
                    Status = status;
            }

            bChanging = false;
        }

        protected override void Init()
        {
            base.Init();

            SupplierLink = new SupplierLink(this);
            LinkProperty<SupplierLink, PurchaseOrder>(x => x.Code, x => x.SupplierCode);
            LinkProperty<SupplierLink, PurchaseOrder>(x => x.Name, x => x.SupplierName);

            IssuedBy = new EmployeeLink();
            RaisedBy = new EmployeeLink();

            Category = new PurchaseOrderCategoryLink();
        }
    }
}