using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using AbsenceService.Contracts;
using AbsenceService.Contracts.Models.DTO;
using AbsenceService.Contracts.Models.Enumerations;
using AbsenceService.Contracts.Models.Service.Absence;
using AdministrationService.Contracts;
using AdministrationService.Contracts.Models.Service.Account;
using AutoMapper;
using Common.ServiceExceptions;
using Common.Utilities;
using ConfigurationService.Contracts;
using ConfigurationService.Contracts.Models.Service.Country;
using ConfigurationService.Contracts.Models.Service.Template;
using CustomerService.Contracts;
using CustomerService.Contracts.Models.Service.Customer;
using CustomerService.Contracts.Models.Service.Department;
using log4net;
using SettingsService.Contracts;
using SettingsService.Contracts.Models.DTO;
using SettingsService.Contracts.Models.Service.Settings;
using SettingsService.Contracts.Models.Service.Version;
using SettingsService.Data;
using SettingsService.Data.Contracts;
using SettingsService.Data.Models;
using SettingsService.Data.Models.Enumerations;
using SettingsService.Helpers;
using SettingsService.Infrastructure;
using TimeRegistrationService.Contracts;
using TimeRegistrationService.Contracts.Models.DTO;
using TimeRegistrationService.Contracts.Models.Enumerations;
using TimeRegistrationService.Contracts.Models.Service;
using AbsenceTypeDTO = SettingsService.Contracts.Models.DTO.AbsenceTypeDTO;
using DepartmentDTO = CustomerService.Contracts.Models.DTO.DepartmentDTO;
using ServiceStatus = SettingsService.Contracts.Models.Service.ServiceStatus;
using VersionInfoDTO = SettingsService.Contracts.Models.DTO.VersionInfoDTO;

namespace SettingsService
{
    /// <summary>
    /// Service for managing customer settings
    /// </summary>
    [AutomapServiceBehavior]
    public class SettingsService : ISettingsService
    {
        #region Variables
        private readonly ILog _log = LogManager.GetLogger(typeof(SettingsService));
        private readonly IUnitOfWork _unitOfWork;
        private readonly DataDbContext _dbContext;
        private readonly IAbsenceService _absenceService;
        private readonly ICustomerService _customerService;
        private readonly ITimeRegistrationService _timeRegistrationService;
        private readonly IAdministrationService _administrationService;
        private readonly IConfigurationService _configurationService;
        #endregion

        #region Constructors

        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="unitOfWork"></param>
        /// <param name="absenceService"></param>
        /// <param name="customerService"></param>
        /// <param name="timeRegistrationService"></param>
        /// <param name="administrationService"></param>
        /// <param name="configurationService"></param>
        /// <param name="dbContext"></param>
        public SettingsService(IUnitOfWork unitOfWork, IAbsenceService absenceService,
            ICustomerService customerService,
            ITimeRegistrationService timeRegistrationService,
            IAdministrationService administrationService,
            IConfigurationService configurationService,
            DataDbContext dbContext)
        {
            _unitOfWork = unitOfWork;
            _dbContext = dbContext;
            _absenceService = absenceService;
            _customerService = customerService;
            _timeRegistrationService = timeRegistrationService;
            _administrationService = administrationService;
            _configurationService = configurationService;
        }
        #endregion

        #region Methods

        public SettingsListVersionInfoResponse GetListVersions(SettingsListVersionInfoRequest request)
        {
            try
            {
                var assemblyName = Assembly.GetExecutingAssembly().GetName().Version.ToString();
                var serviceName = Assembly.GetExecutingAssembly().GetName().Name;
                var databaseName = _dbContext.Database.Connection.Database;

                var databaseVersion = _dbContext.Database.SqlQuery<string>(
                         "SELECT TOP 1 MigrationId FROM setting.__MigrationHistory ORDER BY LEFT(MigrationId, 15) DESC")
                         .FirstOrDefault();

                if (databaseVersion == null)
                {
                    return new SettingsListVersionInfoResponse(null, ServiceStatus.ServiceError, "Can't find version of database");
                }
                databaseVersion = databaseVersion.Substring(0, databaseVersion.IndexOf("_", StringComparison.Ordinal)).Substring(8);
                ICollection<VersionInfoDTO> informationsCollection = new List<VersionInfoDTO>
                {
                    // assembly
                    new VersionInfoDTO()
                    {
                        Description = serviceName,
                        Version = assemblyName
                    },
                    // database
                    new VersionInfoDTO()
                    {
                        Description = databaseName,
                        Version = databaseVersion
                    }
                };
                return new SettingsListVersionInfoResponse(informationsCollection, ServiceStatus.Success, string.Empty);
            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex);
                throw;
            }
        }

        /// <summary>
        /// Get user settings
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public GetUserSettingsResponse GetUserSettings(GetUserSettingsRequest request)
        {
            Stopwatch stopwatch = new Stopwatch();
            _log.Info($"Entry {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");

            try
            {
                _log.Info($"Getting user settings by userID {request.UserId}");
                stopwatch.Start();
                var userSettings = Mapper.Map<UserSettingDTO>(_unitOfWork.UserSettings.GetByUserId(request.UserId));
                _log.Info($"Got user settings from db in {stopwatch.ElapsedMilliseconds}");
                if (userSettings?.NotificationSettings == null || userSettings.LanguageSettings == null || userSettings.WorkScheduleSettings == null || userSettings.PublicHolidays == null || userSettings.ForcedAbsences == null || userSettings.AbsenceTypes == null)
                {
                    if (userSettings == null)
                    {
                        userSettings = new UserSettingDTO();
                    }
                    stopwatch.Restart();
                    _log.Info($"Getting user departments by userID: {request.UserId} by calling Customer service");
                    var getUserDefaultDepartment = _customerService.GetDefaultUserDepartment(new GetDefaultUserDepartmentRequest()
                    {
                        UserId = request.UserId
                    });

                    if (getUserDefaultDepartment.ServiceStatus != CustomerService.Contracts.Models.Service.ServiceStatus.Success)
                    {
                        _log.Info($"Received service status from Customer service are not successful");
                        return new GetUserSettingsResponse(null, ServiceStatus.ServiceError, getUserDefaultDepartment.ErrorMessage);
                    }

                    var departmentId = getUserDefaultDepartment.DepartmentId ?? 0;

                    _log.Info($"Getting department entity by departmentID: {departmentId} by calling Customer service");
                    var getDepartmentByIdResponse = _customerService.GetDepartmentById(new GetDepartmentByIdServiceRequest() { DepartmentId = departmentId });
                    if (getDepartmentByIdResponse.ServiceStatus != CustomerService.Contracts.Models.Service.ServiceStatus.Success)
                    {
                        _log.Info($"Received service status from Customer service are not successful");
                        return new GetUserSettingsResponse(null, ServiceStatus.ServiceError, getDepartmentByIdResponse.ErrorMessage);
                    }
                    _log.Info($"Building department settings");
                    var departmentSettings = BuildDepartmentSettings(getDepartmentByIdResponse.Department.CustomerId, departmentId);
                    if (departmentSettings == null)
                    {
                        return new GetUserSettingsResponse(null, ServiceStatus.ServiceError, getDepartmentByIdResponse.ErrorMessage);
                    }
                    _log.Info($"Filling user settings from department settings");
                    userSettings = FillUserSettingsFromDepartmentSettings(userSettings, departmentSettings);
                    _log.Info($"Built user settings in {stopwatch.ElapsedMilliseconds} ms");
                }
                _log.Info($"Returning user settings successfully");
                return new GetUserSettingsResponse(userSettings, ServiceStatus.Success, string.Empty);
            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex);
                throw;
            }
            finally
            {
                stopwatch.Stop();
                _log.Info($"Exit {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");
            }
        }

        /// <summary>
        /// Update user allocations directly
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public UpdateUserAllocationsResponse UpdateUserAllocations(UpdateUserAllocationsRequest request)
        {
            try
            {
                if (string.IsNullOrEmpty(request.UserId))
                {
                    return new UpdateUserAllocationsResponse(ServiceStatus.ServiceError, "WRONG_USER_ID");
                }

                var exsitedUserSettings = _unitOfWork.UserSettings.GetByUserId(request.UserId);

                // If not user settings, create the new one with absence allocation only
                if (exsitedUserSettings == null || exsitedUserSettings.Id == 0)
                {

                    var userSettings = new UserSetting()
                    {
                        UserId = request.UserId,
                        AbsenceTypeAllocations =
                            Mapper.Map<ICollection<AbsenceTypeAllocation>>(request.AbsenceTypeAllocations)
                    };
                    if (request.AbsenceTypeAllocations != null)
                    {
                        foreach (var absenceTypeAllocation in userSettings.AbsenceTypeAllocations)
                        {
                            var absenceType = _unitOfWork.AbsenceTypes.GetById(absenceTypeAllocation.AbsenceType.Id);
                            absenceTypeAllocation.AbsenceType = absenceType;
                        }
                    }

                    _log.Info($"Updating user settings with ID: {userSettings.Id}");
                    _unitOfWork.UserSettings.Add(userSettings);
                }
                else
                {

                    if (request.AbsenceTypeAllocations != null)
                    {
                        var usrsSettings = _unitOfWork.UserSettings.GetByUserId(request.UserId);
                        UpdateAbsenceTypeAllocations(exsitedUserSettings.AbsenceTypeAllocations, request.AbsenceTypeAllocations);
                    }
                    _unitOfWork.UserSettings.Update(exsitedUserSettings);
                }
                _unitOfWork.Commit();
                _log.Info($"User settings updated in database");
                _log.Info($"Recalculating user absences");
                RecalculateUserAbsences(request.UserId);
                _log.Info($"User settings updated successfully");
                return new UpdateUserAllocationsResponse(ServiceStatus.Success, string.Empty);


            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex, $"{GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");
                throw;
            }
        }


        /// <summary>
        /// Update user settings
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public UpdateUserSettingsResponse UpdateUserSettings(UpdateUserSettingsRequest request)
        {
            _log.Info($"Entry {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");

            try
            {
                if (string.IsNullOrEmpty(request.UserId))
                {
                    return new UpdateUserSettingsResponse(ServiceStatus.ServiceError, "WRONG_USER_ID");
                }

                #region Check if some settings not overriden
                if (request.NotificationSettingsOverride == false)
                {
                    request.NotificationSettings = null;
                }
                if (request.LanguageSettingsOverride == false)
                {
                    request.LanguageSettings = null;
                }
                if (request.WorkScheduleSettingsOverride == false)
                {
                    request.WorkScheduleSettings = null;
                }
                if (request.PublicHolidaysOverride == false)
                {
                    request.PublicHolidays = null;
                }
                if (request.ForcedAbsencesOverride == false)
                {
                    request.ForcedAbsences = null;
                }
                if (request.AbsenceTypesOverride == false)
                {
                    request.AbsenceTypes = null;
                }
                #endregion
                _log.Info($"Getting user settings by userID {request.UserId}");
                var userSettings = _unitOfWork.UserSettings.GetByUserId(request.UserId);
                if (userSettings == null || userSettings.Id == 0)
                {
                    userSettings = Mapper.Map<UserSetting>(request);
                    if (request.AbsenceTypeAllocations != null)
                    {
                        foreach (var absenceTypeAllocation in userSettings.AbsenceTypeAllocations)
                        {
                            var absenceType = _unitOfWork.AbsenceTypes.GetById(absenceTypeAllocation.AbsenceType.Id);
                            absenceTypeAllocation.AbsenceType = absenceType;
                        }
                    }

                    _log.Info($"Updating user settings with ID: {userSettings.Id}");
                    _unitOfWork.UserSettings.Add(userSettings);
                    _unitOfWork.Commit();
                    if (request.CalendarSettings.Any())
                    {
                        userSettings.DefaultCalendar = userSettings.CalendarSettings.FirstOrDefault();
                        _unitOfWork.UserSettings.Update(userSettings);
                    }
                }
                else
                {
                    // Is user uncheck ovveride checkbox on work schedule settings
                    if (request.WorkScheduleSettings == null && userSettings.WorkScheduleSettingsId.HasValue)
                    {
                        var daysToDelete = userSettings.WorkScheduleSettings.WorkingDays.ToList();
                        foreach (var workingDay in daysToDelete)
                        {
                            _unitOfWork.WorkingDays.Delete(workingDay);
                        }
                        _unitOfWork.WorkScheduleSettings.Delete(userSettings.WorkScheduleSettings);

                        userSettings.WorkScheduleSettingsId = null;
                        userSettings.WorkScheduleSettings = null;
                    }
                    else
                    {
                        if (request.WorkScheduleSettingsOverride)
                        {
                            // If user uncheck before work schedule settings then create again and update user settings with new one
                            if (userSettings.WorkScheduleSettings == null)
                            {
                                userSettings.WorkScheduleSettings =
                                    Mapper.Map<WorkScheduleSetting>(request.WorkScheduleSettings);
                                var idOfWSS = _unitOfWork.WorkScheduleSettings.Add(userSettings.WorkScheduleSettings);
                                userSettings.WorkScheduleSettingsId = idOfWSS;
                            }
                            else
                            {
                                UpdateWorkingTimeSchedule(userSettings.WorkScheduleSettings, request.WorkScheduleSettings, null, userSettings, false);
                            }
                        }
                    }
                    if (request.CalendarSettings != null)
                    {
                        UpdateCalendarSettings(userSettings.CalendarSettings, request.CalendarSettings);
                        var defaultCalendar = userSettings.CalendarSettings.FirstOrDefault(r => r.Id == request.DefaultCalendar.Id);
                        if (defaultCalendar != null)
                            userSettings.DefaultCalendar = defaultCalendar;


                    }
                    if (request.AbsenceTypeAllocations != null)
                    {
                        UpdateAbsenceTypeAllocations(userSettings.AbsenceTypeAllocations, request.AbsenceTypeAllocations);
                    }
                    _unitOfWork.UserSettings.Update(userSettings);
                }
                _unitOfWork.Commit();
                _log.Info($"User settings updated in database");
                RecalculateUserAbsences(userSettings.UserId);
                _log.Info($"Recalculating user absences");
                _log.Info($"User settings updated successfully");
                return new UpdateUserSettingsResponse(ServiceStatus.Success, string.Empty);
            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex);
                throw;
            }
            finally
            {
                _log.Info($"Exit {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");
            }
        }

        /// <summary>
        /// Get department settings
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public GetDepartmentSettingsResponse GetDepartmentSettings(GetDepartmentSettingsRequest request)
        {
            Stopwatch stopwatch = new Stopwatch();
            _log.Info($"Entry {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");

            try
            {
                _log.Info($"Gettimg department entity with ID: {request.DepartmentId} by calling Customer service");
                stopwatch.Start();
                var getDepartmentByIdResponse = _customerService.GetDepartmentById(new GetDepartmentByIdServiceRequest() { DepartmentId = request.DepartmentId });
                _log.Info($"Got department by id in {stopwatch.ElapsedMilliseconds}");
                if (getDepartmentByIdResponse.ServiceStatus != CustomerService.Contracts.Models.Service.ServiceStatus.Success)
                {
                    _log.Info($"Received service status from Customer service are not successful");
                    return new GetDepartmentSettingsResponse(null, ServiceStatus.ServiceError, getDepartmentByIdResponse.ErrorMessage);
                }
                _log.Info($"Building department settings for departmentID: {request.DepartmentId}");
                stopwatch.Restart();
                var departmentSettings = BuildDepartmentSettings(getDepartmentByIdResponse.Department.CustomerId, request.DepartmentId);
                if (departmentSettings == null)
                {
                    return new GetDepartmentSettingsResponse(null, ServiceStatus.ServiceError, "UNABLE_TO_GET_SETTINGS_FROM_SETTING_SERVCE");
                }
                _log.Info($"Built department settings in {stopwatch.ElapsedMilliseconds}");
                _log.Info($"Returning department settings successfully");
                return new GetDepartmentSettingsResponse(departmentSettings, ServiceStatus.Success, string.Empty);
            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex);
                throw;
            }
            finally
            {
                stopwatch.Stop();
                _log.Info($"Exit {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");
            }
        }

        //ToDo: Refactor!!!!!!!!!!!
        /// <summary>
        /// Update department settings
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public UpdateDepartmentSettingsResponse UpdateDepartmentSettings(UpdateDepartmentSettingsRequest request)
        {
            _log.Info($"Entry {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");

            try
            {
                if (request.DepartmentId < 1)
                {
                    return new UpdateDepartmentSettingsResponse(ServiceStatus.ServiceError, "WRONG_DEPARTMENT_ID");
                }

                #region Check if some settings not overriden

                if (request.NotificationSettingsOverride == false)
                {
                    request.NotificationSettings = null;
                }
                if (request.LanguageSettingsOverride == false)
                {
                    request.LanguageSettings = null;
                }
                if (request.WorkScheduleSettingsOverride == false)
                {
                    request.WorkScheduleSettings = null;
                }
                if (request.PublicHolidaysOverride == false)
                {
                    request.PublicHolidays = null;
                }
                if (request.ForcedAbsencesOverride == false)
                {
                    request.ForcedAbsences = null;
                }
                if (request.AbsenceTypesOverride == false)
                {
                    request.AbsenceTypes = null;
                }

                #endregion

                _log.Info($"Getting department settings entity by departmentID: {request.DepartmentId}");
                var departmentSettings = _unitOfWork.DepartmentSettings.GetByDepartmentId(request.DepartmentId);
                _log.Info($"Getting department entity for departmentID: {request.DepartmentId} by calling Customer service");
                var departmentEntity = _customerService.GetDepartmentById(new GetDepartmentByIdServiceRequest()
                {
                    DepartmentId = request.DepartmentId
                });
                ResponseStatus<CustomerService.Contracts.Models.Service.ServiceResponse>
                    .CheckSuccess(departmentEntity, _log);

                bool isSettingExistAlreadyForDepartment = departmentSettings != null && departmentSettings.Id != 0;
                bool isDepartmentSettingIsBlank = departmentSettings == null || departmentSettings.Id == 0;

                if (isSettingExistAlreadyForDepartment)
                {
                    bool isNeedRemoveExistedWorkScheduleSettings =
                        departmentSettings.WorkScheduleSettings != null && request.WorkScheduleSettings == null;
                    bool isNeedRemoveExistedAbsenceTypes = departmentSettings.AbsenceTypes.Any() &&
                                                      request.AbsenceTypes == null;
                    bool isNeedRemoveExistedPublicHolidays = departmentSettings.PublicHolidays.Any() &&
                                                             request.PublicHolidays == null;
                    bool isNeedRemoveExistedForcedAbsences = departmentSettings.ForcedAbsences.Any() &&
                                                             request.ForcedAbsences == null;

                    _log.Info("Department settings are not empty");
                    UpdateWorkingTimeSchedule(departmentSettings.WorkScheduleSettings, request.WorkScheduleSettings,
                        departmentSettings, null, isNeedRemoveExistedWorkScheduleSettings);
                    UpdateCalendarSettings(departmentSettings.CalendarSettings, request.CalendarSettings);

                    departmentSettings.NotificationSettings = Mapper.Map<NotificationSetting>(request.NotificationSettings);
                    departmentSettings.LanguageSettings = Mapper.Map<LanguageSetting>(request.LanguageSettings);

                    UpdateAbsenceTypes(isNeedRemoveExistedAbsenceTypes, departmentEntity, departmentSettings, request);
                    UpdateForcedAbsences(departmentSettings, request, departmentSettings.DepartmentId, isNeedRemoveExistedForcedAbsences);
                    UpdateHolidays(departmentSettings, request.PublicHolidays, isNeedRemoveExistedPublicHolidays);

                    departmentSettings.DefaultCalendarId = request.DefaultCalendar.Id;
                    _log.Info($"Updating department settings with ID: {departmentSettings}");
                    _unitOfWork.DepartmentSettings.Update(departmentSettings);
                }

                if (isDepartmentSettingIsBlank)
                {
                    var departmentSettingsRequest = Mapper.Map<DepartmentSetting>(request);
                    var users = GetUserList(departmentEntity.Department.CustomerId);
                    bool isRootDep = IsRootDepartmentOfCompany(departmentEntity.Department.CustomerId,
                                        request.DepartmentId);
                    foreach (var absenceType in departmentSettingsRequest.AbsenceTypes)
                    {
                        var requestedToUpdateProject = Mapper.Map<AbsenceType>(absenceType);
                        if (!isRootDep)
                            requestedToUpdateProject.Name =
                                $"{requestedToUpdateProject.Name} ({departmentEntity.Department.Name})";
                        _log.Info($"Creating of updating project with department settings, calling TimeRegistration project");
                        var createUpdateResponse = CreateOrUpdateProject(requestedToUpdateProject,
                            departmentEntity.Department.CustomerId, users);

                        ResponseStatus<ServiceResponse>.CheckSuccess(createUpdateResponse.Item1, _log);

                        absenceType.ProjectId = (int)createUpdateResponse.Item2;
                    }
                    _log.Info("Adding department settings to database");
                    departmentSettingsRequest.DefaultCalendarId = null;

                    // Case when user remove some absence after checking ovveride, then remove absence that connected with removed absence type
                    var departmentAbsences =
                            _absenceService.GetDepartmentAbsences(new GetDepartmentAbsencesRequest()
                            {
                                DepartmentId = request.DepartmentId
                            });

                    ResponseStatus<AbsenceService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(departmentAbsences, _log);

                    if (departmentAbsences.Absences != null)
                    {
                        foreach (var absence in departmentAbsences.Absences.ToList())
                        {
                            var absenceType = _unitOfWork.AbsenceTypes.GetById(absence.AbsenceTypeId);
                            var removedAbsenceType = departmentSettingsRequest.AbsenceTypes.FirstOrDefault(r => r.Name == absenceType.Name);
                            if (removedAbsenceType == null)
                            {
                                RemoveAbsence(absence);
                            }
                        }
                    }
                    _unitOfWork.DepartmentSettings.Add(departmentSettingsRequest);

                    _log.Info(
                        $"Getting department entity by departmentID: {request.DepartmentId} by calling Customer service");
                    var department = _customerService.GetDepartmentById(new GetDepartmentByIdServiceRequest
                    {
                        DepartmentId = request.DepartmentId
                    });

                    if (department.ServiceStatus != CustomerService.Contracts.Models.Service.ServiceStatus.Success)
                    {
                        _log.Info($"Received service status from Customer service are not successful");
                        return new UpdateDepartmentSettingsResponse(ServiceStatus.ServiceError, department.ErrorMessage);
                    }
                    if (request.ForcedAbsences != null)
                    {
                        var absences = new List<AbsenceDTO>();
                        var parentSettings = GetParentSettings(request, department);

                        foreach (var forcedAbsence in departmentSettingsRequest.ForcedAbsences)
                        {
                            _log.Info(
                                $"Creating of updating project with department settings, calling TimeRegistration project");
                            var createUpdateResponse = CreateOrUpdateProject(forcedAbsence.AbsenceType,
                                departmentEntity.Department.CustomerId, users);

                            ResponseStatus<ServiceResponse>.CheckSuccess(createUpdateResponse.Item1, _log);

                            AbsenceTypeDTO absenceType = null;
                            if (parentSettings != null && forcedAbsence.AbsenceType.Id == 0)
                            {
                                absenceType =
                           parentSettings.DepartmentSettings.AbsenceTypes.FirstOrDefault(
                               r => r.Name == forcedAbsence.AbsenceType.Name);
                            }


                            foreach (var user in department.Department.Users)
                            {
                                absences.Add(new AbsenceDTO
                                {
                                    UserId = user,
                                    State = AbsenceState.Approved,
                                    From = forcedAbsence.From,
                                    To = forcedAbsence.To,
                                    Comment = forcedAbsence.Name,
                                    AbsenceTypeId = absenceType.Id,
                                    AbsenceLenghtDay = 1,
                                    Reason = "Forced absence"
                                });
                            }
                        }
                        _log.Info($"Creating absences in transaction for: {absences.Count} absences");
                        var transactionResponse =
                            _absenceService.CreateAbsencesInTransaction(new CreateAbsencesInTransactionRequest
                            {
                                Absences = absences
                            });

                        ResponseStatus<AbsenceService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(transactionResponse, _log);

                        var transactionRetryResponse =
                            _absenceService.CreateAbsencesInTransaction(new CreateAbsencesInTransactionRequest
                            {
                                Absences = absences
                            });

                        ResponseStatus<AbsenceService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(transactionRetryResponse, _log);

                    }
                    _unitOfWork.Commit();
                    departmentSettingsRequest.DefaultCalendar = departmentSettingsRequest.CalendarSettings.FirstOrDefault();
                    _unitOfWork.DepartmentSettings.Update(departmentSettingsRequest);
                    ReasignOldAbsenceTypeOnDepartmentAbsence(request.DepartmentId);
                }

                if (isSettingExistAlreadyForDepartment)
                {
                    _log.Info($"Recalculating department absences for department {departmentSettings.DepartmentId}");
                    RecalculateDepartmentAbsences(departmentSettings.DepartmentId);
                }
                _unitOfWork.Commit();
                _log.Info($"Department settings updated successfully");
                return new UpdateDepartmentSettingsResponse(ServiceStatus.Success, string.Empty);
            }
            catch (SettingServiceException ex)
            {
                return new UpdateDepartmentSettingsResponse(ServiceStatus.ServiceError, ex.Message);
            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex);
                throw;
            }
            finally
            {
                _log.Info($"Exit {GetType().FullName}.{System.Reflection.MethodBase.GetCurrentMethod().Name}");
            }
        }






        /// <summary>
        /// Call this method only at environment initializations.
        /// Need to assign missing default calendars on old customers
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public AssignDefaultCalendarsToDepartmentsResponse AssignDefaultCalendarsToDepartments(AssignDefaultCalendarsToDepartmentsRequest request)
        {
            _log.Info($"Entry {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");
            try
            {
                var allCustomers = _customerService.GetAllCustomers(new GetAllCustomersServiceRequest());

                ResponseStatus<CustomerService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(allCustomers, _log);

                foreach (var customer in allCustomers.Customers.ToList())
                {
                    var customerTemplateResponse =
                        _configurationService.GetCustomerTemplatesByAbbreviation(new GetCustomerTemplatesByAbbreviationRequest
                            ()
                        {
                            Abbreviation = customer.Country
                        });

                    ResponseStatus<ConfigurationService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(customerTemplateResponse, _log);
                    var customerTemplate = customerTemplateResponse.CustomerTemplates.FirstOrDefault();

                    var departmentsOfCustomerResponse =
                        _customerService.GetAllDepartments(new GetAllDepartmentsServiceRequest()
                        {
                            CustomerId = customer.Id
                        });

                    ResponseStatus<CustomerService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(departmentsOfCustomerResponse, _log);

                    var departmentsOfCustomer = departmentsOfCustomerResponse.Departments.ToList();
                    foreach (var department in departmentsOfCustomer)
                    {
                        var getDepSetting = _unitOfWork.DepartmentSettings.GetByDepartmentId(department.Id);
                        if (getDepSetting != null && customerTemplate != null)
                        {
                            var calendarSettings = getDepSetting.CalendarSettings.FirstOrDefault();
                            var defaultCalendar = customerTemplate.CalendarSettings.FirstOrDefault();

                            if (calendarSettings == null && defaultCalendar != null)
                            {
                                var defaultClaendarModel =
                                    Mapper.Map<CalendarSetting>(defaultCalendar);

                                getDepSetting.CalendarSettings = new List<CalendarSetting>()
                                {
                                   defaultClaendarModel
                                };
                                getDepSetting.DefaultCalendar = defaultClaendarModel;
                            }
                        }
                    }
                }
                _unitOfWork.Commit();

                return new AssignDefaultCalendarsToDepartmentsResponse(ServiceStatus.Success, string.Empty);
            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex);
                throw;
            }
            finally
            {
                _log.Info($"Exit {GetType().FullName}.{System.Reflection.MethodBase.GetCurrentMethod().Name}");
            }
        }



        /// <summary>
        /// Get customer settings
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public GetCustomerSettingsResponse GetCustomerSettings(GetCustomerSettingsRequest request)
        {
            _log.Info($"Entry {GetType().FullName}.{System.Reflection.MethodBase.GetCurrentMethod().Name}");

            try
            {
                _log.Info($"Getting all departments for customerID {request.CustomerId} by calling Customer service");
                var getDepartmentsByCustomerIdResponse = _customerService.GetAllDepartments(new GetAllDepartmentsServiceRequest
                {
                    CustomerId = request.CustomerId
                });

                ResponseStatus<CustomerService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(getDepartmentsByCustomerIdResponse, _log);

                var departmentsSettings = new List<DepartmentSettingDTO>();

                foreach (var department in getDepartmentsByCustomerIdResponse.Departments)
                {
                    BuildCustomerSettings(departmentsSettings, department, request.CustomerId);
                }
                _log.Info($"Returning customer settings successfully");
                return new GetCustomerSettingsResponse(departmentsSettings, ServiceStatus.Success, string.Empty);
            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex);
                throw;
            }
            finally
            {
                _log.Info($"Exit {GetType().FullName}.{System.Reflection.MethodBase.GetCurrentMethod().Name}");
            }
        }

        /// <summary>
        /// Delete customer settings
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public DeleteCustomerSettingsResponse DeleteCustomerSettings(DeleteCustomerSettingsRequest request)
        {
            _log.Info($"Entry {GetType().FullName}.{MethodBase.GetCurrentMethod().Name}");

            try
            {
                var departmentSettings = _unitOfWork.DepartmentSettings.GetAll()
                    .Where(x => request.Departments.Contains(x.DepartmentId));
                var userSettings = _unitOfWork.UserSettings.GetAll()
                    .Where(x => request.Users.Contains(x.UserId));
                foreach (var userSetting in userSettings.ToList())
                {
                    if (userSetting.DefaultCalendar != null)
                        _unitOfWork.CalendarSettings.Delete(userSetting.DefaultCalendar);
                    foreach (var absenceType in userSetting.AbsenceTypes.ToList())
                        _unitOfWork.AbsenceTypes.Delete(absenceType);
                    foreach (var absenceType in userSetting.AbsenceTypeAllocations.ToList())
                        _unitOfWork.AbsenceTypeAllocations.Delete(absenceType);
                    foreach (var absenceType in userSetting.ForcedAbsences.ToList())
                        _unitOfWork.ForcedAbsences.Delete(absenceType);
                    foreach (var absenceType in userSetting.PublicHolidays.ToList())
                        _unitOfWork.Holidays.Delete(absenceType);
                    foreach (var calendarSetting in userSetting.CalendarSettings.ToList())
                        _unitOfWork.CalendarSettings.Delete(calendarSetting);
                }
                foreach (var departmentSetting in departmentSettings.ToList())
                {
                    if (departmentSetting.DefaultCalendar != null)
                        _unitOfWork.CalendarSettings.Delete(departmentSetting.DefaultCalendar);
                    foreach (var absenceType in departmentSetting.AbsenceTypes.ToList())
                        _unitOfWork.AbsenceTypes.Delete(absenceType);
                    foreach (var absenceType in departmentSetting.ForcedAbsences.ToList())
                        _unitOfWork.ForcedAbsences.Delete(absenceType);
                    foreach (var absenceType in departmentSetting.PublicHolidays.ToList())
                        _unitOfWork.Holidays.Delete(absenceType);
                    foreach (var calendarSetting in departmentSetting.CalendarSettings.ToList())
                        _unitOfWork.CalendarSettings.Delete(calendarSetting);
                    foreach (var calendarSetting in departmentSetting.CalendarSettings.ToList())
                        _unitOfWork.CalendarSettings.Delete(calendarSetting);
                }
                _unitOfWork.Commit();

                foreach (var departmentSetting in departmentSettings)
                {
                    _unitOfWork.DepartmentSettings.Delete(departmentSetting);
                }

                foreach (var userSetting in userSettings)
                {
                    _unitOfWork.UserSettings.Delete(userSetting);
                }
                _unitOfWork.Commit();



                return new DeleteCustomerSettingsResponse(ServiceStatus.Success, string.Empty);
            }
            catch (Exception ex)
            {
                _log.LogErrorWithParameters(request, ex);
                throw;
            }
            finally
            {
                _log.Info($"Exit {GetType().FullName}.{System.Reflection.MethodBase.GetCurrentMethod().Name}");
            }
        }
        #endregion

        #region Helpers

        private Tuple<ServiceResponse, int?> CreateOrUpdateProject(AbsenceType absenceType, int departmentId, string[] users)
        {
            if (absenceType.Id == 0)
            {
                return CreateProject(absenceType.Name, departmentId, users);
            }
            var currProject = _timeRegistrationService.GetProjectById(new GetProjectByIdServiceRequest()
            {
                Id = absenceType.ProjectId
            });
            if (currProject.Project == null)
            {
                return CreateProject(absenceType.Name, departmentId, users);
            }
            if (currProject.ServiceStatus != TimeRegistrationService.Contracts.Models.Service.ServiceStatus.Success)
            {
                return new Tuple<ServiceResponse, int?>(new ServiceResponse(
                    TimeRegistrationService.Contracts.Models.Service.ServiceStatus.ServiceError, currProject.ErrorMessage),
                    null);
            }
            var updateResponse = _timeRegistrationService.UpdateProject(new UpdateProjectServiceRequest
            {
                Project = new ProjectDTO
                {
                    Id = absenceType.ProjectId,
                    Name = absenceType.Name,
                    State = currProject.Project.State,
                    Children = currProject.Project.Children,
                    Budget = currProject.Project.Budget,
                    CustomerId = currProject.Project.CustomerId,
                    ProjectType = currProject.Project.ProjectType
                }
            });
            if (updateResponse.ServiceStatus != TimeRegistrationService.Contracts.Models.Service.ServiceStatus.Success)
            {
                return new Tuple<ServiceResponse, int?>(new ServiceResponse(
                    TimeRegistrationService.Contracts.Models.Service.ServiceStatus.ServiceError, updateResponse.ErrorMessage),
                    null);
            }
            return new Tuple<ServiceResponse, int?>(new ServiceResponse(
                TimeRegistrationService.Contracts.Models.Service.ServiceStatus.Success, updateResponse.ErrorMessage),
                updateResponse.Project.Id);
        }

        private Tuple<ServiceResponse, int?> CreateProject(string name, int departmentId, string[] users)
        {
            var createResponse = _timeRegistrationService.CreateProject(new CreateProjectServiceRequest
            {
                Name = name,
                State = ProjectState.Active,
                Budget = 0,
                CustomerId = departmentId,
                Children = null,
                ProjectType = new ProjectTypeDTO
                {
                    Name = name,
                    CustomerId = departmentId
                },
                BuiltIn = true
            });
            if (createResponse.ServiceStatus != TimeRegistrationService.Contracts.Models.Service.ServiceStatus.Success)
            {
                return new Tuple<ServiceResponse, int?>(new ServiceResponse(
                    TimeRegistrationService.Contracts.Models.Service.ServiceStatus.ServiceError,
                    createResponse.ErrorMessage), null);
            }
            foreach (var user in users)
            {
                _timeRegistrationService.AddUserProject(new AddUserProjectServiceRequest()
                {
                    UserId = user,
                    ProjectId = createResponse.Project.Id
                });
            }
            return new Tuple<ServiceResponse, int?>(new ServiceResponse(
                TimeRegistrationService.Contracts.Models.Service.ServiceStatus.Success, createResponse.ErrorMessage),
                createResponse.Project.Id);
        }

        private ServiceResponse DeleteProject(int id)
        {
            var response = _timeRegistrationService.DeleteProject(new DeleteProjectServiceRequest
            {
                Id = id
            });
            if (response.ServiceStatus != TimeRegistrationService.Contracts.Models.Service.ServiceStatus.Success)
            {
                return new ServiceResponse(TimeRegistrationService.Contracts.Models.Service.ServiceStatus.ServiceError, response.ErrorMessage);
            }
            return new ServiceResponse(TimeRegistrationService.Contracts.Models.Service.ServiceStatus.Success, string.Empty);
        }

        /// <summary>
        /// Check if any absences can be recalculated after changed user settings
        /// </summary>
        /// <param name="userId"></param>
        private void RecalculateUserAbsences(string userId)
        {
            var recalculateUserAbsencesResponse = _absenceService.RecalculateUserAbsences(new RecalculateUserAbsencesRequest() { UserId = userId });
        }

        /// <summary>
        /// Check if any absences can be recalculated after changed department settings
        /// </summary>
        /// <param name="departmentId"></param>
        private void RecalculateDepartmentAbsences(int departmentId)
        {
            var recalculateDepartmentAbsencesResponse = _absenceService.RecalculateDepartmentAbsences(new RecalculateDepartmentAbsencesRequest() { DepartmentId = departmentId });
        }

        /// <summary>
        /// Fill user settings from department with inheritance
        /// </summary>
        /// <param name="userSettings"></param>
        /// <param name="departmentSettings"></param>
        /// <returns></returns>
        private UserSettingDTO FillUserSettingsFromDepartmentSettings(UserSettingDTO userSettings, DepartmentSettingDTO departmentSettings)
        {
            if (userSettings.NotificationSettings == null)
            {
                userSettings.NotificationSettings = departmentSettings.NotificationSettings;
                userSettings.NotificationSettingsOverride = false;
            }
            else
            {
                userSettings.NotificationSettingsOverride = true;
            }
            if (userSettings.LanguageSettings == null)
            {
                userSettings.LanguageSettings = departmentSettings.LanguageSettings;
                userSettings.LanguageSettingsOverride = false;
            }
            else
            {
                userSettings.LanguageSettingsOverride = true;
            }
            if (userSettings.WorkScheduleSettings == null)
            {
                userSettings.WorkScheduleSettings = departmentSettings.WorkScheduleSettings;
                userSettings.WorkScheduleSettingsOverride = false;
            }
            else
            {
                userSettings.WorkScheduleSettingsOverride = true;
            }
            if (userSettings.PublicHolidays != null && userSettings.PublicHolidays.Any())
            {
                userSettings.PublicHolidaysOverride = true;
            }
            else
            {
                userSettings.PublicHolidays = departmentSettings.PublicHolidays;
                userSettings.PublicHolidaysOverride = false;
            }
            if (userSettings.ForcedAbsences != null && userSettings.ForcedAbsences.Any())
            {
                userSettings.ForcedAbsencesOverride = true;
            }
            else
            {
                userSettings.ForcedAbsences = departmentSettings.ForcedAbsences;
                userSettings.ForcedAbsencesOverride = false;
            }
            if (userSettings.AbsenceTypes != null && userSettings.AbsenceTypes.Any())
            {
                userSettings.AbsenceTypesOverride = true;
            }
            else
            {
                userSettings.AbsenceTypes = departmentSettings.AbsenceTypes;
                userSettings.AbsenceTypesOverride = false;
            }
            if (userSettings.CalendarSettings == null || !userSettings.CalendarSettings.Any())
            {
                userSettings.CalendarSettings = departmentSettings.CalendarSettings;
            }
            if (userSettings.DefaultCalendar == null)
            {
                userSettings.DefaultCalendar = departmentSettings.DefaultCalendar;
            }
            return userSettings;
        }

        /// <summary>
        /// Build department full settings using all inheritance
        /// Get root department find branch for selected department, go from up to down and write settings
        /// If selected department has own settings set Override for own settings blocks
        /// </summary>
        /// <param name="customerId"></param>
        /// <param name="departmentId"></param>
        /// <returns></returns>
        private DepartmentSettingDTO BuildDepartmentSettings(int customerId, int departmentId)
        {
            var buildedSettings = new DepartmentSettingDTO()
            {
                DepartmentId = departmentId
            };
            var getCustomerByIdResponse = _customerService.GetCustomerById(new GetCustomerByIdServiceRequest() { CustomerId = customerId });
            if (getCustomerByIdResponse.ServiceStatus != CustomerService.Contracts.Models.Service.ServiceStatus.Success)
            {
                return null;
            }
            var customerRootDepartment = getCustomerByIdResponse.Customer.Department;

            bool isRootDepartmentOfTheCompany = false;
            if (customerRootDepartment == null)
            {
                throw new Exception("ERROR_NO_ROOT_DEPARTMENT");
            }
            if (customerRootDepartment.Id == departmentId)
                isRootDepartmentOfTheCompany = true;
            CleanTree(departmentId, customerRootDepartment);
            return DepartmentSettingsByCheckingTree(buildedSettings, customerRootDepartment, departmentId, isRootDepartmentOfTheCompany);
        }

        /// <summary>
        /// Build final settings through all tree paths
        /// </summary>
        /// <param name="departmentSetting"></param>
        /// <param name="department"></param>
        /// <param name="requestedDepartmentId"></param>
        /// <returns></returns>
        private DepartmentSettingDTO DepartmentSettingsByCheckingTree(DepartmentSettingDTO departmentSetting, DepartmentDTO department, int requestedDepartmentId, bool isRootDepartmentOfTheCompany)
        {
            var currentDepartmentSettings = _unitOfWork.DepartmentSettings.GetByDepartmentId(department.Id);
            if (currentDepartmentSettings != null)
            {
                departmentSetting.NotificationSettings = Mapper.Map<NotificationSettingDTO>(currentDepartmentSettings.NotificationSettings) ?? departmentSetting.NotificationSettings;
                departmentSetting.NotificationSettingsOverride = currentDepartmentSettings.NotificationSettings != null && currentDepartmentSettings.DepartmentId == requestedDepartmentId;
                departmentSetting.LanguageSettings = Mapper.Map<LanguageSettingDTO>(currentDepartmentSettings.LanguageSettings) ?? departmentSetting.LanguageSettings;
                departmentSetting.LanguageSettingsOverride = currentDepartmentSettings.LanguageSettings != null && currentDepartmentSettings.DepartmentId == requestedDepartmentId;
                departmentSetting.WorkScheduleSettings = Mapper.Map<WorkScheduleSettingDTO>(currentDepartmentSettings.WorkScheduleSettings) ?? departmentSetting.WorkScheduleSettings;
                departmentSetting.WorkScheduleSettingsOverride = currentDepartmentSettings.WorkScheduleSettings != null && currentDepartmentSettings.DepartmentId == requestedDepartmentId;
                departmentSetting.PublicHolidays = currentDepartmentSettings.PublicHolidays.Any() ? Mapper.Map<ICollection<Contracts.Models.DTO.HolidayDTO>>(currentDepartmentSettings.PublicHolidays) : departmentSetting.PublicHolidays;
                if (departmentSetting.PublicHolidays != null)
                {
                    foreach (var publicHoliday in departmentSetting.PublicHolidays)
                    {
                        publicHoliday.Day += publicHoliday.EasterOffset;
                    }
                }
                departmentSetting.PublicHolidaysOverride = currentDepartmentSettings.PublicHolidays.Any() && currentDepartmentSettings.DepartmentId == requestedDepartmentId;
                departmentSetting.ForcedAbsences = currentDepartmentSettings.ForcedAbsences.Any() ? Mapper.Map<ICollection<ForcedAbsenceDTO>>(currentDepartmentSettings.ForcedAbsences) : departmentSetting.ForcedAbsences;
                // If department is root (company) then forced absence is always true, if request is child department we check any forced absences and is department have own settings
                departmentSetting.ForcedAbsencesOverride = isRootDepartmentOfTheCompany || currentDepartmentSettings.ForcedAbsences.Any() && currentDepartmentSettings.DepartmentId == requestedDepartmentId;
                departmentSetting.AbsenceTypes = currentDepartmentSettings.AbsenceTypes.Any() ? Mapper.Map<ICollection<Contracts.Models.DTO.AbsenceTypeDTO>>(currentDepartmentSettings.AbsenceTypes) : departmentSetting.AbsenceTypes;
                departmentSetting.AbsenceTypesOverride = currentDepartmentSettings.AbsenceTypes.Any() && currentDepartmentSettings.DepartmentId == requestedDepartmentId;
                departmentSetting.CalendarSettings = currentDepartmentSettings.CalendarSettings.Any() ? Mapper.Map<ICollection<CalendarSettingDTO>>(currentDepartmentSettings.CalendarSettings) : departmentSetting.CalendarSettings;
                departmentSetting.DefaultCalendar = currentDepartmentSettings.DefaultCalendar != null ? Mapper.Map<CalendarSettingDTO>(currentDepartmentSettings.DefaultCalendar) : departmentSetting.DefaultCalendar;
                if (department.Departments != null && department.Departments.Any())
                {
                    departmentSetting = DepartmentSettingsByCheckingTree(departmentSetting, department.Departments.FirstOrDefault(), requestedDepartmentId, false);
                }
            }
            return departmentSetting;
        }
        private void BuildCustomerSettings(List<DepartmentSettingDTO> departmentSettingsList, DepartmentDTO department, int customerId)
        {
            _log.Info($"Building department settings for department with ID {department.Id}");
            var departmentSettings = BuildDepartmentSettings(customerId, department.Id);
            if (departmentSettings == null)
            {
                throw new Exception("UNABLE_TO_GET_SETTINGS_FROM_SETTING_SERVCE");
            }
            departmentSettings.DepartmentName = department.Name;
            departmentSettingsList.Add(departmentSettings);
            foreach (var departmentDTO in department.Departments)
            {
                BuildCustomerSettings(departmentSettingsList, departmentDTO, customerId);
            }
        }
        /// <summary>
        /// Cleaning department tree, stays only branches with department
        /// </summary>
        /// <param name="departmentId"></param>
        /// <param name="department"></param>
        private void CleanTree(int departmentId, DepartmentDTO department)
        {
            for (int i = department.Departments.Count() - 1; i >= 0; i--)
            {
                CleanTree(departmentId, department.Departments[i]);
                if (department.Departments[i].Departments.Count == 0)
                {
                    if (department.Departments[i].Id != departmentId)
                    {
                        department.Departments.RemoveAt(i);
                    }
                }
            }
        }

        private void UpdateHolidays(DepartmentSetting departmentSetting, ICollection<HolidayDTO> reqHolidays, bool isNeedRemoveSettings)
        {
            // If no request settings and no need to remove existed one - just pass this method.
            if (reqHolidays == null && !isNeedRemoveSettings)
                return;

            if (isNeedRemoveSettings)
            {
                departmentSetting.PublicHolidays = null;
                return;
            }

            _log.Info("Updating Holidays");
            var holidaysToDelete = new List<Holiday>();
            foreach (var holiday in departmentSetting.PublicHolidays)
            {
                var reqAbsence = reqHolidays.FirstOrDefault(x => x.Id == holiday.Id);
                if (reqAbsence != null)
                {
                    holiday.Name = reqAbsence.Name;
                    holiday.Day = reqAbsence.Day;
                    holiday.DayLength = reqAbsence.DayLength;
                    holiday.EasterOffset = reqAbsence.EasterOffset;
                    holiday.Month = reqAbsence.Month;
                    holiday.Year = reqAbsence.Year;
                    holiday.Type = Mapper.Map<HolidayTypeEnum>(reqAbsence.Type);
                    _unitOfWork.Holidays.Update(holiday);
                }
                else
                {
                    holidaysToDelete.Add(holiday);
                }
            }

            foreach (var holiday in holidaysToDelete)
            {
                _unitOfWork.Holidays.Delete(holiday);
            }

            foreach (var holiday in reqHolidays)
            {
                if (holiday.Id == 0)
                {
                    var mappedHoliday = Mapper.Map<Holiday>(holiday);
                    departmentSetting.PublicHolidays.Add(mappedHoliday);
                }
            }
        }

        private void RemoveAbsence(AbsenceExtendedDTO absence)
        {
            // Absence removal
            var absenceDeleteRequest =
                _absenceService.DeleteAbsence(new DeleteAbsenceRequest() { AbsenceId = absence.Id });
            ResponseStatus<AbsenceService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(absenceDeleteRequest, _log);
        }

        private void UpdateCalendars(ICollection<CalendarSetting> calendars,
            ICollection<CalendarSettingDTO> reqCalendars)
        {
            List<CalendarSetting> calendarsToDelete = new List<CalendarSetting>();
            foreach (var calendar in calendars)
            {
                var reqCalendar = reqCalendars.FirstOrDefault(x => x.Id == calendar.Id);
                if (reqCalendar != null)
                {
                    calendar.Name = reqCalendar.Name;
                    calendar.BuiltIn = reqCalendar.BuiltIn;
                    calendar.Day = reqCalendar.Day;
                    calendar.Month = reqCalendar.Month;
                    _unitOfWork.CalendarSettings.Update(calendar);
                }
                else
                {
                    calendarsToDelete.Add(calendar);
                }
            }

            foreach (var calendar in calendarsToDelete)
            {
                if (!calendar.BuiltIn)
                    _unitOfWork.CalendarSettings.Delete(calendar);
            }

            foreach (var calendar in reqCalendars)
            {
                if (calendar.Id == 0)
                {
                    var mappedHoliday = Mapper.Map<CalendarSetting>(calendar);
                    calendars.Add(mappedHoliday);
                }
            }
        }

        private void ReasignOldAbsenceTypeOnDepartmentAbsence(int departmentId)
        {
            var departmentAbsences =
                       _absenceService.GetDepartmentAbsences(new GetDepartmentAbsencesRequest()
                       {
                           DepartmentId = departmentId
                       });
            if (departmentAbsences.Absences == null) return;

            var depSettingsAfterSave = _unitOfWork.DepartmentSettings.GetByDepartmentId(departmentId);
            foreach (var absence in departmentAbsences.Absences.ToList())
            {
                var oldAbsenceType = _unitOfWork.AbsenceTypes.GetById(absence.AbsenceTypeId);
                if (oldAbsenceType == null) continue;

                var newAbsenceType =
                    depSettingsAfterSave.AbsenceTypes.First(
                        r => r.Name == oldAbsenceType.Name);

                // Replace absence type id of absence to parent absence type ID
                var absenceTypeUpdateRequest =
                    _absenceService.UpdateAbsenceTypeId(new UpdateAbsenceTypeOfAbsenceRequest()
                    {
                        AbsenceTypeId = newAbsenceType.Id,
                        AbsenceId = absence.Id
                    });
                ResponseStatus<AbsenceService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(absenceTypeUpdateRequest, _log);
            }
        }

        private void UpdateAbsenceTypes(bool isNeedRemoveExistedAbsenceTypes, GetDepartmentByIdServiceResponse
           getDepartmentByIdResponse, DepartmentSetting departmentSetting, UpdateDepartmentSettingsRequest updateDepartmentSettingsRequest
           )
        {
            if (updateDepartmentSettingsRequest.AbsenceTypes == null && !isNeedRemoveExistedAbsenceTypes)
                return;

            _log.Info("Updating absence types");
            _log.Info("Getting user liset");
            var users = GetUserList(getDepartmentByIdResponse.Department.CustomerId);
            bool isRootDep = IsRootDepartmentOfCompany(getDepartmentByIdResponse.Department.CustomerId,
                updateDepartmentSettingsRequest.DepartmentId);
            _log.Info($"Total users:{users.Length}");
            List<AbsenceType> absenceTypesToDelete = new List<AbsenceType>();
            _log.Info($"Total absence types: {departmentSetting.AbsenceTypes.Count}");
            foreach (var absenceType in departmentSetting.AbsenceTypes)
            {
                if (updateDepartmentSettingsRequest.AbsenceTypes != null)
                {
                    var reqAbsence = updateDepartmentSettingsRequest.AbsenceTypes.FirstOrDefault(x => x.Id == absenceType.Id);
                    //reqAbsence.
                    if (reqAbsence != null)
                    {
                        _log.Info($"Updating absence type: {reqAbsence.Id}");
                        absenceType.Color = reqAbsence.Color;
                        absenceType.Name = reqAbsence.Name;
                        absenceType.RequiresApproval = reqAbsence.RequiresApproval;
                        absenceType.YearlyAllocations = reqAbsence.YearlyAllocations;
                        absenceType.PastRegistrationAllowed = reqAbsence.PastRegistrationAllowed;
                        _log.Info(
                            $"Creating of updating project with department settings, calling TimeRegistration project");
                        var updateResponse = CreateOrUpdateProject(absenceType,
                            getDepartmentByIdResponse.Department.CustomerId, users);
                        ResponseStatus<ServiceResponse>.CheckSuccess(updateResponse.Item1, _log);
                        absenceType.ProjectId = (int)updateResponse.Item2;
                        _unitOfWork.AbsenceTypes.Update(absenceType);
                    }
                    else
                        absenceTypesToDelete.Add(absenceType);

                }
                else
                {
                    _log.Info($"Deleting absence type {absenceType.Id}");
                    absenceTypesToDelete.Add(absenceType);
                }
            }

            var departmentAbsences =
               _absenceService.GetDepartmentAbsences(new GetDepartmentAbsencesRequest()
               {
                   DepartmentId = departmentSetting.DepartmentId
               });

            ResponseStatus<AbsenceService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(departmentAbsences, _log);

            GetDepartmentSettingsResponse parentDepartmentSettings = null;
            // If requested department not root get parent dep settings
            if (!isRootDep)
            {
                // Get parent department
                var parentDepartment = _customerService.GetParentDepartment(new GetParentDepartmentRequest()
                {
                    DepartmentId = getDepartmentByIdResponse.Department.Id
                });

                ResponseStatus<CustomerService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(parentDepartment, _log);
                // Parent dep settings
                parentDepartmentSettings = GetDepartmentSettings(new GetDepartmentSettingsRequest() { DepartmentId = parentDepartment.Department.Id });
                ResponseStatus<Contracts.Models.Service.ServiceResponse>.CheckSuccess(parentDepartmentSettings, _log);
            }


            _log.Info("Deleting absence types");
            foreach (var absenceType in absenceTypesToDelete)
            {
                if (departmentAbsences.Absences != null)
                {
                    var absenceToDelete =
                    departmentAbsences.Absences.Where(r => r.AbsenceTypeId == absenceType.Id);

                    foreach (var absence in absenceToDelete.ToList())
                    {
                        // If no parent dep or user not unchecked ovveride settings then just remove absence that connected with absence type
                        if (parentDepartmentSettings == null | !isNeedRemoveExistedAbsenceTypes)
                        {
                            // Absence removal
                            RemoveAbsence(absence);
                            continue;
                        }

                        // Find absence type from removed absence type list
                        var absenceTypeOfCurrentAbsence = absenceTypesToDelete.FirstOrDefault(r => r.Id == absence.AbsenceTypeId);

                        // RELINK PART
                        // Find matched by name absence type of parent absence types
                        var matchedParentAbsenceType = parentDepartmentSettings.DepartmentSettings.AbsenceTypes.FirstOrDefault(
                            r => string.Equals(r.Name, absenceTypeOfCurrentAbsence?.Name, StringComparison.CurrentCultureIgnoreCase));

                        // If no matched absence type by name then remove all absences that connected with removed absence type
                        if (matchedParentAbsenceType == null)
                        {
                            RemoveAbsence(absence);
                        }
                        else
                        {
                            // Replace absence type id of absence to parent absence type ID
                            var absenceTypeUpdateRequest =
                                _absenceService.UpdateAbsenceTypeId(new UpdateAbsenceTypeOfAbsenceRequest()
                                {
                                    AbsenceTypeId = matchedParentAbsenceType.Id,
                                    AbsenceId = absence.Id
                                });

                            ResponseStatus<AbsenceService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(absenceTypeUpdateRequest, _log);
                        }

                    }
                }

                // TODO: Disqus this part with Kristian!!!
                _log.Info($"Deleting project with projectID: {absenceType.ProjectId}, calling TimeRegistration project");
                var deleteResponse = DeleteProject(absenceType.ProjectId);
                ResponseStatus<ServiceResponse>.CheckSuccess(deleteResponse, _log);
                _log.Info($"Deleting absenceType with absenceTypeID: {absenceType.Id}");
                _unitOfWork.AbsenceTypes.Delete(absenceType);
            }

            if (isNeedRemoveExistedAbsenceTypes)
                departmentSetting.AbsenceTypes = null;

            _log.Info("Adding new absence types");
            if (updateDepartmentSettingsRequest.AbsenceTypes != null)
            {
                foreach (var absenceType in updateDepartmentSettingsRequest.AbsenceTypes.ToList())
                {
                    if (absenceType.Id == 0)
                    {
                        _log.Info($"Adding new absence type: {absenceType.Name}");
                        var mappedAbsenceType = Mapper.Map<AbsenceType>(absenceType);
                        var requestToCreateProject = Mapper.Map<AbsenceType>(absenceType);
                        if (!isRootDep)
                            requestToCreateProject.Name =
                                $"{requestToCreateProject.Name} ({getDepartmentByIdResponse.Department.Name})";
                        _log.Info($"Creating of updating project with department settings, calling TimeRegistration project");
                        var createUpdateResponse = CreateOrUpdateProject(requestToCreateProject, getDepartmentByIdResponse.Department.CustomerId, users);
                        ResponseStatus<ServiceResponse>.CheckSuccess(createUpdateResponse.Item1, _log);
                        mappedAbsenceType.ProjectId = (int)createUpdateResponse.Item2;
                        departmentSetting.AbsenceTypes.Add(mappedAbsenceType);
                    }
                }
            }
        }

        private string[] GetUserList(int customerId)
        {
            var usersResponse = _administrationService.GetAllUsersForCustomer(new GetAllUsersForCustomerServiceRequest()
            {
                CompanyId = customerId
            });
            return usersResponse.Users.Select(x => x.Id).ToArray();
        }

        private void UpdateWorkingTimeSchedule(WorkScheduleSetting workScheduleSetting, WorkScheduleSettingDTO workScheduleDto,
            DepartmentSetting departmentSetting, UserSetting userSetting, bool isNeedRemoveSettings)
        {
            // If no request settings and no need to remove existed one - just pass this method.
            if (workScheduleDto == null && !isNeedRemoveSettings)
                return;

            if (isNeedRemoveSettings)
            {
                departmentSetting.WorkScheduleSettings = null;
                return;
            }

            _log.Info("Updating working time schedule");
            if (workScheduleSetting == null || workScheduleSetting.Id == 0)
            {
                workScheduleSetting = Mapper.Map<WorkScheduleSetting>(workScheduleDto);
                _dbContext.Entry(workScheduleSetting).State = EntityState.Added;
                if (departmentSetting != null)
                    departmentSetting.WorkScheduleSettingsId = workScheduleSetting.Id;
                else
                    userSetting.WorkScheduleSettingsId = workScheduleSetting.Id;
            }
            else
            {
                var workScheduleSettings = Mapper.Map<WorkScheduleSetting>(workScheduleDto);
                workScheduleSetting.WorkingHours = workScheduleSettings.WorkingHours;
                List<WorkingDay> daysToDelete = workScheduleSetting.WorkingDays.ToList();
                foreach (var workingDay in daysToDelete)
                {
                    _unitOfWork.WorkingDays.Delete(workingDay);
                }
                workScheduleSetting.WorkingDays = workScheduleSettings.WorkingDays;
            }
        }


        private void UpdateCalendarSettings(ICollection<CalendarSetting> calendarSettings,
            ICollection<CalendarSettingDTO> requestCalendarSettingDto)
        {
            if (requestCalendarSettingDto == null)
                return;

            List<CalendarSetting> settingsToDelete = new List<CalendarSetting>();
            foreach (var settings in calendarSettings)
            {
                var reqSetting = requestCalendarSettingDto.FirstOrDefault(x => x.Id == settings.Id);
                if (reqSetting != null)
                {
                    settings.BuiltIn = reqSetting.BuiltIn;
                    settings.Day = reqSetting.Day;
                    settings.Month = reqSetting.Month;
                    settings.Name = reqSetting.Name;
                    _unitOfWork.CalendarSettings.Update(settings);
                }
                else
                {
                    settingsToDelete.Add(settings);
                }
            }

            foreach (var setting in settingsToDelete)
            {
                _unitOfWork.CalendarSettings.Delete(setting);
            }

            foreach (var requestSetting in requestCalendarSettingDto)
            {
                if (requestSetting.Id == 0)
                {
                    var mappedCalendarSettings = Mapper.Map<CalendarSetting>(requestSetting);
                    calendarSettings.Add(mappedCalendarSettings);
                }
            }
        }

        private void UpdateAbsenceTypeAllocations(ICollection<AbsenceTypeAllocation> absenceTypeAllocations,
            ICollection<AbsenceTypeAllocationDTO> reqAbsenceTypeAllocations)
        {
            List<AbsenceTypeAllocation> absenceAllocationsToDelete = new List<AbsenceTypeAllocation>();
            foreach (var absenceAllocation in absenceTypeAllocations)
            {
                var absenceType = _unitOfWork.AbsenceTypes.GetById(absenceAllocation.AbsenceType.Id);
                var reqAbsence = reqAbsenceTypeAllocations.FirstOrDefault(x => x.Id == absenceAllocation.Id);
                if (reqAbsence != null)
                {
                    absenceAllocation.Year = reqAbsence.Year;
                    absenceAllocation.YearlyAllocations = reqAbsence.YearlyAllocations;
                    absenceAllocation.AbsenceTypeId = absenceType.Id;
                    absenceAllocation.AbsenceType = absenceType;
                    _unitOfWork.AbsenceTypeAllocations.Update(absenceAllocation);
                }
                else if (reqAbsenceTypeAllocations.Any() && reqAbsenceTypeAllocations.FirstOrDefault().Year == absenceAllocation.Year)
                {
                    absenceAllocationsToDelete.Add(absenceAllocation);
                }
            }

            foreach (var absenceAllocation in absenceAllocationsToDelete)
            {
                _unitOfWork.AbsenceTypeAllocations.Delete(absenceAllocation);
            }

            foreach (var absenceAllocation in reqAbsenceTypeAllocations)
            {
                if (absenceAllocation.Id == 0)
                {
                    var absenceType = _unitOfWork.AbsenceTypes.GetById(absenceAllocation.AbsenceType.Id);
                    var mappedAbsenceTypeAllocation = Mapper.Map<AbsenceTypeAllocation>(absenceAllocation);
                    mappedAbsenceTypeAllocation.AbsenceType = absenceType;
                    mappedAbsenceTypeAllocation.AbsenceTypeId = absenceType.Id;
                    absenceTypeAllocations.Add(mappedAbsenceTypeAllocation);
                }
            }
        }

        private void UpdateForcedAbsences(DepartmentSetting departmentSetting,
            UpdateDepartmentSettingsRequest request, int departmentId, bool isNeedRemoveSettings)
        {
            // If no request settings and no need to remove existed one - just pass this method.
            if (request.ForcedAbsences == null && !isNeedRemoveSettings)
                return;

            if (isNeedRemoveSettings)
            {
                departmentSetting.ForcedAbsences = null;
                return;
            }

            _log.Info("Updating forced absences");
            var forcedAbsencesToDelete = new List<ForcedAbsence>();
            var absences = new List<AbsenceDTO>();
            foreach (var forcedAbsence in departmentSetting.ForcedAbsences)
            {
                var reqAbsence = request.ForcedAbsences.FirstOrDefault(x => x.Id == forcedAbsence.Id);
                if (reqAbsence != null)
                {
                    forcedAbsence.Name = reqAbsence.Name;
                    forcedAbsence.AbsenceType = Mapper.Map<AbsenceType>(reqAbsence.AbsenceType);
                    forcedAbsence.From = reqAbsence.From;
                    forcedAbsence.To = reqAbsence.To;
                    _unitOfWork.ForcedAbsences.Update(forcedAbsence);
                }
                else
                {
                    forcedAbsencesToDelete.Add(forcedAbsence);
                }
            }

            foreach (var forcedAbsence in forcedAbsencesToDelete)
            {
                _unitOfWork.ForcedAbsences.Delete(forcedAbsence);
            }

            var departmentById = _customerService.GetDepartmentById(new GetDepartmentByIdServiceRequest()
            {
                DepartmentId = departmentId
            });

            var departmentUsers = new List<string>();
            GetAllUnoverridenDepartmentsUsers(departmentById.Department, departmentUsers, true);
            var parentSettings = GetParentSettings(request, departmentById);
            foreach (var forcedAbsence in request.ForcedAbsences)
            {
                if (forcedAbsence.Id == 0)
                {
                    var mappedForcedAbsence = Mapper.Map<ForcedAbsence>(forcedAbsence);

                    if (parentSettings != null && forcedAbsence.AbsenceType.Id == 0)
                    {
                        var absenceType =
                            parentSettings.DepartmentSettings.AbsenceTypes.FirstOrDefault(
                                r => r.Name == forcedAbsence.AbsenceType.Name);

                        mappedForcedAbsence.AbsenceType = Mapper.Map<AbsenceType>(absenceType);
                        mappedForcedAbsence.AbsenceTypeId = mappedForcedAbsence.AbsenceType.Id;
                        departmentSetting.ForcedAbsences.Add(mappedForcedAbsence);
                        foreach (var user in departmentUsers)
                        {
                            absences.Add(new AbsenceDTO()
                            {
                                UserId = user,
                                State = AbsenceState.Approved,
                                From = forcedAbsence.From,
                                To = forcedAbsence.To,
                                Comment = forcedAbsence.Name,
                                AbsenceTypeId = absenceType.Id,
                                AbsenceLenghtDay = 1,
                                Reason = "Forced absence"
                            });
                        }
                    }
                    else
                    {
                        mappedForcedAbsence.AbsenceType = Mapper.Map<AbsenceType>(forcedAbsence.AbsenceType);

                        departmentSetting.ForcedAbsences.Add(mappedForcedAbsence);
                        foreach (var user in departmentUsers)
                        {
                            absences.Add(new AbsenceDTO()
                            {
                                UserId = user,
                                State = AbsenceState.Approved,
                                From = forcedAbsence.From,
                                To = forcedAbsence.To,
                                Comment = forcedAbsence.Name,
                                AbsenceTypeId = forcedAbsence.AbsenceType.Id,
                                AbsenceLenghtDay = 1,
                                Reason = "Forced absence"
                            });
                        }
                    }
                }
            }
            _absenceService.DeleteAbsencesInTransaction(new DeleteAbsencesInTransactionRequest()
            {
                Absences = Mapper.Map<ICollection<ForcedAbsenceDTO>>(forcedAbsencesToDelete),
                Users = departmentUsers
            });
            _absenceService.CreateAbsencesInTransaction(new CreateAbsencesInTransactionRequest()
            {
                Absences = absences
            });
        }

        private void GetAllUnoverridenDepartmentsUsers(DepartmentDTO department, List<string> users, bool isRoot)
        {
            var depSettings = _unitOfWork.DepartmentSettings.GetByDepartmentId(department.Id);
            if ((depSettings?.ForcedAbsences != null && depSettings.ForcedAbsences.Count < 1) || isRoot)
            {
                users.AddRange(department.Users);
            }
            foreach (var childDepartment in department.Departments)
            {
                GetAllUnoverridenDepartmentsUsers(childDepartment, users, false);
            }
        }

        private bool IsRootDepartmentOfCompany(int customerId, int departmentId)
        {
            var getCustomerByIdResponse = _customerService.GetCustomerById(new GetCustomerByIdServiceRequest() { CustomerId = customerId });
            ResponseStatus<CustomerService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(getCustomerByIdResponse, _log);
            var customerRootDepartment = getCustomerByIdResponse.Customer.Department;
            bool isRootDepartmentOfTheCompany = false;
            if (customerRootDepartment == null)
            {
                throw new Exception("ERROR_NO_ROOT_DEPARTMENT");
            }
            if (customerRootDepartment.Id == departmentId)
                isRootDepartmentOfTheCompany = true;

            return isRootDepartmentOfTheCompany;
        }

        private GetDepartmentSettingsResponse GetParentSettings(UpdateDepartmentSettingsRequest request, GetDepartmentByIdServiceResponse getDepartmentByIdResponse)
        {
            bool isRootDep = IsRootDepartmentOfCompany(getDepartmentByIdResponse.Department.CustomerId,
              request.DepartmentId);

            if (!isRootDep)
            {
                // Get parent department
                var parentDepartment = _customerService.GetParentDepartment(new GetParentDepartmentRequest()
                {
                    DepartmentId = getDepartmentByIdResponse.Department.Id
                });

                ResponseStatus<CustomerService.Contracts.Models.Service.ServiceResponse>.CheckSuccess(parentDepartment, _log);
                // Parent dep settings
                var parentDepartmentSettings = GetDepartmentSettings(new GetDepartmentSettingsRequest() { DepartmentId = parentDepartment.Department.Id });
                ResponseStatus<Contracts.Models.Service.ServiceResponse>.CheckSuccess(parentDepartmentSettings, _log);
                return parentDepartmentSettings;
            }
            return null;
        }
        #endregion
    }
}