using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using BeWo.Data;
using BeWo.Data.Access;
using BeWo.Data.Entities;
using BeWo.Data.Security;
using BeWo.Service.Core;
using BeWo.Service.DCEntityMapper;
using BS.Shared;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.Compact;
using BS.Shared.Extensions;
using BS.Shared.Services;
using Utils = BeWo.Service.Core.Utils;


namespace BeWo.Service.Plugins
{
    public class EmployeeService : AbstractIDSpecificDefaultClass<EmployeeService>
    {
        public virtual EmployeeDC LoadEmployee(long eOid)
        {
            var test = DAOFactory.GenericDAO.LoadByID<Employee>(eOid);

            SettingsLogic.AddToUsersHistory<Employee>(eOid);
            var dc = MapperFactory.EmployeeDC_Employee.MapToNewDC(test);



            return dc;

        }
        public virtual long InsertNewEmployee(EmployeeDC pEmployeeDC)
        {
            Employee lEmployee = MapperFactory.EmployeeDC_Employee.MapToNewEntity(pEmployeeDC);
            DAOFactory.GenericDAO.Insert(lEmployee);
            return lEmployee.Oid.Value;   
        }

        public virtual List<CompactEmployeeDC> GetAllActiveEmployeesCompact()
        {
            return MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Employee>());
        }

        public virtual List<CompactEmployeeDC> GetAllActiveAndArchivedEmployeesCompact()
        {
            return MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(DAOFactory.GenericDAO.GetAllActiveAndArchived<Employee>());
        }

        public virtual List<CompactTeamDC> GetAllTeamsCompact()
        {
            return GetAllTeamsCompact(false);
        }


        public virtual List<CompactTeamDC> GetAllTeamsCompact(bool includeOwnChat)
        {
            var teamDcs = new List<CompactTeamDC>();
            var loggedInUser = UserRightHelper.GetLoggedInUser();

            if (Utils.UserHasRight(loggedInUser, UserRightType.TeamView_ViewAll))
            {
                teamDcs = MapperFactory.CompactTeamDC_Team.MapToNewDCs(DAOFactory.GenericDAO.GetAllActive<Team>());
            }
            else if (Utils.UserHasRight(loggedInUser, UserRightType.TeamView_ViewMyTeams))
            {
                var teams = DAOFactory.SearchDAO.FindAllActiveTeamsOfEmployee(loggedInUser.Employee.Oid.Value);
                teamDcs = MapperFactory.CompactTeamDC_Team.MapToNewDCs(teams);
            }

            return teamDcs.Where(t => includeOwnChat || !t.IsOwnChatTeam).ToList();
        }
        //Für Main Navigation View
        public virtual List<CompactEmployeeDC> GetAllCompactEmployees()
        {
            //var employees = DAOFactory.GenericDAO.GetAll<Employee>();
            var employees = DAOFactory.GenericDAO.GetAllWithoutPermanentlyDeleted<Employee>();

            var dcs = MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(employees);
            var teams = GetAllTeamsCompact();

            var teamDCs = new List<TeamDC>();
            foreach (var ct in teams)
                teamDCs.Add(MapperFactory.TeamDC_Team.MapToNewDC(DAOFactory.GenericDAO.GetByID<Team>(ct.TeamOid)));

            foreach (var dc in dcs)
            {
                foreach (var tDC in teamDCs)
                {
                    if (tDC.Member.Contains(dc))
                    {
                        if (dc.TeamOids == null)
                            dc.TeamOids = new List<long>();

                        if (!dc.TeamOids.Contains(tDC.TeamOid.Value))
                            dc.TeamOids.Add(tDC.TeamOid.Value);
                    }
                }

                if (dc.TeamOids != null)
                {
                    foreach (var oid in dc.TeamOids)
                    {
                        var team = teamDCs.FirstOrDefault(t => t.TeamOid == oid);
                        if (team != null)
                        {
                            

                            if (dc.RelatedTeams == null)
                                dc.RelatedTeams = "Teams: " + team.Name + ", ";
                            else
                                dc.RelatedTeams += team.Name + ", ";
                        }
                    }
                    if (dc.RelatedTeams != null && dc.RelatedTeams.Length > 0)
                        dc.RelatedTeams = dc.RelatedTeams.Remove(dc.RelatedTeams.Length - 2, 1);
                }
            }
            

            return dcs;
        }

        public virtual List<CompactEmployeeDC> GetAllAuthorizedCompactEmployees()
        {
            var user = UserRightHelper.GetLoggedInUser();

            var employees = DAOFactory.GenericDAO.GetAllActive<Employee>();

            //var dcs = MapperFactory.CompactEmployeeDC_Employee.MapToNewDCs(employees);



            var result = new List<CompactEmployeeDC>();
            
            bool darfAlleSehen = false;
            bool darfAlleDesTeamsSehen = false;
            bool darfAlleEigenenSehen = false;

            if (Core.Utils.UserHasRight(user, UserRightType.Employee_AllowViewOwnEmployees))
            {
                darfAlleEigenenSehen = true;
            }
            if (Core.Utils.UserHasRight(user, UserRightType.EmployeeView_View))
            {
                darfAlleSehen = true;
            }
            if (Core.Utils.UserHasRight(user, UserRightType.Employee_AllowViewOwnTeam))
            {
                darfAlleDesTeamsSehen = true;
            }

            List<long> teamMemberOids = new List<long>();
            
            foreach (var item in user.Employee.LeadingTeams)
            {

                foreach (var member in item.MemberList)
                {
                    teamMemberOids.Add(member.Oid.Value);
                }
            }

            foreach (var emp in employees)
            {
                if (darfAlleSehen)
                {
                    result.Add(MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(emp));
                }
                else if (darfAlleDesTeamsSehen)
                {
                    
                    if (emp.Oid == user.Employee.Oid || teamMemberOids.Contains(emp.Oid.Value))
                    {
                        result.Add(MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(emp));
                    }

                }
                else if (darfAlleEigenenSehen)
                {
                    if (emp.Oid == user.Employee.Oid)
                    {
                        result.Add(MapperFactory.CompactEmployeeDC_Employee.MapToNewDC(emp));
                    }
                }
                 
            }

            return result.OrderBy(e => e.LastName).ToList();
        }


        //Filtert die übergebenen Mitarbeiter anhand der Berechtigung (alle, nur Team bzw. nur eigenen)
        public static IList<Employee> FilterList(IList<Employee> employees)
        {
            List<Employee> newList = new List<Employee>();

            var loggedInUser = UserRightHelper.GetLoggedInUser();

            if (UserRightHelper.UserHasRight(loggedInUser, UserRightType.EmployeeView_View))
            {
                return employees;
            }
            if (UserRightHelper.UserHasRight(loggedInUser, UserRightType.Employee_AllowViewOwnTeam))
            {
                var teams = DAOFactory.SearchDAO.FindAllActiveTeamsOfEmployee(loggedInUser.Employee.Oid.Value);

                foreach (var e in employees)
                {
                    if (BelongsToTeam(teams, loggedInUser, e))
                    {
                        newList.Add(e);
                    }
                }
            }
            else if (UserRightHelper.UserHasRight(loggedInUser, UserRightType.Employee_AllowViewOwnEmployees))
            {
                foreach (var e in employees)
                {
                    if (e.Oid == loggedInUser.Employee.Oid)
                    {
                        newList.Add(e);
                    }
                }
            }
            

            return newList;
        }

        public static bool BelongsToTeam(IList<Team> teams, ApplicationUser loggedInUser, Employee emp)
        {
            //var teams = loggedInUser.Employee.LeadingTeams;

            //foreach (var team in teams)
            //{
            //    foreach (var member in team.MemberList)
            //    {
            //        if (member.Oid == compactEmployeeDc.EmployeeOid)
            //        {
            //            return true;
            //        }
            //    }
            //}


            foreach (var team in teams)
            {
                if (team.Leader != null && team.Leader.Oid == emp.Oid)
                {
                    return true;
                }
                foreach (var member in team.MemberList)
                {
                    if (member.Oid == emp.Oid)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
    }
}