using EnVisage.Code;
using System;
using System.Collections.Generic;
using System.Linq;
using EnVisage.Code.DAL.Mongo;
using EnVisage.Code.BLL;
using EnVisage.Models.ProjectDependencies;

namespace EnVisage.Models
{
    public class ScenarioDetailSnapshotModelBase
    {
        public ScenarioInfoModel Scenario { get; set; }
        public List<ExpenditureModel> AvailableExpenditures { get; set; }
        public List<ScenarioCalendarRateModel> Rates { get; set; }
        public List<TeamInScenarioModel> TeamsInScenario { get; set; }
        public bool NeedToRebind { get; set; }
        //8.24.16 start tab
        public long filterStartDate { get; set; }
        public long filterEndDate { get; set; }
        //8.24.16 end
        public bool NeedToRecalculateScenarioDetails { get; set; }
        public bool LocalRatesLoaded { get; set; }

        public List<WorkFlowCommand> WorkFlowActions { get; set; }
        public List<WorkFlowState> WorkFlowStates { get; set; }
        public string WorkFlowSchema { get; set; }
        public ScenarioDetailSnapshotModelBase()
        {
            AvailableExpenditures = new List<ExpenditureModel>();
            Rates = new List<ScenarioCalendarRateModel>();
            TeamsInScenario = new List<TeamInScenarioModel>();
            WorkFlowActions = new List<WorkFlowCommand>();
        }
    }

    public class ScenarioDetailSnapshotModel : ScenarioDetailSnapshotModelBase
    {
        public List<ScenarioExpenditureModel> Expenditures2Add { get; set; }
        public ScenarioCalendarModel Calendar { get; set; }
        public List<NoteModel> Notes { get; set; }

        public ScenarioDetailSnapshotModel()
            : base()
        {
        }
    }

    public class ScenarioDetailSnapshotRecalculationModel : ScenarioDetailSnapshotModelBase
    {
        public ScenarioCalendarModelBase Calendar { get; set; }
    }

    public class ScenarioDetailsSnapshotSaveModel
    {
        public ScenarioInfoModel Scenario { get; set; }
        public ScenarioCalendarModelBase Calendar { get; set; }
        public List<ExpenditureModel> AvailableExpenditures { get; set; }
        public List<TeamInScenarioModel> TeamsInScenario { get; set; }
        public List<NoteModel> Notes { get; set; }
        public List<NoteModel> NotesToDelete { get; set; }
        public List<WorkFlowCommand> WorkFlowActions { get; set; }
        public List<WorkFlowState> WorkFlowStates { get; set; }
        public string WorkFlowSchema { get; set; }
        public DependencyResolveModel Dependencies { get; set; }
		public ExpenditureCategoryChangesHistory Audit { get; set; }
		public ScenarioDetailsSnapshotSaveModel()
        {
            AvailableExpenditures = new List<ExpenditureModel>();
            TeamsInScenario = new List<TeamInScenarioModel>();
            WorkFlowActions = new List<WorkFlowCommand>();
			Audit = new ExpenditureCategoryChangesHistory();
		}

        public ScenarioDetailsSnapshotSaveModel(ScenarioCalendarMixModel model)
            : this()
        {
            if (model == null)
                return;

            Scenario = new ScenarioInfoModel(model);
            Calendar = new ScenarioCalendarModelBase()
            {
                Expenditures = model.Expenditures
            };
            AvailableExpenditures = model.Expenditures.Select(x => new ExpenditureModel()
            {
                Id = x.Value.ExpenditureCategoryId,
                Name = x.Value.ExpenditureCategoryName
            }).Distinct().ToList();
            //todo: copy dependencies here
        }
    }

    #region Model Classes

    public class ScenarioInfoModel
    {
        public Guid? Id { get; set; }
        public string Name { get; set; }
        public Guid? ParentId { get; set; }
        public long? ProjectDeadline { get; set; }
        public Guid? OldTemplateId { get; set; }
        public Guid TemplateId { get; set; }
        public long StartDate { get; set; }
        public long EndDate { get; set; }
        public decimal? ProjectedRevenue { get; set; }
        public long ActualStartDate { get; set; }
        public long ActualEndDate { get; set; }
        public bool GrowthScenario { get; set; }
        public ScenarioType Type { get; set; }
        public bool UseLMMargin { get; set; }
        public decimal? GrossMargin { get; set; }
        public decimal? LMMargin { get; set; }
        public decimal? GreenIndicator { get; set; }
        public decimal? YellowIndicator { get; set; }
        public decimal? RedIndicator { get; set; }
        public int Duration { get; set; }
        public decimal? TDDirectCosts { get; set; }
        public decimal CGSplit { get; set; }
        public decimal EFXSplit { get; set; }
        public bool FreezeRevenue { get; set; }
        public int Shots { get; set; }
        public bool IsActiveScenario { get; set; }
        public long? DateForStartOfChanges { get; set; }
        public CostSavingSnapshotModel CostSavings { get; set; }
        public SaveAsScenario? SaveAs { get; set; }
        public bool SaveAsDraft { get; set; }
        public bool NeedToAdjustMargin { get; set; }
        public AdjustScenarioDetailsDistribution.DistributionType DistributionType { get; set; }
        public bool IsBottomUp { get; set; }
        public List<UDFValueCollection> UserDefinedFields { get; set; }

		public bool? AdjustMarginRased { get; set; }
		public long? DateForStartOfChangesOld { get; set; }

        #region Constructors

        public ScenarioInfoModel()
        {

        }

        public ScenarioInfoModel(ScenarioCalendarMixModel model)
            : this()
        {
            if (model == null)
                return;

            Id = model.Id;
            ParentId = model.ParentId;
            TemplateId = model.TemplateId;
            Name = model.Name;
            StartDate = model.StartDate;
            EndDate = model.EndDate;
            GrowthScenario = model.GrowthScenario;
            Type = model.Type;
            Duration = model.Duration;
            IsActiveScenario = true;
            SaveAs = SaveAsScenario.New;
            SaveAsDraft = false;
            NeedToAdjustMargin = false;
            IsBottomUp = model.IsBottomUp;

            if (model.FinInfo != null)
            {
                ProjectedRevenue = model.FinInfo.ProjectedRevenue;
                UseLMMargin = model.FinInfo.UseLMMargin;
                GrossMargin = model.FinInfo.GrossMargin;
                LMMargin = model.FinInfo.LMMargin;
                CGSplit = model.FinInfo.LaborSplitPercentage / (decimal)100.0;
                EFXSplit = model.FinInfo.EFXSplit;
                TDDirectCosts = model.FinInfo.TDDirectCosts;
                CostSavings = model.FinInfo.CostSaving;
            }
        }

        #endregion
    }

    public class ScenarioCalendarFilterModel
    {
        /// <summary>String representation for <see cref="ExpenditureCategoryModel.CategoryTypes"/></summary>
        public string CategoryType { get; set; }

        /// <summary>String representation for <see cref="ExpenditureCategoryModel.CgEfx"/></summary>
        public string LaborMaterials { get; set; }
        public Guid? IncomeType { get; set; }
        public Guid? GLAccount { get; set; }
        public Guid? CreditDepartment { get; set; }
        public IEnumerable<Guid> SelectedExpCats { get; set; }
        public bool IsTableModeQuantity { get; set; }
        public bool IsViewModeMonth { get; set; }
        public bool ShowActuals { get; set; }
        public bool IsUOMHours { get; set; }
        public bool ShowAvgTotals { get; set; }
    }

    public class ScenarioCalendarRateModel
    {
        public Guid expCatId { get; set; }
        public List<RateValueModel> rateValues { get; set; }
    }

    public class RateValueModel
    {
        public long weekStartDate { get; set; }
        public long weekEndDate { get; set; }
        public decimal rateValue { get; set; }
    }

    public class CollapsableModelBase
    {
        public bool Collapsed { get; set; }
        public string CollapsedClass { get; set; }
        public CollapsableModelBase()
        {
            Collapsed = true;
            CollapsedClass = "fa-plus-square";
        }
    }

    public class ScenarioDetailsItem
    {
        public Guid? ForecastId { get; set; }
        public Guid? ActualsId { get; set; }
        public decimal? ForecastQuantity { get; set; }
        public decimal? ActualsQuantity { get; set; }
        public decimal? ForecastCost { get; set; }
        public decimal? ActualsCost { get; set; }
        public int WeekOrdinal { get; set; }
        public bool Changed { get; set; }
    }

    public class ExpenditureDetail : CollapsableModelBase
    {
        public Guid ExpenditureCategoryId { get; set; }
        public string ExpenditureCategoryName { get; set; }
        public int Type { get; set; }
        public int UseType { get; set; } //default is 1
        public string CGEFX { get; set; }
        public Guid GLId { get; set; }
        public Guid UOMId { get; set; }
        public Guid CreditId { get; set; }
        public Guid? SystemAttributeOne { get; set; }
        public Guid? SystemAttributeTwo { get; set; }
        public int? SortOrder { get; set; }
        public decimal UOMValue { get; set; }
        public Dictionary<string, ScenarioDetailsItem> Details { get; set; }
        public Dictionary<string, ExpenditureDetailsTeam> Teams { get; set; }
        public bool AllowResourceAssignment { get; set; }
        /// <summary>
        /// Added for RMO to store EC unassigned to any team values
        /// </summary>
        public Dictionary<string, decimal> UnassignedAllocations { get; set; }

        public ExpenditureDetail()
            : base()
        {
            Details = new Dictionary<string, ScenarioDetailsItem>();
            Teams = new Dictionary<string, ExpenditureDetailsTeam>();
            UnassignedAllocations = new Dictionary<string, decimal>();
        }

        public override bool Equals(object obj)
        {
            if (obj == null)
                return false;

            if (!(obj is ExpenditureDetail))
                return false;

            return ExpenditureCategoryId == (obj as ExpenditureDetail).ExpenditureCategoryId;
        }

        public override int GetHashCode()
        {
            return ExpenditureCategoryId.GetHashCode();
        }

        public static explicit operator ExpenditureDetail(MixExpenditureAllocation obj)
        {
            var model = new ExpenditureDetail
            {
                CGEFX = obj.CGEFX,
                CreditId = obj.CreditId,
                ExpenditureCategoryId = obj.ExpCatId,
                ExpenditureCategoryName = obj.ExpenditureCategoryName,
                GLId = obj.GLId,
                SortOrder = obj.SortOrder,
                SystemAttributeOne = obj.SysAttrOne,
                SystemAttributeTwo = obj.SysAttrTwo,
                Teams = new Dictionary<string, ExpenditureDetailsTeam>(),
                Type = obj.Type,
                UOMId = obj.UOMId,
                UOMValue = obj.UOMValue,
                UseType = obj.UseType,
				AllowResourceAssignment = obj.AllowResourceAssignment,

                Details = obj.Allocations.Where(x => x.Value != null).Select((pair, i) => new { pair.Key, pair.Value, index = i }).ToDictionary(key => key.Key, value => new ScenarioDetailsItem
                {
                    ForecastId = Guid.NewGuid(),
                    ForecastQuantity = value.Value.Quantity,
                    ForecastCost = value.Value.Cost,
                    WeekOrdinal = value.index + 1
                })
            };

            if ((obj.UnassignedAllocations != null) && (obj.UnassignedAllocations.Keys.Count > 0))
            {
                model.UnassignedAllocations = obj.UnassignedAllocations.Select(item =>
                    new KeyValuePair<string, decimal>(item.Key, item.Value))
                    .ToDictionary(i1 => i1.Key, i2 => i2.Value);
            }
            return model;
        }

        public void CopyTo(MixExpenditureAllocation expenditureAllocation)
        {
            expenditureAllocation.Allocations =
                Details.Select(pair => new { pair.Key, pair.Value.ForecastQuantity, pair.Value.ForecastCost })
                       .ToDictionary(key => key.Key, value => new QuantityItem()
                       {
                           Quantity = value.ForecastQuantity ?? 0,
                           Cost = value.ForecastCost ?? 0
                       });
            expenditureAllocation.CGEFX = CGEFX;
            expenditureAllocation.CreditId = CreditId;
            expenditureAllocation.ExpCatId = ExpenditureCategoryId;
            expenditureAllocation.ExpenditureCategoryName = ExpenditureCategoryName;
            expenditureAllocation.GLId = GLId;
            expenditureAllocation.SortOrder = SortOrder;
            expenditureAllocation.SysAttrOne = SystemAttributeOne;
            expenditureAllocation.SysAttrTwo = SystemAttributeTwo;
            expenditureAllocation.Type = Type;
            expenditureAllocation.UOMId = UOMId;
            expenditureAllocation.UOMValue = UOMValue;
            expenditureAllocation.UseType = UseType;
			expenditureAllocation.AllowResourceAssignment = AllowResourceAssignment;

			if ((UnassignedAllocations != null) && (UnassignedAllocations.Keys.Count > 0))
            {
                expenditureAllocation.UnassignedAllocations = UnassignedAllocations.Select(item =>
                    new KeyValuePair<string, decimal>(item.Key, item.Value))
                    .ToDictionary(i1 => i1.Key, i2 => i2.Value);
            }
        }
    }

    public class ExpenditureDetailsTeam : CollapsableModelBase
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public bool IsAccessible { get; set; }

        /// <summary>Current allocation for scenario in certain EC</summary>
        public Dictionary<string, decimal> QuantityValues { get; set; }

        /// <summary>Quantity available for allocation in certain EC</summary>
        public Dictionary<string, decimal> RestQuantityValues { get; set; }

        /// <summary>All team capacity in certain EC</summary>
        public Dictionary<string, decimal> CapacityQuantityValues { get; set; }

        /// <summary>All resources from current team allocated in certain EC</summary>
        public Dictionary<string, TeamResource> Resources { get; set; }

        /// <summary>All resources from current team available for allocation in certain EC</summary>
        public Dictionary<string, TeamResource> AllResources { get; set; }

        public bool Changed { get; set; }
        public bool CanBeDeleted { get; set; }

        public ExpenditureDetailsTeam()
            : base()
        {
            AllResources = new Dictionary<string, TeamResource>();
            Resources = new Dictionary<string, TeamResource>();
            QuantityValues = new Dictionary<string, decimal>();
            RestQuantityValues = new Dictionary<string, decimal>();
            CapacityQuantityValues = new Dictionary<string, decimal>();
        }

        public static explicit operator ExpenditureDetailsTeam(MixTeamAllocation obj)
        {
            var model = new ExpenditureDetailsTeam
            {
                Id = Guid.Parse(obj.TeamId),
                Name = obj.Name,
                QuantityValues = obj.Allocations,
                AllResources = (obj.AllResources ?? new Dictionary<string, MixResourceAllocation>()).Select(t => (TeamResource)t.Value).ToDictionary(key => key.Id.ToString())
            };
            return model;
        }

        public void CopyTo(MixTeamAllocation teamAllocation)
        {
            teamAllocation.Name = Name;
            teamAllocation.TeamId = Id.ToString();
            teamAllocation.Allocations = QuantityValues;
            teamAllocation.AllResources = (AllResources ?? new Dictionary<string, TeamResource>()).Select(t =>
                {
                    var alloc = new MixResourceAllocation();
                    t.Value.CopyTo(alloc);
                    return alloc;
                }).ToDictionary(key => key.ResourceId);
        }
    }
    /// <summary>
    /// Represents info about the resource within one of the teams.
    /// </summary>
    public class TeamResource
    {
        public Guid Id { get; set; }
        public Guid ExpenditureCategoryId { get; set; }
        public string Name { get; set; }
        public bool IsActiveEmployee { get; set; }
        public Dictionary<string, decimal> CapacityQuantityValues { get; set; }
        public Dictionary<string, decimal> QuantityValues { get; set; }
        public Dictionary<string, decimal> RestQuantityValues { get; set; }
        public Dictionary<string, bool> ReadOnly { get; set; }
        public bool Changed { get; set; }
        public bool Deleted { get; set; }
        /// <summary>
        /// Gets or sets a value indicating start of work (milliseconds from Unix date) of the specified resource in the specified team.
        /// </summary>
        public long StartDate { get; set; }
        /// <summary>
        /// Gets or sets a value indicating end of work (milliseconds from Unix date) of the specified resource in the specified team.
        /// </summary>
        public long? EndDate { get; set; }
        /// <summary>
        /// Gets or sets a value indicating percent of involvment of the resource within the specified team.
        /// </summary>
        /// <remarks>
        /// Min value = 0. Max value = 1. Value=0.75 means 75%.
        /// </remarks>
        public decimal Allocation { get; set; }

        public TeamResource()
        {
            CapacityQuantityValues = new Dictionary<string, decimal>();
            QuantityValues = new Dictionary<string, decimal>();
            RestQuantityValues = new Dictionary<string, decimal>();
            ReadOnly = new Dictionary<string, bool>();
        }
        public static explicit operator TeamResource(MixResourceAllocation obj)
        {
            var model = new TeamResource
            {
                Id = Guid.Parse(obj.ResourceId),
                ExpenditureCategoryId = obj.ExpCatId,
                Name = obj.Name,
                QuantityValues = obj.Allocations
            };
            return model;
        }
        public void CopyTo(MixResourceAllocation allocation)
        {
            allocation.Name = Name;
            allocation.ResourceId = Id.ToString();
            allocation.Allocations = QuantityValues;
        }
    }

    public class TeamResourceSortable : TeamResource
    {
        public string LastName { get; set; }
		public List<TeamMembershipModel> Teams { get; set; }

		public TeamResourceSortable() : base()
		{
			Teams = new List<TeamMembershipModel>();
		}
	}

	public class ScenarioCalendarModelBase
    {
        public Dictionary<string, ExpenditureDetail> Expenditures { get; set; }
        public List<VW_ScenarioAndProxyDetails> GetScenarioDetails(bool needForecast)
        {
            var scenarioDetails = new List<VW_ScenarioAndProxyDetails>();

            if (Expenditures != null && Expenditures.Count > 0)
            {
				// we have to create new items only for those dates where scenario has forecast data
				// e.g.:
				// actuals:     11.09.2015, 18.09.2015
				// forecast:                            25.09.2015, 02.10.2015, 09.10.2015
				// so we have to create new forecast items for categories which exist only in actuals only for 3 dates which correspond to forecast data
				var forecastDates = Expenditures.SelectMany(x => x.Value.Details)
                                                .Where(x => x.Value?.ForecastId != null && x.Value.ForecastId != Guid.Empty)
                                                .Select(x => x.Key).Distinct().ToList();

                foreach (var ec in Expenditures)
                {
                    foreach (var detail in ec.Value.Details)
                    {
                        if (needForecast && (!detail.Value.ForecastId.HasValue || Guid.Empty.Equals(detail.Value.ForecastId)))
                        {
                            // this condition must be here because if current week corresponds to left or right side of actuals (befor or after forecast)
                            // we do not need to create forecast items for these dates
                            if (forecastDates.Contains(detail.Key))
                            {
                                // SA. ENV-667. Create new dataitem
                                scenarioDetails.Add(new VW_ScenarioAndProxyDetails
                                {
                                    Id = Guid.NewGuid(),
                                    ExpenditureCategoryId = ec.Value.ExpenditureCategoryId,
                                    ExpenditureCategoryName = String.Empty,                     // SA. ENV-839
                                    ExpCategoryWithCcName = ec.Value.ExpenditureCategoryName,   // SA. ENV-839
                                    WeekEndingDate = Utils.ConvertFromUnixDate(long.Parse(detail.Key)),
                                    WeekOrdinal = detail.Value.WeekOrdinal,
                                    Quantity = detail.Value.ForecastQuantity ?? 0,
                                    Cost = detail.Value.ForecastCost ?? 0,
                                    Type = ec.Value.Type,
                                    UseType = ec.Value.UseType,
                                    CGEFX = ec.Value.CGEFX,
                                    GLId = ec.Value.GLId,
                                    UOMId = ec.Value.UOMId,
                                    CreditId = ec.Value.CreditId,
                                    SystemAttributeOne = ec.Value.SystemAttributeOne,
                                    SystemAttributeTwo = ec.Value.SystemAttributeTwo,
                                    SortOrder = ec.Value.SortOrder,
                                    AllowResourceAssignment = ec.Value.AllowResourceAssignment
                                });
                            }

                            continue;
                        }

                        if (!needForecast && !detail.Value.ActualsId.HasValue)
                            continue;

                        scenarioDetails.Add(new VW_ScenarioAndProxyDetails
                        {
                            Id = needForecast ? detail.Value.ForecastId.Value : detail.Value.ActualsId.Value,
                            ExpenditureCategoryId = ec.Value.ExpenditureCategoryId,
                            ExpenditureCategoryName = String.Empty,     // SA. ENV-839
                            ExpCategoryWithCcName = ec.Value.ExpenditureCategoryName, // SA. ENV-839
                            WeekEndingDate = Utils.ConvertFromUnixDate(long.Parse(detail.Key)),
                            WeekOrdinal = detail.Value.WeekOrdinal,
                            Quantity = needForecast ? detail.Value.ForecastQuantity : detail.Value.ActualsQuantity,
                            Cost = needForecast ? detail.Value.ForecastCost : detail.Value.ActualsCost,
                            Type = ec.Value.Type,
                            UseType = ec.Value.UseType,
                            CGEFX = ec.Value.CGEFX,
                            GLId = ec.Value.GLId,
                            UOMId = ec.Value.UOMId,
                            CreditId = ec.Value.CreditId,
                            SystemAttributeOne = ec.Value.SystemAttributeOne,
                            SystemAttributeTwo = ec.Value.SystemAttributeTwo,
                            SortOrder = ec.Value.SortOrder,
                            AllowResourceAssignment = ec.Value.AllowResourceAssignment
                        });
                    }
                }
            }

            return scenarioDetails;
        }

        public Dictionary<string, Dictionary<string, ExpenditureDetailsTeam>> GetTeams()
        {
            if (Expenditures == null || Expenditures.Count <= 0)
                return new Dictionary<string, Dictionary<string, ExpenditureDetailsTeam>>();

            return Expenditures.Select(x => new
            {
                ExpenditureId = x.Key,
                x.Value.Teams
            }).ToDictionary(x => x.ExpenditureId, g => g.Teams);
        }

        public ScenarioCalendarModelBase()
        {
            Expenditures = new Dictionary<string, ExpenditureDetail>();
        }
    }

    public class ScenarioCalendarModel : ScenarioCalendarModelBase
    {
        public Dictionary<string, List<ScenarioDetailsModel.HeaderBase>> Headers { get; set; }

        public ScenarioCalendarModel()
            : base()
        {
            Headers = new Dictionary<string, List<ScenarioDetailsModel.HeaderBase>>();
        }
    }

    public class CostSavingSnapshotModel
    {
        public decimal? CostSavings { get; set; }
        public long? CostSavingStartDate { get; set; }
        public long? CostSavingEndDate { get; set; }
        public bool CostSavingType { get; set; }
        public string CostSavingDescription { get; set; }
        public List<ScenarioCostSavingModel> CostSavingItems { get; set; }

        public CostSavingSnapshotModel()
        {
            CostSavingItems = new List<ScenarioCostSavingModel>();
        }
    }

    public class TeamInScenarioModel
    {
        public Guid TeamId { get; set; }
        public short Allocation { get; set; }
        public bool IsNew { get; set; }
        public bool IsAdd { get; set; }
        public bool IsAccessible { get; set; }
        public bool CanBeDeleted { get; set; }
    }

    /// <summary>
    /// Information about versions of ralated item
    /// </summary>
    public class ItemVersionInfo
    {
        public ItemVersionInfo()
        {
            RmoVersion = 1;
            ChangedInMain = false;
            ChangedInRmo = false;
        }

        public ulong? SourceVersion { get; set; }
        public ulong RmoVersion { get; set; }
        public bool ChangedInMain { get; set; }
        public bool ChangedInRmo { get; set; }
    }

    public class ScenarioCalendarSelectItemTeamModel
    {
        public Guid Id { get; set; }
        public string Name { get; set; }
        public List<Guid> Expenditures { get; set; }

        #region Constructors

        public ScenarioCalendarSelectItemTeamModel()
        {
            Expenditures = new List<Guid>();
        }

        #endregion
    }

	public class ExpenditureCategoryChangeCurveModel
	{
		public Guid FromExpenditureId { get; set; }
		public Guid ToExpenditureId { get; set; }
	}

	public class ExpenditureCategoryReallocateResourceModel
	{
		public Guid SourceExpCat { get; set; }
		public Guid TargetExpCat { get; set; }
		public long SourceWeekEnding { get; set; }
		public long TargetWeekEnding { get; set; }
		public short Percentage { get; set; }
		public string ReallocateBy { get; set; }
		public Guid UseCurveFromExpenditureId { get; set; }
	}

	public class ExpenditureCategoryRoundModel
	{
		public List<string> ExpCats { get; set; }
		public long StartDate { get; set; }
		public long EndDate { get; set; }
		public string DecimalPlaces { get; set; }
	}

	public class ExpenditureCategoryChangesHistory
	{
		public Dictionary<string, ExpenditureCategoryChangeCurveModel> CurveChanges { get; set; }
		public Dictionary<string, ExpenditureCategoryReallocateResourceModel> Reallocations { get; set; }
		public Dictionary<string, ExpenditureCategoryRoundModel> Roundings { get; set; }

		public ExpenditureCategoryChangesHistory()
		{
			CurveChanges = new Dictionary<string, ExpenditureCategoryChangeCurveModel>();
			Reallocations = new Dictionary<string, ExpenditureCategoryReallocateResourceModel>();
			Roundings = new Dictionary<string, ExpenditureCategoryRoundModel>();
		}
}

	#endregion
}