using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using EnVisage.Code.BLL;
namespace EnVisage.Code
{
    public class Approvers
    {
        //Must be а public property to serialize to JSON
        public Dictionary<Guid, bool> ApproversDictionary { get; set; }
        public Dictionary<Guid, Dictionary<Guid, bool>> TeamApproversDictionary { get; set; }
        public WorkFlowApprovalType Type { get; set; }

        public Approvers(Guid ProcessId, WorkFlowApprovalType approvalType, string step, string workflowRole)
        {
            Type = approvalType;
            TeamApproversDictionary = new Dictionary<Guid, Dictionary<Guid, bool>>();
            ApproversDictionary = new Dictionary<Guid, bool>();
            var _runtime = WorkFlowEngine.Runtime(null);
            var p = (OptimaJet.Workflow.DbPersistence.MSSQLProvider) _runtime.PersistenceProvider;
             using (var context =  EnVisageEntities.PrevuEntity(p.ConnectionString, true))
            {
                var scenario = context.Scenarios.Where(x => x.Id == ProcessId).FirstOrDefault();
                if (scenario == null)
                    return;
                var ECLists = context.ScenarioDetail.Where(x => x.ParentID == scenario.Id).Select(x => x.ExpenditureCategoryId).Distinct().ToList();
                var project = context.Projects.Where(x => x.Id == scenario.ParentId).FirstOrDefault();
                if (project == null)
                    return;
                var creditIds = context.ScenarioDetail.Where(x => x.ParentID == scenario.Id).Select(x => x.ExpenditureCategory.CreditId).Distinct().ToList();
                if (approvalType == WorkFlowApprovalType.Project)
                    ApproversDictionary = (new WorkFlowManager(context)).GetProjectApproversForRole(project.Id, step, ProcessId, workflowRole);
                if (approvalType == WorkFlowApprovalType.Team || approvalType == WorkFlowApprovalType.AllTeam || approvalType == WorkFlowApprovalType.COSTCENTER || approvalType == WorkFlowApprovalType.TeamToEC)
                {
                    var teams = new List<Team>();
                    if (approvalType == WorkFlowApprovalType.AllTeam)
                        teams = context.Teams.ToList();
                    else if (approvalType == WorkFlowApprovalType.Team)
                        teams = project.Team2Project.Where(x => x.ProjectId == project.Id).Select(x => x.Team).ToList();
                    else if (approvalType == WorkFlowApprovalType.COSTCENTER)
                        teams = context.Teams.Where(x => creditIds.Contains((x.CostCenterId.HasValue ? x.CostCenterId.Value : Guid.Empty))).ToList();
                    else if (approvalType == WorkFlowApprovalType.TeamToEC) {
                        var teamids = context.VW_TeamResource.Where(x => ECLists.Contains(x.ExpenditureCategoryId)).Select(x => x.TeamId).Distinct().ToList();
                        teams =  context.Teams.Where(x => teamids.Contains(x.Id)).Distinct().ToList();

                    }
                    var teamIds = teams.Select(x => x.Id).ToList();
                    var deadApprovals = context.WorkFlowParallelApprovals.Where(x => x.ProcessId == scenario.Id && x.IsActive == true && !teamIds.Contains(x.GroupId.Value));
                    if (deadApprovals.Count() > 0)
                        context.WorkFlowParallelApprovals.RemoveRange(deadApprovals);
                    foreach (var team in teams)
                    {
                        var userLevelApproval = new Dictionary<Guid, bool>();
                     
                        var teamApvs = new Dictionary<Guid, bool>();
                        var approvalKey = Guid.NewGuid();
                        if (approvalType == WorkFlowApprovalType.COSTCENTER)
                        {
                            teamApvs = (new WorkFlowManager(context)).GetCostCenterApproversForRole(team.Id, step, ProcessId, workflowRole, team.CostCenterId.Value);
                            approvalKey = team.CostCenterId.Value;
                        }
                        else {
                            teamApvs = (new WorkFlowManager(context)).GetTeamApproversForRole(team.Id, step, ProcessId, workflowRole);
                            approvalKey = team.Id;
                        }
                        if (TeamApproversDictionary.ContainsKey(approvalKey))
                            userLevelApproval = TeamApproversDictionary[approvalKey];
                            foreach (var apv in teamApvs)
                        {
                            if (!userLevelApproval.ContainsKey(apv.Key))
                                userLevelApproval.Add(apv.Key, apv.Value);
                        }
                        if (userLevelApproval.Count > 0)
                        {
                            if (TeamApproversDictionary.ContainsKey(approvalKey))
                                TeamApproversDictionary[approvalKey] = userLevelApproval;
                            else
                                TeamApproversDictionary.Add(approvalKey, userLevelApproval);
                        }
                    }
                }

                if (approvalType == WorkFlowApprovalType.ADHOC)
                {
                    var approvers = context.WorkFlowParallelApprovals.Where(x => x.StepName == step && x.ProcessId == ProcessId && x.IsActive == true).ToList();
                    foreach (var a in approvers)
                    {
                        if (!ApproversDictionary.ContainsKey(a.UserId))
                            ApproversDictionary.Add(a.UserId, a.Approved.HasValue ? a.Approved.Value : false);
                    }
                }
                context.SaveChanges();
            }

        }
        [JsonIgnore]
        public bool IsApproved
        {
            get
            {
                if (Type == WorkFlowApprovalType.Project || Type == WorkFlowApprovalType.ADHOC)
                    return ApproversDictionary.Values.All(v => v);
                else
                {
                    foreach (var teamApvs in TeamApproversDictionary.Values)
                    {
                        if (!teamApvs.Values.Any(v => v))
                            return false;
                    }
                    return true;
                }
            }
        }
        public bool NotApproved
        {
            get {
                if (Type == WorkFlowApprovalType.Project || Type == WorkFlowApprovalType.ADHOC)
                    return !ApproversDictionary.Values.All(v => v);
                else
                {
                    foreach (var teamApvs in TeamApproversDictionary.Values)
                    {
                        if (!teamApvs.Values.All(v => v))
                            return true;
                    }
                    return false;
                }
            }
        }
        public void Approve(Guid userid,bool approved, Guid ProcessId,string step)
        {
            ApproversDictionary[userid] = true;
            var _runtime = WorkFlowEngine.Runtime(null);
            var p = (OptimaJet.Workflow.DbPersistence.MSSQLProvider) _runtime.PersistenceProvider;
             using (var context =  EnVisageEntities.PrevuEntity(p.ConnectionString, true))
            {
                var projectId = context.Scenarios.Where(x => x.Id == ProcessId).Select(x => x.ParentId).FirstOrDefault();
                (new WorkFlowManager(context)).SetApprovalValue(userid, approved, ProcessId, step, this.Type, projectId.Value);
                context.SaveChanges();
            }
        }
        public  List<Guid> GetAvailiableApprovers()
        {
            return ApproversDictionary.Where(s => !s.Value).Select(s => s.Key).ToList();
        }
    }
}