using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using InABox.Core;
using Newtonsoft.Json;

namespace Comal.Classes
{
    public class JobStageJobLookup : LookupDefinitionGenerator<JobStage, Job>
    {
        public override Filter<JobStage> DefineFilter(Job[] items)
        {
            if (items.Length == 1)
                return new Filter<JobStage>(x => x.Job.ID).IsEqualTo(items.First().ID).And(x => x.IsHeader).IsEqualTo(false);
            return new Filter<JobStage>(x => x.ID).IsEqualTo(Guid.Empty);
        }

        public override Columns<Job> DefineFilterColumns()
            => Columns.None<Job>().Add(x => x.ID);
    }
    
    
    [UserTracking("Gantt Charts")]
    public class JobStageType : Entity, IRemotable, IPersistent, ILicense<ProjectManagementLicense>
    {
        [EditorSequence(1)]
        [UniqueCodeEditor(Visible = Visible.Default, Editable = Editable.Enabled)]
        public string Code { get; set; }

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

        [EditorSequence(3)]
        [ColorEditor]
        public string Color { get; set; }
    }
    
    public class JobStageTypeLink : EntityLink<JobStageType>
    {
        [CodePopupEditor(typeof(JobStageType), CanAdd = true)]
        public override Guid ID { get; set; }
        
        [EditorSequence(1)]
        [CodeEditor(Visible = Visible.Default, Editable = Editable.Hidden)]
        public string Code { get; set; }

        [EditorSequence(2)]
        [CodeEditor(Visible = Visible.Optional, Editable = Editable.Hidden)]
        public string Description { get; set; }

        [EditorSequence(3)]
        [ColorEditor(Visible = Visible.Optional, Editable = Editable.Hidden)]
        public string Color { get; set; }
    }
    
    public class JobStageTypeLookups : EntityLookup<JobStageType>
    {
        public override Filter<JobStageType> DefineFilter() 
            => new Filter<JobStageType>().All();
        
        public override Columns<JobStageType> DefineColumns() 
            => Columns.None<JobStageType>()
                .Add(x => x.ID)
                .Add(x => x.Code)
                .Add(x => x.Description)
                .Add(x=>x.Color);
        
        public override SortOrder<JobStageType>? DefineSortOrder() 
            => new SortOrder<JobStageType>(x=>x.Code, SortDirection.Ascending);

        public override string FormatLookup(Dictionary<string, object?> values, IEnumerable<string> exclude) 
            => values.TryGetValue("Description", out var description) ? description?.ToString() ?? "" : "";
    }
    
    
    [UserTracking("Gantt Charts")]
    public class JobStage : Entity, IRemotable, IPersistent, ISequenceable, INotifyPropertyChanged, ILicense<ProjectManagementLicense>, IOneToMany<Job>,
        IChildEntityLookup<Job, JobStage, JobStageJobLookup>
    {
        private bool bChanging;

        [EntityRelationship(DeleteAction.Cascade)]
        [EditorSequence(0)]
        public JobLink Job { get; set; }

        [NullEditor]
        public bool IsHeader { get; set; }

        private class JobStageLookup : LookupDefinitionGenerator<JobStage, JobStage>
        {
            public override Filter<JobStage> DefineFilter(JobStage[] items)
            {
                if (items.Length == 1)
                    return new Filter<JobStage>(x => x.Job.ID).IsEqualTo(items.First().Job.ID).And(x => x.IsHeader).IsEqualTo(false);
                return new Filter<JobStage>(x => x.ID).IsEqualTo(Guid.Empty);
            }

            public override Columns<JobStage> DefineFilterColumns()
                => Columns.None<JobStage>().Add(x => x.Job.ID);
        }
        [LookupDefinition(typeof(JobStageLookup))]
        [NullEditor]
        public JobStageLink Parent { get; set; }
        
        [EditorSequence(1)]
        public JobStageTypeLink Type { get; set; }

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

        [EditorSequence(3)]
        [NullEditor]
        public JobStageCalendarLink Calendar { get; set; }

        [DateEditor]
        [EditorSequence(4)]
        public DateTime StartDate { get; set; }

        [IntegerEditor]
        [EditorSequence(5)]
        public int WorkDays { get; set; }

        [DateEditor]
        [EditorSequence(6)]
        public DateTime EndDate { get; set; }

        [DoubleEditor]
        [EditorSequence(7)]
        public double SupervisionHours { get; set; }

        [DoubleEditor]
        [EditorSequence(8)]
        public double TradesHours { get; set; }

        [DoubleEditor]
        [EditorSequence(9)]
        public double ApprenticeHours { get; set; }

        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence("Summary", 1)]
        public double TotalHours { get; set; }

        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence("Summary", 2)]
        public double Supervisors { get; set; }

        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence("Summary", 3)]
        public double Tradespersons { get; set; }

        [DoubleEditor(Editable = Editable.Disabled)]
        [EditorSequence("Summary", 4)]
        public double Apprentices { get; set; }

        [NullEditor]
        public long Sequence { get; set; }

        protected override void DoPropertyChanged(string name, object? before, object? after)
        {
            base.DoPropertyChanged(name, before, after);

            if (bChanging)
                return;
            bChanging = true;

            if (name.Equals("WorkDays"))
            {
                EndDate = Calendar.CalculateEndDate(StartDate, (int)after);
                Tradespersons = Calendar.CalculateWorkers(StartDate, EndDate, TradesHours);
                Supervisors = Calendar.CalculateWorkers(StartDate, EndDate, SupervisionHours);
                Apprentices = Calendar.CalculateWorkers(StartDate, EndDate, ApprenticeHours);
            }

            else if (name.Equals("EndDate"))
            {
                WorkDays = Calendar.CalculateWorkDays(StartDate, (DateTime)after);
                Tradespersons = Calendar.CalculateWorkers(StartDate, (DateTime)after, TradesHours);
                Supervisors = Calendar.CalculateWorkers(StartDate, (DateTime)after, SupervisionHours);
                Apprentices = Calendar.CalculateWorkers(StartDate, (DateTime)after, ApprenticeHours);
            }

            else if (name.Equals("TradesHours"))
            {
                Tradespersons = Calendar.CalculateWorkers(StartDate, EndDate, (double)after);
                TotalHours = SupervisionHours + (double)after + ApprenticeHours;
            }

            else if (name.Equals("SupervisionHours"))
            {
                Supervisors = Calendar.CalculateWorkers(StartDate, EndDate, (double)after);
                TotalHours = (double)after + TradesHours + ApprenticeHours;
            }

            else if (name.Equals("ApprenticeHours"))
            {
                Apprentices = Calendar.CalculateWorkers(StartDate, EndDate, (double)after);
                TotalHours = SupervisionHours + TradesHours + (double)after;
            }

            bChanging = false;
        }
    }
}