using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using EnVisage.Code.BLL;
using EnVisage.Models;
using EnVisage.Models.Entities;
using System.Data.Entity;
using System.Xml.Serialization;
using System.IO;
using System.Xml;

namespace EnVisage.Code
{
    public static class Utils
    {
        public static T TrimStringProperties<T>(this T obj)
        {
            // ReSharper disable CompareNonConstrainedGenericWithNull

            if (obj == null)
                throw new ArgumentNullException();
            foreach (PropertyDescriptor prop in TypeDescriptor.GetProperties(obj))
            {
                if (prop.PropertyType != typeof(string) || prop.IsReadOnly)
                    continue;

                var val = prop.GetValue(obj) as string;
                if (val != null)
                    prop.SetValue(obj, val.Trim());
            }

            return obj;

            // ReSharper restore CompareNonConstrainedGenericWithNull
        }

        public static IEnumerable<SelectListItem> GetFiscalCalendarTypes()
        {
            return new List<SelectListItem>
                {
                    new SelectListItem
                        {
                            Text = "",
                            Value = ""
                        },
                    new SelectListItem
                        {
                            Text = FiscalCalendarModel.FiscalCalendarType.CalendarYear.ToDisplayValue(),
                            Value = FiscalCalendarModel.FiscalCalendarType.CalendarYear.ToString()
                        },
                    new SelectListItem
                        {
                            Text = FiscalCalendarModel.FiscalCalendarType.Calendar445.ToDisplayValue(),
                            Value = FiscalCalendarModel.FiscalCalendarType.Calendar445.ToString()
                        },
                    new SelectListItem
                        {
                            Text = FiscalCalendarModel.FiscalCalendarType.Calendar454.ToDisplayValue(),
                            Value = FiscalCalendarModel.FiscalCalendarType.Calendar454.ToString()
                        },
                    new SelectListItem
                        {
                            Text = FiscalCalendarModel.FiscalCalendarType.Calendar544.ToDisplayValue(),
                            Value = FiscalCalendarModel.FiscalCalendarType.Calendar544.ToString()
                        }
                };
        }

        public static IEnumerable<SelectListItem> GetWeekDays()
        {
            return new List<SelectListItem>
                {
                    new SelectListItem
                        {
                            Text = DayOfWeek.Monday.ToDisplayValue(),
                            Value = DayOfWeek.Monday.ToString()
                        },
                    new SelectListItem
                        {
                            Text = DayOfWeek.Tuesday.ToDisplayValue(),
                            Value = DayOfWeek.Tuesday.ToString()
                        },
                    new SelectListItem
                        {
                            Text = DayOfWeek.Wednesday.ToDisplayValue(),
                            Value = DayOfWeek.Wednesday.ToString()
                        },
                    new SelectListItem
                        {
                            Text = DayOfWeek.Thursday.ToDisplayValue(),
                            Value = DayOfWeek.Thursday.ToString()
                        },
                    new SelectListItem
                        {
                            Text = DayOfWeek.Friday.ToDisplayValue(),
                            Value = DayOfWeek.Friday.ToString()
                        },
                    new SelectListItem
                        {
                            Text = DayOfWeek.Saturday.ToDisplayValue(),
                            Value = DayOfWeek.Saturday.ToString()
                        },
                    new SelectListItem
                        {
                            Text = DayOfWeek.Sunday.ToDisplayValue(),
                            Value = DayOfWeek.Sunday.ToString()
                        }
                };
        }

        public static IEnumerable<SelectListItem> GetWeekEndingTypes()
        {
            return new List<SelectListItem>
                {
                    new SelectListItem
                        {
                            Text = "",
                            Value = ""
                        },
                    new SelectListItem
                        {
                            Text = FiscalCalendarModel.CalendarYearType.StandardYear.ToDisplayValue(),
                            Value = FiscalCalendarModel.CalendarYearType.StandardYear.ToString()
                        },
                    new SelectListItem
                        {
                            Text = FiscalCalendarModel.CalendarYearType.Only52Weeks.ToDisplayValue(),
                            Value = FiscalCalendarModel.CalendarYearType.Only52Weeks.ToString()
                        },
                    new SelectListItem
                        {
                            Text = FiscalCalendarModel.CalendarYearType.LastWeekDay.ToDisplayValue(),
                            Value = FiscalCalendarModel.CalendarYearType.LastWeekDay.ToString()
                        }
                };
        }

        public static IEnumerable<SelectListItem> GetOccurrenceTypes()
        {
            return new List<SelectListItem>
                {
                    new SelectListItem 
                        {
                            Text = HolidayModel.HolidayOccurrence.SameDayEveryYear.ToDisplayValue(),
                            Value = HolidayModel.HolidayOccurrence.SameDayEveryYear.ToString()
                        },
                    new SelectListItem
                        {
                            Text = HolidayModel.HolidayOccurrence.FirstDayOfWeek.ToDisplayValue(),
                            Value = HolidayModel.HolidayOccurrence.FirstDayOfWeek.ToString()
                        },
                    new SelectListItem
                        {
                            Text = HolidayModel.HolidayOccurrence.SecondDayOfWeek.ToDisplayValue(),
                            Value = HolidayModel.HolidayOccurrence.SecondDayOfWeek.ToString()
                        },
                    new SelectListItem
                        {
                            Text = HolidayModel.HolidayOccurrence.ThirdDayOfWeek.ToDisplayValue(),
                            Value = HolidayModel.HolidayOccurrence.ThirdDayOfWeek.ToString()
                        },
                    new SelectListItem
                        {
                            Text = HolidayModel.HolidayOccurrence.FourthDayOfWeek.ToDisplayValue(),
                            Value = HolidayModel.HolidayOccurrence.FourthDayOfWeek.ToString()
                        },
                    new SelectListItem
                        {
                            Text = HolidayModel.HolidayOccurrence.LastDayOfWeek.ToDisplayValue(),
                            Value = HolidayModel.HolidayOccurrence.LastDayOfWeek.ToString()
                        },
                    new SelectListItem
                        {
                            Text = HolidayModel.HolidayOccurrence.VariesEveryYear.ToDisplayValue(),
                            Value = HolidayModel.HolidayOccurrence.VariesEveryYear.ToString()
                        },
                    new SelectListItem
                        {
                            Text = HolidayModel.HolidayOccurrence.OnlyOnce.ToDisplayValue(),
                            Value = HolidayModel.HolidayOccurrence.OnlyOnce.ToString()
                        }
                };
        }

        public static IEnumerable<SelectListItem> GetMonths()
        {
            var options = new List<SelectListItem>();
            var month = new DateTime(2000, 1, 1);
            for (var i = 0; i < 12; i++)
            {
                var nextMonth = month.AddMonths(i);
                options.Add(new SelectListItem
                    {
                        Value = nextMonth.Month.ToString(CultureInfo.InvariantCulture),
                        Text = nextMonth.ToString("MMMM")
                    });
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetMonthDays(int month)
        {
            var date = new DateTime(2000, month, 1);
            var options = new List<SelectListItem>();
            while (date.Month == month)
            {
                options.Add(new SelectListItem
                    {
                        Value = date.Day.ToString(CultureInfo.InvariantCulture),
                        Text = date.Day.ToString(CultureInfo.InvariantCulture)
                    });
                date = date.AddDays(1);

                // do not display 29 of February
                if (date.Month == 2 && date.Day == 29)
                    break;
            }
            return options;
        }

        /// <summary>
        /// Prepares a detailed info about provided object including all property values of target and all inner objects.
        /// </summary>
        /// <param name="obj">An object whose property values will be gathered into <see cref="StringBuilder"/> object <paramref name="sb"/>.</param>
        /// <param name="sb">A <see cref="StringBuilder"/> object that will contain gathered info.</param>
        /// <param name="tab">Initial padding of the object level. "" for the target object, " " for the 1st level inner object, etc..</param>
        public static void DebugObjectProperties(this object obj, StringBuilder sb, string tab = " ")
        {
            foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(obj))
            {
                if (property.Attributes.OfType<SkipLoggingAttribute>().Any())
                    continue;

                var value = property.GetValue(obj);
                sb.AppendLine(string.Format("{0}{1}: {2}", tab, property.DisplayName, value));
                if (property.PropertyType != typeof(int) && property.PropertyType != typeof(string) && property.PropertyType != typeof(decimal) &&
                    property.PropertyType != typeof(float) && property.PropertyType != typeof(DateTime) && property.PropertyType != typeof(int?) &&
                    property.PropertyType != typeof(decimal?) && property.PropertyType != typeof(DateTime?) &&
                    TypeDescriptor.GetProperties(value).Count > 0)
                    DebugObjectProperties(value, sb, tab + " ");
            }
        }

        public static IEnumerable<SelectListItem> GetParentCompanies()
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var parentCompanies = dbContext.Companies.AsNoTracking().Where(t => t.ParentCompanyId == null);
                options.AddRange(parentCompanies.Select(parentCompany => new SelectListItem()
                    {
                        Value = parentCompany.Id.ToString(),
                        Text = parentCompany.Name
                    }));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetStatuses(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var statuses = dbContext.Status.AsNoTracking().Where(t => !t.IsSystem).OrderBy(s => s.Name);
                options.AddRange(statuses.Select(s => new SelectListItem()
                {
                    Value = s.Id.ToString(),
                    Text = s.Name
                }));
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetTypes()
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var types = dbContext.Types.AsNoTracking().Where(t => !t.IsSystem).OrderBy(t => t.Name);
                options.AddRange(types.Select(t => new SelectListItem()
                {
                    Value = t.Id.ToString(),
                    Text = t.Name
                }));
            }
            return options;
        }

        public static List<KeyValuePair<string, List<TypeModel>>> GetTypesWithGroups()
        {
            SortedDictionary<string, List<TypeModel>> typeDict = new SortedDictionary<string, List<TypeModel>>();
            typeDict.Add("No Group", new List<TypeModel>());

            using (var dbContext = new EnVisageEntities())
            {
                var types = dbContext.Types.AsNoTracking().Where(t => !t.IsSystem).OrderBy(t => t.Name);
                foreach (Type t in types)
                {
                    if (t.Type2TypeGroup.Count == 0)
                    {
                        typeDict["No Group"].Add((TypeModel)t);
                    }

                    foreach (Type2TypeGroup t2g in t.Type2TypeGroup)
                    {
                        if (!typeDict.ContainsKey(t2g.TypeGroup.Name))
                            typeDict.Add(t2g.TypeGroup.Name, new List<TypeModel>());

                        typeDict[t2g.TypeGroup.Name].Add((TypeModel)t);
                    }
                }
            }

            return typeDict.ToList();
        }

        //public static IEnumerable<SelectListItem> GetTemplates()
        //{
        //    var options = new List<SelectListItem>();
        //    options.Add(new SelectListItem() { Value = "", Text = "" });

        //    using (var dbContext = new EnVisageEntities())
        //    {
        //        var types = dbContext.Scenarios.AsNoTracking().Where(t =>
        //            t.Type == (int)ScenarioType.Template);
        //        options.AddRange(types.Select(t => new SelectListItem()
        //        {
        //            Value = t.Id.ToString(),
        //            Text = t.Name
        //        }));
        //    }

        //    return options;
        //}
        public static MvcHtmlString GetTemplates(Guid? selectedId)
        {
            EnVisageEntities context = new EnVisageEntities();
            var groups = context.TemplateGroups.Where(x => x.Template2TemplateGroup.Any(t => t.Scenario.Status == (int)ScenarioStatus.Active))
                                               .Include(x => x.Template2TemplateGroup).OrderBy(x => x.Name).ToList();
            var templates = (from pr in context.Scenarios where pr.Type == (int)ScenarioType.Template && pr.Status == (int)ScenarioStatus.Active select pr).OrderBy(x => x.Name).ToDictionary(x => x.Id, x => x.Name);
            List<TagBuilder> result = new List<TagBuilder>();

            foreach (var group in groups)
            {
                var groupBuilder = new TagBuilder("optgroup");
                groupBuilder.Attributes.Add(new KeyValuePair<string, string>("label", group.Name));
                foreach (var template in group.Template2TemplateGroup)
                {
                    if (template.Scenario.Status != (int)ScenarioStatus.Active) continue;
                    var option = new TagBuilder("option");
                    option.Attributes["value"] = template.TemplateId.ToString();
                    option.SetInnerText(template.Scenario.Name);
                    if (selectedId.HasValue && selectedId.Value == template.TemplateId)
                        option.Attributes["selected"] = string.Empty;
                    groupBuilder.InnerHtml += option;
                    templates.Remove(template.TemplateId);
                }
                result.Add(groupBuilder);
            }
            var ungroupedBuilder = new TagBuilder("optgroup");
            ungroupedBuilder.Attributes.Add(new KeyValuePair<string, string>("label", "Ungrouped"));
            foreach (var template in templates)
            {
                var option = new TagBuilder("option");
                option.Attributes["value"] = template.Key.ToString();
                option.SetInnerText(template.Value);
                if (selectedId.HasValue && selectedId.Value == template.Key)
                    option.Attributes["selected"] = string.Empty;
                ungroupedBuilder.InnerHtml += option;
            }
            result.Add(ungroupedBuilder);

            string final = "<option value=\"\"></option>";
            foreach (var gr in result)
                final += gr.ToString();
            return new MvcHtmlString(final);
        }
        public static IEnumerable<SelectListItem> GetClients(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var clients = dbContext.Clients.AsNoTracking().OrderBy(c => c.Name);
                options.AddRange(clients.Select(c => new SelectListItem()
                {
                    Value = c.Id.ToString(),
                    Text = c.Name
                }));
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetCompanies(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var companies = dbContext.Companies.AsNoTracking().OrderBy(c => c.Name);
                options.AddRange(companies.Select(c => new SelectListItem()
                {
                    Value = c.Id.ToString(),
                    Text = c.Name
                }));
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetProjectTemplates(Guid clientId, Guid companyId)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var companies = dbContext.Companies.AsNoTracking().OrderBy(c => c.Name);
                options.AddRange(companies.Select(c => new SelectListItem()
                {
                    Value = c.Id.ToString(),
                    Text = c.Name
                }));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetProjectParts(Guid? projectId, Guid userId)
        {
            var options = new List<SelectListItem>();
            if (projectId.HasValue && !Guid.Empty.Equals(projectId.Value))
            {
                using (var dbContext = new EnVisageEntities())
                {
                    var parts =
                        from part in dbContext.Projects
                        join sec in dbContext.VW_ProjectAccessByUser on part.Id equals sec.Id
                        orderby part.Name
                        where sec.UserId.Equals(userId) && part.ParentProjectId == projectId
                        select part;

                    options.AddRange(parts.Select(c => new SelectListItem()
                    {
                        Value = c.Id.ToString(),
                        Text = c.Name
                    }));
                }
            }
            return options;
        }

        public static IList<UserQuickLink> GetQuickLinksByUser(Guid? userId)
        {
            var dbContext = new EnVisageEntities();
            if (userId.HasValue)
            {
                var quickLinks = dbContext.UserQuickLinks.AsNoTracking()
                                               .Where(x => x.UserId == userId)
                                               .ToList();

                //quickLinks.ForEach(t => t.PeopleResources = t.PeopleResources.OrderBy(r => r.FirstName + r.LastName).ToList());
                return quickLinks;
            }

            return new List<UserQuickLink>();
        }

        #region Date calculation
        /// <summary>
        /// Gets next date with provided DayOfWeek.
        /// </summary>
        /// <param name="startDate">A date to start from.</param>
        /// <param name="weekDay">A day of the week, Monday=1, Tuesday=2, etc.</param>
        /// <param name="counter">Which one of next week days to return, 1st, 2nd, 3rd, etc.</param>
        /// <param name="skipMonthCheck">Indicates whether to let next week day to be on next month or not.</param>
        /// <returns>A <see cref="DateTime"/>.</returns>
        public static DateTime GetNextDateByWeekDate(DateTime startDate, short weekDay, int counter, bool skipMonthCheck = false)
        {
            var date = startDate;
            while (date.DayOfWeek != (DayOfWeek)weekDay && (skipMonthCheck || date.Month == date.AddDays(1).Month))
            {
                date = date.AddDays(1);
            }
            if (counter == 1)
                return date;
            date = date.AddDays(7 * (counter - 1));
            return date;
        }
        public static DateTime GetLastDateByWeekDate(DateTime startDate, short weekDay)
        {
            var date = startDate;
            // find first upcoming weekDay
            while (date.DayOfWeek != (DayOfWeek)weekDay && date.Month == date.AddDays(1).Month)
            {
                date = date.AddDays(1);
            }

            while (date.Month == date.AddDays(7).Month)
            {
                date = date.AddDays(7);
            }
            return date;
        }
        #endregion

        public static IEnumerable<SelectListItem> GetSystemAttributeOne()
        {
            var options = new List<SelectListItem>();
            options.Add(new SelectListItem()
            {
                Value = Guid.Empty.ToString(),
                Text = "None"
            });
            using (var dbContext = new EnVisageEntities())
            {
                var systemAttributes = dbContext.SystemAttributes.AsNoTracking().Where(t => t.Type == 1);
                options.AddRange(systemAttributes.Select(systemAttribute => new SelectListItem()
                {
                    Value = systemAttribute.Id.ToString(),
                    Text = systemAttribute.Name
                }));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetSystemAttributeTwo()
        {
            var options = new List<SelectListItem>();
            options.Add(new SelectListItem()
            {
                Value = Guid.Empty.ToString(),
                Text = "None"
            });
            using (var dbContext = new EnVisageEntities())
            {
                var systemAttributes = dbContext.SystemAttributes.AsNoTracking().Where(t => t.Type == 2);
                options.AddRange(systemAttributes.Select(systemAttribute => new SelectListItem()
                {
                    Value = systemAttribute.Id.ToString(),
                    Text = systemAttribute.Name
                }));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetExpenditures()
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var expenditures = dbContext.Expenditures.AsNoTracking().OrderBy(e => e.Name);
                options.AddRange(expenditures.Select(expenditure => new SelectListItem()
                {
                    Value = expenditure.Id.ToString(),
                    Text = expenditure.Name
                }));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetExpenditureCategories(Guid parentExpenditureCategory)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                // SA. ENV-839. Rewrited
                //var expenditures = dbContext.Expenditures.AsNoTracking().Where(x => !x.ExpenditureCategory.Any(ec => ec.Id == parentExpenditureCategory));
                //options.AddRange(expenditures.Select(expenditure => new SelectListItem()
                //{
                //    Value = expenditure.ExpenditureCategory.FirstOrDefault().Id.ToString(),
                //    Text = expenditure.ExpenditureCategory.FirstOrDefault().Name // SA. ENV-756. ExpName -> ExpCatName
                //}));

                var expCats = dbContext.VW_ExpenditureCategory.AsNoTracking().Where(x => x.Id == parentExpenditureCategory);
                options.AddRange(expCats.Select(expCatItem => new SelectListItem()
                {
                    Value = expCatItem.Id.ToString(),
                    Text = expCatItem.ExpCategoryWithCcName // SA. ENV-756. ExpName -> ExpCatName. ENV-839
                }));
            }
            return options.OrderBy(x => x.Text);
        }

        public static List<ScenarioModel.ExpenditureItem> GetScenarioExpenditures(Guid scenarioId)
        {
            List<ScenarioModel.ExpenditureItem> result;
            using (var context = new EnVisageEntities())
            {
                result = (from c in context.ScenarioDetail.AsNoTracking()
                          join o in context.VW_ExpenditureCategory on c.ExpenditureCategoryId equals o.Id    // ENV-839
                          where c.ParentID == scenarioId
                          select new ScenarioModel.ExpenditureItem
                            {
                                Id = o.Id,
                                Name = o.ExpCategoryWithCcName  // SA. ENV-756. ENV-839
                            }).Distinct().ToList();
            }
            return result;
        }

        public static IList<SelectListItem> GetResourceExpendituresList(Guid? resourceExpId)
        {
            List<SelectListItem> result;
            using (var context = new EnVisageEntities())
            {
                result = (from c in context.VW_ExpenditureCategory.AsNoTracking()  // SA. ENV-839
                          //						  join o in context.Expenditures on c.ExpenditureId equals o.Id
                          select new SelectListItem
                          {
                              Text = c.ExpCategoryWithCcName, // SA. ENV-756. ENV-839
                              Value = c.Id.ToString(),
                              Selected = resourceExpId.HasValue && resourceExpId != Guid.Empty && resourceExpId == c.Id
                          }).Distinct().ToList();
            }

            var r = result.Where(x => x.Selected == true);

            return result;
        }

        public static IEnumerable<SelectListItem> GetResorces()
        {
            List<SelectListItem> retList = new List<SelectListItem>();

            using (var dbContext = new EnVisageEntities())
            {
                var resources = (from r in dbContext.PeopleResources select r).Distinct().ToArray();
                retList.AddRange(resources
                    .Select(x => new SelectListItem()
                    {
                        Text = x.FirstName + " " + x.LastName,
                        Value = x.Id.ToString()
                    }).OrderBy(x => x.Text));
            }
            return retList;
        }

        public static IEnumerable<string> GetTypeGroups()
        {
            List<string> retList = new List<string>();

            using (var dbContext = new EnVisageEntities())
            {
                var resources = (from r in dbContext.TypeGroups select r).Distinct().ToArray();
                retList.AddRange(resources
                    .Select(x => x.Name));
            }
            return retList;
        }

        public static IEnumerable<string> GetTemplateGroups()
        {
            List<string> retList = new List<string>();

            using (var dbContext = new EnVisageEntities())
            {
                var resources = (from r in dbContext.TemplateGroups select r).Distinct().ToArray();
                retList.AddRange(resources
                    .Select(x => x.Name));
            }
            return retList;
        }

        public static IEnumerable<SelectListItem> GetSubstituteResources(string UserName, Guid CurrentResourceId, Guid ExpenditureCategoryId, Guid ProjectId)
        {
            List<SelectListItem> retList = new List<SelectListItem>();
            retList.Add(new SelectListItem
                       {
                           Text = "",
                           Value = ""
                       });
            using (var dbContext = new EnVisageEntities())
            {
                var user = dbContext.AspNetUsers.Where(x => x.UserName == UserName).FirstOrDefault();
                var teams = dbContext.User2Team.Where(x => x.UserId == user.Id).Select(x => x.TeamId).ToArray();
                var projectTeamIds = dbContext.Team2Project.Where(x => x.ProjectId == ProjectId).Select(x => x.TeamId).ToArray();
                var resources = dbContext.PeopleResources.Where(x => teams.Contains((Guid)x.TeamId) && projectTeamIds.Contains((Guid)x.TeamId) && x.ExpenditureCategoryId == ExpenditureCategoryId && x.IsActiveEmployee).ToList();
                resources.Remove(resources.Where(x => x.Id == CurrentResourceId).FirstOrDefault());
                retList.AddRange(resources
                    .Select(x => new SelectListItem()
                    {
                        Text = x.FirstName + " " + x.LastName,
                        Value = x.Id.ToString()
                    }).OrderBy(x => x.Text));
            }
            return retList;
        }

        public static IEnumerable<SelectListItem> GetProjects(Guid userId)
        {
            var retList = new List<SelectListItem>() 
            {
                new SelectListItem
                {
                    Text = "",
                    Value = ""
                }
            };

            using (var dbContext = new EnVisageEntities())
            {
                var projects =
                    (from proj in dbContext.Projects
                     join sc in dbContext.VW_ProjectAccessByUser on proj.Id equals sc.Id
                     where sc.UserId.Equals(userId)
                     select new SelectListItem()
                     {
                         Value = proj.Id.ToString(),
                         Text = proj.Name
                     }).ToList();

                retList.AddRange(projects);
            }

            return retList;
        }

        public static IEnumerable<Project> GetResourceProjects(Guid ResourceId, string Username)
        {
            List<Project> retList = new List<Project>();
            using (var dbContext = new EnVisageEntities())
            {
                var userId = dbContext.AspNetUsers.Where(x => x.UserName == Username).Select(x => x.Id).FirstOrDefault();
                var userteams = dbContext.User2Team.Where(x => x.UserId == userId).Select(x => x.TeamId).Distinct().ToList();
                var scenarioIds = dbContext.PeopleResourceAllocations.Where(x => x.PeopleResourceId == ResourceId).Select(x => x.ScenarioId).ToList();
                var ProjectIds = dbContext.Scenarios.Where(x => scenarioIds.Contains(x.Id)).Select(x => x.ParentId).Distinct().ToList();
                var teamsProjectsIds = dbContext.Team2Project.Where(x => ProjectIds.Contains(x.ProjectId) && userteams.Contains(x.TeamId)).Select(x => x.ProjectId).Distinct().ToList();
                var projects = dbContext.Projects.Where(x => ProjectIds.Contains(x.Id)).Distinct().ToList();
                retList.AddRange(projects);
            }
            return retList;
        }

        public static IEnumerable<SelectListItem> GetProjectsToScenarioCopy(Guid projectId, string Username)
        {
            List<SelectListItem> retList = new List<SelectListItem>();

            const string delim = ": ";

            using (var dbContext = new EnVisageEntities())
            {
                var userIdAsText = dbContext.AspNetUsers.Where(x => x.UserName == Username).Select(x => x.Id).FirstOrDefault();
                Guid userId = new Guid(userIdAsText);

                List<Project> projects = null;
                var teamIds = new List<Guid>();

                projects =
                    (from proj in dbContext.Projects
                     join sc in dbContext.VW_ProjectAccessByUser on proj.Id equals sc.Id
                     where sc.UserId.Equals(userId) && !proj.HasChildren
                     select proj).Include(x=> x.ParentProject).ToList();

                var prIds = projects.Select(p => p.Id).ToList();
                var userteams = dbContext.User2Team.Where(x => x.UserId == userIdAsText).Select(x => x.TeamId).Distinct().ToList();
                var p1 = dbContext.Team2Project.Where(x => userteams.Contains(x.TeamId) && prIds.Contains(x.ProjectId)).ToList();
                var teamsProjects = p1.Select(x => x.ProjectId).Distinct().ToList();

                //var projectsAssignedToTeams = projects.Where(x => ProjectIds.Contains(x.Id)).Distinct().ToList();
                var currProject = projects.FirstOrDefault(p => p.Id == projectId);
                if (currProject != null)
                {
                    retList.Add(new SelectListItem() { Value = string.Empty, Text = "Current Project" });
                    retList.Add(new SelectListItem() { Value = currProject.Id.ToString(), Text = currProject.Name + (currProject.ParentProject != null ? delim + currProject.ParentProject.Name : string.Empty) });
                }
                if (teamsProjects != null)
                {
                    retList.Add(new SelectListItem() { Value = string.Empty, Text = "Other Projects for Teams Assigned" });
                    retList.AddRange(projects.Where(p => teamsProjects.Contains(p.Id) && p.Id != projectId).Select(p => new SelectListItem() { Value = p.Id.ToString(), Text = p.Name + (p.ParentProject != null ? delim + p.ParentProject.Name : string.Empty) }));
                }
                if (projects != null)
                {
                    retList.Add(new SelectListItem() { Value = string.Empty, Text = "Other Projects" });
                    retList.AddRange(projects.Where(p => !teamsProjects.Contains(p.Id) && p.Id != projectId).Select(p => new SelectListItem() { Value = p.Id.ToString(), Text = p.Name + (p.ParentProject != null ? delim + p.ParentProject.Name : string.Empty) }));
                }

            }
            return retList;
        }


        public static List<Contact> GetProjectContacts(Guid projectId)
        {
            List<ContactModel> result = new List<ContactModel>();
            EnVisageEntities DbContext = new EnVisageEntities();
            return (from c in DbContext.Contact2Project where c.ShowId == projectId select c.Contact).Distinct().OrderBy(c => c.LastName).ToList();
        }

        public static IEnumerable<SelectListItem> GetProjectInternalContacts(Guid? companyId)
        {
            List<SelectListItem> retList = new List<SelectListItem>();
            if (companyId.HasValue)
            {
                using (var dbContext = new EnVisageEntities())
                {
                    retList.AddRange(dbContext.Contacts
                        .Where(x => x.ParentId == companyId && x.Type == (int)ContactType.CompanyContact)
                        .Select(x => new SelectListItem()
                        {
                            Text = x.FirstName + " " + x.LastName,
                            Value = x.Id.ToString()
                        }).OrderBy(x => x.Text));
                }
            }
            return retList;
        }

        public static IEnumerable<SelectListItem> GetProjectExternalContacts(Guid? clientId)
        {
            List<SelectListItem> retList = new List<SelectListItem>();
            if (clientId.HasValue)
            {
                using (var dbContext = new EnVisageEntities())
                {
                    retList.AddRange(dbContext.Contacts
                        .Where(x => x.ParentId == clientId && x.Type == (int)ContactType.ClientContact)
                        .Select(x => new SelectListItem()
                        {
                            Text = x.FirstName + " " + x.LastName,
                            Value = x.Id.ToString()
                        }).OrderBy(x => x.Text));
                }
            }
            return retList;
        }

        public static List<ScenarioModel.ProjectItem> GetScenarioProjects(Guid scenarioId)
        {
            List<ScenarioModel.ProjectItem> result;
            using (var context = new EnVisageEntities())
            {
                result = (from p in context.Projects.AsNoTracking()
                          select new ScenarioModel.ProjectItem
                          {
                              Id = p.Id,
                              Name = p.Name,
                              IsRevenueGenerating = p.IsRevenueGenerating
                          }).Distinct().OrderBy(x => x.Name).ToList();
            }
            return result;
        }

        public static LaborMaterialsCostInfo GetLaborMaterialsSplit(Guid scenarioId)
        {
            using (var context = new EnVisageEntities())
            {
                var data = context.VW_ScenarioAndProxyDetails
                                  .Where(x => x.ParentID == scenarioId)
                                  .GroupBy(x => x.Type)
                                  .Select(x => new
                            {
                                Type = x.Key,
                                BUCost = x.Sum(t => t.Cost)
                            }).ToDictionary(x => x.Type, g => g.BUCost ?? 0);

                decimal totalBtUpCostsLabor = 0, totalBtUpCostsMaterials = 0;
                if (data.ContainsKey(ExpenditureCategoryModel.CategoryTypes.Labor.GetHashCode()))
                    totalBtUpCostsLabor = data[ExpenditureCategoryModel.CategoryTypes.Labor.GetHashCode()];
                if (data.ContainsKey(ExpenditureCategoryModel.CategoryTypes.Materials.GetHashCode()))
                    totalBtUpCostsMaterials = data[ExpenditureCategoryModel.CategoryTypes.Materials.GetHashCode()];

                return new LaborMaterialsCostInfo()
                {
                    Labor = totalBtUpCostsLabor,
                    Materials = totalBtUpCostsMaterials,
                    Total = data.Sum(x => x.Value)
                };
            }
        }

        public static LaborMaterialsCostInfo GetLaborMaterialsActualSplit(Guid projectId)
        {
            using (var context = new EnVisageEntities())
            {
                var actualScenario = context.Scenarios.FirstOrDefault(x => x.ParentId == projectId &&
                                                                           x.Type == (int)ScenarioType.Actuals &&
                                                                           x.Status == (int)ScenarioStatus.Active);
                if (actualScenario == null)
                    return new LaborMaterialsCostInfo();

                return GetLaborMaterialsSplit(actualScenario.Id);
            }
        }

        public static IEnumerable<SelectListItem> GetGLAccounts(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var glAccounts = dbContext.GLAccounts.AsNoTracking();
                options.AddRange(glAccounts.Select(glAccount => new SelectListItem()
                {
                    Value = glAccount.Id.ToString(),
                    Text = glAccount.Name
                }).OrderBy(x => x.Text));
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetViews(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var views = dbContext.Views.AsNoTracking();
                options.AddRange(views.Select(view => new SelectListItem()
                {
                    Value = view.Id.ToString(),
                    Text = view.Name
                }).OrderBy(x => x.Text));
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetUnitsOfMeasure()
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var unitsOfMeasure = dbContext.UOMs.AsNoTracking();
                options.AddRange(unitsOfMeasure.Select(unitOfMeasure => new SelectListItem()
                {
                    Value = unitOfMeasure.Id.ToString(),
                    Text = unitOfMeasure.Name + " " + unitOfMeasure.UOMValue.ToString()
                }).OrderBy(x => x.Text));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetCreditDepartments(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var creditDepartments = dbContext.CreditDepartments.AsNoTracking().ToList();
                options.AddRange(creditDepartments.Select(creditDepartment => new SelectListItem()
                {
                    Value = creditDepartment.Id.ToString(),
                    Text = string.IsNullOrEmpty(creditDepartment.CreditNumber) ? creditDepartment.Name : string.Format("{0} ({1})", creditDepartment.Name, creditDepartment.CreditNumber)
                }).OrderBy(x => x.Text));
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetTeams(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var teams = dbContext.Teams.AsNoTracking();
                foreach (Team team in teams.OrderBy(x => x.Name))
                {
                    options.Add(new SelectListItem()
                    {
                        Value = team.Id.ToString(),
                        Text = team.Name,
                    });
                }
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public class SelectListItemExt : SelectListItem
        {
            public bool IsAccessible { get; set; }
        }
        public static IEnumerable<SelectListItemExt> GetTeams(string userId, bool useEmptyElement = false)
        {
            var options = new List<SelectListItemExt>();
            using (var dbContext = new EnVisageEntities())
            {
                options.AddRange(dbContext.Teams.Select(t => new SelectListItemExt
                            {
                                Value = t.Id.ToString(),
                                Text = t.Name,
                                IsAccessible = (t.User2Team.FirstOrDefault(u2t=> u2t.UserId.Equals(userId)) != null)
                            }).AsNoTracking());

                //foreach (Team team in teams.OrderBy(x => x.Name))
                //{
                //    options.Add(new SelectListItemExt()
                //    {
                //        Value = team.Id.ToString(),
                //        Text = team.Name,
                //    });
                //}
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItemExt());
            return options;
        }

        public static IEnumerable<SelectListItem> GetStrategicGoals(Guid? CompanyId, bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var goals = dbContext.StrategicGoal2Company.AsNoTracking().Where(x => x.CompanyId == CompanyId.Value).Select(x => x.StrategicGoal).Distinct().OrderBy(x => x.Name).ToList();
                foreach (StrategicGoal goal in goals)
                {
                    options.Add(new SelectListItem()
                    {
                        Value = goal.Id.ToString(),
                        Text = goal.Name,
                    });
                }
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetTeamsAvailableForUser(Guid userId, bool useEmptyElement = false, bool useBlankElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var user2team = dbContext.User2Team.AsNoTracking().Where(t => t.UserId == userId.ToString()).Select(t => t.TeamId).ToArray();
                var teams = dbContext.Teams.AsNoTracking().Where(t => user2team.Contains(t.Id)).ToList();
                foreach (Team team in teams.OrderBy(x => x.Name))
                {
                    options.Add(new SelectListItem()
                    {
                        Value = team.Id.ToString(),
                        Text = team.Name,
                    });
                }
            }
            if (useEmptyElement)
            {
                var allItem = new SelectListItem();
                if (!useBlankElement)
                {
                    allItem.Text = "All";
                    allItem.Value = "All";
                }
                options.Insert(0, allItem);
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetViewsAvailableForUser(Guid userId, bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var user2view = dbContext.User2View.AsNoTracking().Where(t => t.UserId == userId).Select(t => t.ViewId).ToArray();
                var views = dbContext.Views.AsNoTracking().Where(t => user2view.Contains(t.Id)).ToList();
                foreach (View view in views.OrderBy(x => x.Name))
                {
                    options.Add(new SelectListItem()
                    {
                        Value = view.Id.ToString(),
                        Text = view.Name,
                    });
                }
            }
            if (useEmptyElement)
            {
                var allItem = new SelectListItem();
                allItem.Text = "All";
                allItem.Value = "All";
                options.Insert(0, allItem);
            }
            return options;
        }

        public static List<SelectListItem> GetViewsAndTeams(string userId, bool useEmptyElement)
        {
            using (var context = new EnVisageEntities())
            {
                var result = new List<SelectListItem>();
                var views = context.User2View.AsNoTracking()
                                             .Where(x => x.UserId == new Guid(userId))
                                             .Select(x => x.View)
                                             .OrderBy(x => x.Name)
                                             .ToList();

                var teams = context.User2Team.AsNoTracking()
                                             .Where(x => x.UserId == userId)
                                             .Select(x => new { Id = x.Team.Id, Name = x.Team.Name })
                                             .OrderBy(x => x.Name)
                                             .ToList();
                var teamgroup = new SelectListGroup()
                    {
                        Name = "Teams"
                    };
                var viewgroup = new SelectListGroup()
                    {
                        Name = "Views"
                    };
                result.AddRange(teams.Select(x => new SelectListItem()
                {
                    Value = x.Id.ToString(),
                    Text = x.Name,
                    Group = teamgroup
                }));

                result.AddRange(views.Select(x => new SelectListItem()
                {
                    Value = x.Id.ToString(),
                    Text = x.Name,
                    Group = viewgroup
                }));

                if (useEmptyElement)
                {
                    var allitem = new SelectListItem();
                    allitem.Text = "All";
                    allitem.Value = "All";
                    result.Insert(0, allitem);
                }
                return result;
            }
        }

        public static IEnumerable<SelectListItem> GetUsers(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var users = dbContext.AspNetUsers.AsNoTracking();
                options.AddRange(users.Select(user => new SelectListItem()
                {
                    Value = user.Id,
                    Text = user.FirstName + " " + user.LastName
                }).OrderBy(x => x.Text));
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetCategoryTypes(bool useEmptyElement = false)
        {
            var result = new List<SelectListItem>
                {
                    new SelectListItem
                        {
                            Text = ExpenditureCategoryModel.CategoryTypes.Labor.ToDisplayValue(),
                            Value =  ExpenditureCategoryModel.CategoryTypes.Labor.ToString()
                        },
                    new SelectListItem
                        {
                            Text = ExpenditureCategoryModel.CategoryTypes.Materials.ToDisplayValue(),
                            Value =  ExpenditureCategoryModel.CategoryTypes.Materials.ToString()
                        },
                     new SelectListItem
                        {
                            Text = ExpenditureCategoryModel.CategoryTypes.Usage.ToDisplayValue(),
                            Value =  ExpenditureCategoryModel.CategoryTypes.Usage.ToString()
                        }
                };
            if (useEmptyElement)
                result.Insert(0, new SelectListItem());
            return result;
        }

        public static List<SelectListItem> CastEnumToSelectedList<T>()
        {
            if (!typeof(T).IsEnum)
                return new List<SelectListItem>();

            return Enum.GetValues(typeof(T)).Cast<T>().Select(x => new SelectListItem()
            {
                Text = (x as Enum).ToDisplayValue(),
                Value = x.GetHashCode().ToString()
            }).OrderBy(x => x.Text).ToList();
        }

        public static IEnumerable<SelectListItem> GetUseTypes()
        {
            return new List<SelectListItem>
                {
                      new SelectListItem
                        {
                            Text = ExpenditureCategoryModel.UseTypes.Quantity.ToDisplayValue(),
                            Value =  ExpenditureCategoryModel.UseTypes.Quantity.GetHashCode().ToString()
                        },
                        new SelectListItem
                        {
                            Text = ExpenditureCategoryModel.UseTypes.Cost.ToDisplayValue(),
                            Value =  ExpenditureCategoryModel.UseTypes.Cost.GetHashCode().ToString()
                        }
                        //,
                        //new SelectListItem
                        //{
                        //    Text = ExpenditureCategoryModel.UseTypes.Calculated.ToDisplayValue(),
                        //    Value =  ExpenditureCategoryModel.UseTypes.Calculated.GetHashCode().ToString()
                        //},
                        //new SelectListItem
                        //{
                        //    Text = ExpenditureCategoryModel.UseTypes.Fee.ToDisplayValue(),
                        //    Value =  ExpenditureCategoryModel.UseTypes.Fee.GetHashCode().ToString()
                        //}
                        
                };
        }

        public static IEnumerable<SelectListItem> GetIncomeTypes(bool useEmptyItem = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var systemAttributes = dbContext.SystemAttributes.AsNoTracking().Where(t => t.Type == (int)SystemAttributeModel.Type.IncomeType);
                options.AddRange(systemAttributes.Select(systemAttribute => new SelectListItem()
                {
                    Value = systemAttribute.Id.ToString(),
                    Text = systemAttribute.Name
                }).OrderBy(x => x.Text));
            }
            if (useEmptyItem)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetCGEFX(bool useEmptyElement = false)
        {
            var result = new List<SelectListItem>
                {
                      new SelectListItem
                        {
                            Text = ExpenditureCategoryModel.CgEfx.CG.ToDisplayValue(),
                            Value = ExpenditureCategoryModel.CgEfx.CG.ToDisplayValue()
                        },
                       new SelectListItem
                        {
                            Text = ExpenditureCategoryModel.CgEfx.EFX.ToDisplayValue(),
                            Value = ExpenditureCategoryModel.CgEfx.EFX.ToDisplayValue()
                        }
                };
            if (useEmptyElement)
                result.Insert(0, new SelectListItem());
            return result;
        }

        public static IEnumerable<SelectListItem> GetTrainingType()
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var items = dbContext.TrainingTypes.AsNoTracking().ToArray();
                options.AddRange(items.OrderBy(t => t.Name).Select(item => new SelectListItem()
                {
                    Value = item.Id.ToString(),
                    Text = item.Name
                }).OrderBy(x => x.Text));
            }
            if (options.Count == 0)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetScenarioTemplates(bool useEmptyElement = false)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var items = dbContext.Scenarios.AsNoTracking().Where(t => t.Type == (int?)ScenarioType.Template && t.Status == (int?)ScenarioStatus.Active).ToArray();
                options.AddRange(items.OrderBy(t => t.Name).Select(item => new SelectListItem()
                {
                    Value = item.Id.ToString(),
                    Text = item.Name
                }).OrderBy(x => x.Text));
            }
            if (useEmptyElement)
                options.Insert(0, new SelectListItem());
            return options;
        }

        public static IEnumerable<SelectListItem> GetFactorTypes()
        {
            return new List<SelectListItem>
                {
                      new SelectListItem
                        {
                            Text = CalculatesCategoryModel.FactorTypes.Divide.ToDisplayValue(),
                            Value =  CalculatesCategoryModel.FactorTypes.Divide.GetHashCode().ToString()
                        },
                        new SelectListItem
                        {
                            Text = CalculatesCategoryModel.FactorTypes.Multipiy.ToDisplayValue(),
                            Value =  CalculatesCategoryModel.FactorTypes.Multipiy.GetHashCode().ToString()
                        }
                };
        }

        public static IEnumerable<SelectListItem> GetProjectStatusDropdown(bool includeEmpty = true)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var projectStatuses = dbContext.Status.ToList();
                if (includeEmpty)
                {
                    var allItem = new SelectListItem()
                    {
                        Text = "All",
                        Value = "All"
                    };
                    options.Add(allItem);
                }
                options.AddRange(projectStatuses.Select(status => new SelectListItem()
                {
                    Value = status.Id.ToString(),
                    Text = status.Name
                }).OrderBy(x => x.Text));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetStrategicGoalsDropdown(bool includeEmpty = true)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var strategicGoals = dbContext.StrategicGoals.ToList();
                if (includeEmpty)
                {
                    var allItem = new SelectListItem()
                    {
                        Text = "All",
                        Value = "All"
                    };
                    options.Add(allItem);
                }
                options.AddRange(strategicGoals.Select(goal => new SelectListItem()
                {
                    Value = goal.Id.ToString(),
                    Text = goal.Name
                }).OrderBy(x => x.Text));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetProjectClassificationDropdown(bool includeEmpty = true)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var projectClassifications = dbContext.Types.ToList();
                if (includeEmpty)
                {
                    var allItem = new SelectListItem()
                    {
                        Text = "All",
                        Value = "All"
                    };
                    options.Add(allItem);
                }
                options.AddRange(projectClassifications.Select(classification => new SelectListItem()
                {
                    Value = classification.Id.ToString(),
                    Text = classification.Name
                }));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetScenarioGroup(bool includeEmpty = true)
        {
            var options = new List<SelectListItem>();
            using (var dbContext = new EnVisageEntities())
            {
                var scenarioGroup = dbContext.SystemAttributes.AsNoTracking().Where(t => t.Type == 3).OrderBy(x => x.Name);
                if (includeEmpty)
                {
                    options.Add(new SelectListItem()
                    {
                        Text = "Default",
                        Value = Guid.Empty.ToString()
                    });
                }
                options.AddRange(scenarioGroup.Select(group => new SelectListItem()
                {
                    Value = group.Id.ToString(),
                    Text = group.Name
                }).OrderBy(x => x.Text));
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetListboxItems<T>()
        {
            var options = new List<SelectListItem>();
            //if (type is Enum)
            T t = default(T);
            {
                foreach (string e in Enum.GetNames(t.GetType()))
                {
                    object value = Enum.Parse(t.GetType(), e);

                    var members = value.GetType().GetMember(value.ToString());
                    var attr = members.Length > 0
                                   ? members[0].GetCustomAttributes(typeof(DisplayValueAttribute), true)
                                               .Cast<DisplayValueAttribute>()
                                               .FirstOrDefault()
                                   : null;

                    options.Add(new SelectListItem()
                    {
                        Text = attr == null ? value.ToString() : attr.DisplayValue,
                        Value = value.GetHashCode().ToString()
                    });
                }
            }
            return options;
        }

        public static IEnumerable<SelectListItem> GetScenarioTypesPortfAndSched()
        {
            return new List<SelectListItem>
                {
                      new SelectListItem
                        {
                            Text = ScenarioType.Portfolio.ToDisplayValue(),
                            Value =  ScenarioType.Portfolio.ToString()
                        },
                        new SelectListItem
                        {
                            Text = ScenarioType.Scheduling.ToDisplayValue(),
                            Value =  ScenarioType.Scheduling.ToString()
                        }
                }.OrderBy(x => x.Text);
        }

        public static IEnumerable<SelectListItem> GetContactTypes()
        {
            List<SelectListItem> retList = new List<SelectListItem>();
            foreach (int e in Enum.GetValues(typeof(ContactType)))
            {
                retList.Add(new SelectListItem
                {
                    Text = ((ContactType)e).ToDisplayValue(),
                    Value = e.ToString(),
                });
            }
            return retList;
        }

        public static IEnumerable<SelectListItem> GetYesNo()
        {
            List<SelectListItem> retList = new List<SelectListItem>();

            retList.Add(new SelectListItem()
                {
                    Text = "Yes",
                    Value = "Yes"
                });
            retList.Add(new SelectListItem()
            {
                Text = "No",
                Value = "No"
            });

            return retList;
        }

        public static IEnumerable<SelectListItem> GetContactClassification()
        {
            List<SelectListItem> retList = new List<SelectListItem>();

            foreach (var classification in Enum.GetValues(typeof(InternalContactClassification)))
                retList.Add(new SelectListItem()
                    {
                        Text = Enum.GetName(typeof(InternalContactClassification), classification),
                        Value = classification.ToString()
                    });

            return retList;
        }

        public static IEnumerable<SelectListItem> GetTeamContacts(Guid? companyId)
        {
            List<SelectListItem> retList = new List<SelectListItem>();

            retList.Add(new SelectListItem()
            {
                Text = "None",
                Value = Guid.Empty.ToString()
            });

            if (companyId.HasValue)
            {
                using (var dbContext = new EnVisageEntities())
                {
                    retList.AddRange(dbContext.Contacts
                        .Where(x => x.ParentId == companyId &&
                                    x.ContactClassification == (int)InternalContactClassification.ResourceManagerContact)
                        .Select(x => new SelectListItem()
                        {
                            Text = x.FirstName + " " + x.LastName,
                            Value = x.Id.ToString()
                        }));
                }
            }

            return retList;
        }

        public class DateRange
        {
            public DateTime StartDate { get; set; }
            public DateTime EndDate { get; set; }
        }

        public static bool IsDateRangesIntersect(DateRange range1, DateRange range2)
        {
            // if ranges are equal - they intersected
            if (range1.StartDate == range2.StartDate && range1.EndDate == range2.EndDate)
                return true;

            // ranges not intersected  if...
            if ((range1.StartDate > range2.EndDate) || (range2.StartDate > range1.EndDate))
                return false;

            // if range1 partially intersect with range2
            if ((range1.StartDate >= range2.StartDate && range1.StartDate < range2.EndDate)
                || (range2.StartDate >= range1.StartDate && range2.StartDate < range1.EndDate))
                return true;

            return false;
        }

        /// <summary>
        /// Gets a multiplier to be applied to scenario detail quantity or rate, value depends on provided expenditure category's UOM value.
        /// </summary>
        /// <param name="expCatId">Expenditure Category Id.</param>
        /// <param name="uomMode">Value indicating selected UOM Mode.<br/>
        /// null - UOM Mode has not been selected. Use default value = 1;<br/>
        /// true - UOM Mode is Hours. Returned value is 1.
        /// false - UOM Mode is Resources. Returned value depends on provided expenditure category Id.
        /// </param>
        /// <param name="categories">Dictionary of all available expenditure categories used as source to search for provided <paramref name="expCatId"/>. Key is Category.Id</param>
        /// <param name="uoms">Dictionary of all Unit of Measures used as a source to search for UOM value. Key is UoM.Id</param>
        /// <returns>Returns a decimal multiplier value depending on provided expenditure category's UOM value.</returns>
        public static decimal GetUOMMultiplier(Dictionary<Guid, ExpenditureCategory> categories, Dictionary<Guid, UOM> uoms, Guid expCatId, bool? uomMode)
        {
            if (!uomMode.HasValue || uomMode.Value)
                return Constants.UOM_HOURS_MULTIPLIER;

            if (categories == null || !categories.Any() || uoms == null || !uoms.Any())
                throw new UOMNotExistsException();

            ExpenditureCategory category = null;
            if (categories.ContainsKey(expCatId))
                category = categories[expCatId];
            if (category == null)
                throw new UOMNotExistsException();

            UOM uom = null;
            if (uoms.ContainsKey(category.UOMId))
                uom = uoms[category.UOMId];
            if (uom == null || uom.UOMValue == 0)
                throw new UOMNotExistsException();

            return 1 / uom.UOMValue;
        }


        public static List<MixTeamViewModel> GetViewsAndTeams(string userId)
        {
            using (var context = new EnVisageEntities())
            {
                var result = new List<MixTeamViewModel>();
                var views = context.User2View.AsNoTracking()
                                             .Where(x => x.UserId == new Guid(userId))
                                             .Select(x => x.View)
                                             .OrderBy(x => x.Name)
                                             .ToList();

                var teams = context.User2Team.AsNoTracking()
                                             .Where(x => x.UserId == userId)
                                             .Select(x => x.Team)
                                             .OrderBy(x => x.Name)
                                             .ToList();

                result.AddRange(views.Select(x => new MixTeamViewModel()
                {
                    Id = x.Id.ToString(),
                    TVName = x.Name,
                    CompanyId = null,//x.Company2View.FirstOrDefault().CompanyId,
                    CostCenterId = null,
                    CapacityTeamId = null,
                    CopyPlanned = false,
                    Data = null,
                    UserId = null,
                    IsNew = false,
                    Group = new SelectListGroup()
                    {
                        Name = "Views"
                    }
                }));

                result.AddRange(teams.Select(x => new MixTeamViewModel()
                {
                    Id = x.Id.ToString(),
                    TVName = x.Name,
                    CompanyId = null,//x.Company2View.FirstOrDefault().CompanyId,
                    CostCenterId = null,
                    CapacityTeamId = null,
                    CopyPlanned = false,
                    Data = null,
                    UserId = null,
                    IsNew = false,
                    Group = new SelectListGroup()
                    {
                        Name = "Teams"
                    }
                }));

                return result;
            }
        }
        public static List<SelectListItem> GetMixesAvailable4User(string userId)
        {
            using (var context = new EnVisageEntities())
            {
                // ! SA. Remove try..catch block, when the struct for savable data be finished
                try
                {
                    MongoMixManager mngr = new MongoMixManager(context, userId);
                    var foundMixes = mngr.GetMixesByUser();

                    if (foundMixes != null)
                    {
                        return foundMixes.Select(x => new SelectListItem()
                        {
                            Value = x.Id.ToString(),
                            Text = x.Name
                        }).ToList();
                    }
                    else
                        return new List<SelectListItem>();
                }
                catch (FormatException formatException)
                {
                    var logger = NLog.LogManager.GetCurrentClassLogger();
                    logger.Error(formatException);
                    return new List<SelectListItem>();
                }
            }
        }

        public static long ConvertToUnixDate(DateTime date)
        {
            return (long)date.Subtract(Constants.UnixEpochDate).TotalMilliseconds;
        }

        public static DateTime ConvertFromUnixDate(long milliseconds)
        {
            if (milliseconds <= 0)
                return Constants.UnixEpochDate;

            return Constants.UnixEpochDate.AddMilliseconds(milliseconds);
        }

        public static string Serialize<T>(this T value)
        {
            if (value == null)
            {
                return string.Empty;
            }
            try
            {
                var xmlserializer = new XmlSerializer(typeof(T));
                var stringWriter = new StringWriter();
                using (var writer = XmlWriter.Create(stringWriter))
                {
                    xmlserializer.Serialize(writer, value);
                    return stringWriter.ToString();
                }
            }
            catch (Exception ex)
            {
                throw new Exception("An error occurred", ex);
            }
        }
        public static T Deserialize<T>(this string value)
        {
            if (string.IsNullOrWhiteSpace (value))
            {
                return default(T);
            }
            try
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                T result = default(T);
                using (TextReader reader = new StringReader(value))
                {
                    result = (T)serializer.Deserialize(reader);
                }
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception("An error occurred while deserialization", ex);
            }
        }
 
		public static string ByteArrayToString(this byte[] ba)
		{
            if (null == ba || ba.Length == 0)
                return string.Empty;
			StringBuilder hex = new StringBuilder(ba.Length * 2);
			foreach (byte b in ba)
				hex.AppendFormat("{0:x2}", b);
			return hex.ToString();
		}
		public static byte[] StringToByteArray(this string hex)
		{
            if (string.IsNullOrWhiteSpace(hex))
                return new byte[0];
			int NumberChars = hex.Length;
			byte[] bytes = new byte[NumberChars / 2];
			for (int i = 0; i < NumberChars; i += 2)
				bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
			return bytes;
		}
    }
}