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

namespace Comal.Classes
{
    [UserTracking("Accounts Payable")]
    public class Bill : Entity, IPersistent, IRemotable, ILicense<AccountsPayableLicense>, IDataEntryInstance, IPostable, IExportable, 
        IProblems<ManagedProblem>
    {
     
        [RequiredColumn]
        [EditorSequence(1)]
        [EntityRelationship(DeleteAction.Cascade)]
        public SupplierLink SupplierLink { get; set; }
        
        [EditorSequence(2)]
        [CodeEditor(Visible = Visible.Default, Editable = Editable.Enabled)]
        public string Number { get; set; }

        [EditorSequence(3)]
        [MemoEditor]
        public string Description { get; set; }

        [EditorSequence(4)]
        [DateEditor]
        public DateTime BillDate { get; set; }
        
        [EditorSequence(5)]
        [LookupDefinition(typeof(AccountsPayablePaymentTermsLookup<Bill>))]
        public PaymentTermsLink Terms { get; set; }
        
        [EditorSequence(6)]
        [DateEditor]
        public DateTime PaymentDate { get; set; }

        [EditorSequence(7)]
        [DateEditor]
        public DateTime AccountingDate { get; set; }
        
        [EditorSequence("Additional",1)]
        [TimestampEditor]
        public DateTime DataEntered { get; set; }
        
        [EditorSequence("Additional",2)]
        [TimestampEditor]
        [Security(typeof(CanCheckBills), Editable = Editable.Disabled)]
        public DateTime Checked { get; set; }

        [EditorSequence("Additional",3)]
        [TimestampEditor]
        [Security(typeof(CanApproveBills), Editable = Editable.Disabled)]
        public DateTime Approved { get; set; }
        
        
        [DoubleEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(BillExTax))]
        public double ExTax { get; set; }

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

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

        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Aggregate(typeof(BillAmountPaid))]
        public double AmountPaid { get; set; }

        [CurrencyEditor(Editable = Editable.Hidden, Summary = Summary.Sum)]
        [Formula(typeof(BillBalance))]
        public double Balance { get; set; }

        [Aggregate(typeof(BillDocumentCount))]
        [IntegerEditor(Editable = Editable.Hidden)]
        public int Documents { get; set; }

        [NullEditor]
        [LoggableProperty]
        public DateTime Posted { get; set; }

        [NullEditor]
        [LoggableProperty]
        [RequiredColumn]
        public PostedStatus PostedStatus { get; set; }

        [NullEditor]
        public string PostedNote { get; set; }

        [NullEditor]
        public string PostedReference { get; set; }

        private static string BILLDATE = CoreUtils.GetFullPropertyName<Bill, DateTime>(x => x.BillDate, ".");
        private static string TERMSCALCULATION = CoreUtils.GetFullPropertyName<Bill, String>(x => x.Terms.Calculation, ".");
        private static string SUPPLIERLINKTERMSCALCULATION = CoreUtils.GetFullPropertyName<Bill, String>(x => x.SupplierLink.Terms.Calculation, ".");
        private static string AMOUNTPAID = CoreUtils.GetFullPropertyName<Bill, double>(x => x.AmountPaid, ".");
        private static string INCTAX = CoreUtils.GetFullPropertyName<Bill, double>(x => x.IncTax, ".");
        
        protected override void DoPropertyChanged(string name, object? before, object? after)
        {
            base.DoPropertyChanged(name, before, after);
            if (name.Equals(AMOUNTPAID))
                Balance = IncTax - (double)(after ?? 0.0);
            else if (name.Equals(INCTAX))
                Balance = (double)(after ?? 0.0) - AmountPaid;
            else if (name.Equals(BILLDATE))
                PaymentDate =  CalculateTerms((DateTime)(after ?? ""),Terms.Calculation);
            else if (name.Equals(TERMSCALCULATION))
                PaymentDate =  CalculateTerms(BillDate, (string)(after ?? ""));
            else if (name.Equals(SUPPLIERLINKTERMSCALCULATION))
                PaymentDate =  CalculateTerms(BillDate, (string)(after ?? ""));
        }

        private DateTime CalculateTerms(DateTime date, string calculation)
        {
            if (string.IsNullOrWhiteSpace(calculation))
                return date;
            
            var variables = new Dictionary<string, object?>()
            {
                { "Date", date }
            };
            
            try
            {
                var expr = new CoreExpression(calculation);
                var eval = expr.Evaluate(variables);
                return (DateTime)(CoreUtils.ChangeType(eval, typeof(DateTime)) ?? date);
            }
            catch (Exception e)
            {
                Logger.Send(LogType.Information, "", $"Error in Formula: [{calculation}] ({e.Message})");
                return date;
            }
        }

        static Bill()
        {
            LinkedProperties.Register<Bill,PaymentTermsLink,Guid>(x=>x.SupplierLink.Terms,x=>x.ID, x=>x.Terms.ID);
            LinkedProperties.Register<Bill,PaymentTermsLink,String>(x=>x.SupplierLink.Terms,x=>x.Code, x=>x.Terms.Code);
            LinkedProperties.Register<Bill,PaymentTermsLink,String>(x=>x.SupplierLink.Terms,x=>x.Description, x=>x.Terms.Description);
            LinkedProperties.Register<Bill,PaymentTermsLink,String>(x=>x.SupplierLink.Terms,x=>x.Calculation, x=>x.Terms.Calculation);
        }

        //[NullEditor]
        //public string Issues { get; set; }
        
        [EditorSequence("Issues", 1)]
        public ManagedProblem Problem { get; set; }
    }
}