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

namespace Comal.Classes
{
    public class RequisitionDocumentCount : CoreAggregate<Requisition, RequisitionDocument, Guid>
    {
        public override Expression<Func<RequisitionDocument, Guid>> Aggregate => x => x.ID;

        public override AggregateCalculation Calculation => AggregateCalculation.Count;

        public override Dictionary<Expression<Func<RequisitionDocument, object>>, Expression<Func<Requisition, object>>> Links =>
            new Dictionary<Expression<Func<RequisitionDocument, object>>, Expression<Func<Requisition, object>>>()
            {
                { RequisitionDocument => RequisitionDocument.EntityLink.ID, Requisition => Requisition.ID }
            };
    }

    [UserTracking(typeof(StockMovement))]
    public class Requisition : Entity, IRequisition, IPersistent, IRemotable, INumericAutoIncrement<Requisition>, ILicense<ProjectManagementLicense>, IJobScopedItem
    {
        
        [EntityRelationship(DeleteAction.SetNull)]
        [NullEditor]
        [RequiredColumn]
        [LoggableProperty]
        public DeliveryLink Delivery { get; set; }

        [Aggregate(typeof(RequisitionDocumentCount))]
        [NullEditor]
        public int Documents { get; set; }
        
        public Expression<Func<Requisition, int>> AutoIncrementField()
        {
            return x => x.Number;
        }

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

        [EditorSequence(1)]
        [IntegerEditor(Editable = Editable.Disabled)]
        public int Number { get; set; }
        
        [EditorSequence(2)]
        [DateEditor(Editable = Editable.Hidden)]
        public override DateTime Created
        {
            get => base.Created;
            set => base.Created = value;
        }
        
        [EditorSequence(3)]
        [TextBoxEditor]
        public string Title { get; set; }

        [EditorSequence(4)]
        [EntityRelationship(DeleteAction.Cascade)]
        public JobLink JobLink { get; set; }
        
        private class JobScopeLookup : LookupDefinitionGenerator<JobScope, Requisition>
        {
            public override Filter<JobScope> DefineFilter(Requisition[] items)
            {
                var item = items?.Length == 1 ? items[0] : null;
                if (item != null)
                    return new Filter<JobScope>(x => x.Job.ID).IsEqualTo(item.JobLink.ID).And(x => x.Status.Approved).IsEqualTo(true);
                return new Filter<JobScope>(x => x.ID).None();
            }
            
            public override Columns<Requisition> DefineFilterColumns()
                => new Columns<Requisition>(x=>x.JobLink.ID);
        }
        [LookupDefinition(typeof(JobScopeLookup))]
        [EditorSequence(5)]
        [EntityRelationship(DeleteAction.SetNull)]
        public JobScopeLink JobScope { get; set; }

        [EditorSequence(6)]
        public EmployeeLink RequestedBy { get; set; }
        
        [EditorSequence(7)]
        [MemoEditor]
        public string Request { get; set; }
        
        [EditorSequence(8)]
        [DateTimeEditor]
        public DateTime Due { get; set; }
        
        [EditorSequence(9)]
        public RequisitionDestinationLink Destination { get; set; }
        
        [EditorSequence("Notes",1)]
        [NotesEditor]
        public string[] Notes { get; set; } = Array.Empty<string>();
        
        [EditorSequence("Fulfilment", 1)]
        [Caption("Assigned To")]
        public EmployeeLink Employee { get; set; }
        
        [EditorSequence("Fulfilment", 2)]
        [TimestampEditor]
        public DateTime Filled { get; set; }
        
        [EditorSequence("Fulfilment", 3)]
        [IntegerEditor]
        public int Boxes { get; set; }
        
        [EditorSequence("Fulfilment", 4)]
        [LoggableProperty]
        [RequiredColumn]
        public EmployeeLink TakenBy { get; set; }
        
        [EditorSequence("Fulfilment", 5)]
        [TimestampEditor(Editable = Editable.Disabled)]
        public DateTime StockUpdated { get; set; }
        
        [EditorSequence("Fulfilment", 6)]
        [TimestampEditor(Editable = Editable.Disabled)]
        [LoggableProperty]
        public DateTime Archived { get; set; } = DateTime.MinValue;
        
        public override string ToString()
        {
            return string.Format("{0}: {1} ({2} - {3})", Number, Title, JobLink.JobNumber, JobLink.Name);
        }

        static Requisition()
        {
            LinkedProperties.Register<Requisition,JobScopeLink,Guid>(x=>x.JobLink.DefaultScope, x=>x.ID, x=>x.JobScope.ID);
        }
    }
}