using Serilog;
using TimeZoneConverter;
using Newtonsoft.Json;
using LCU.Library.Internal.DataCleanUpModel.Models;
using LCU.Api.Internal.DataCleanUp.Models;
using LCU.Library.Internal.CoreApiWrapperModel.CoreModels.Persons;
using LCU.Api.Internal.DataCleanUp.Configuration;

namespace LCU.Api.Internal.DataCleanUp.Services;

public class UpdatePersonForAtmHoldsService : IUpdatePersonForAtmHoldsService 
{
    private readonly ICoreApiWrapperService _coreApiWrapperService;
    private readonly DataCleanupDefaults _dataCleanupDefaults;
    private readonly DataCleanUpConfiguration _dataCleanUpConfiguration;

    public UpdatePersonForAtmHoldsService(ICoreApiWrapperService coreApiWrapperService, DataCleanupDefaults dataCleanupDefaults, DataCleanUpConfiguration dataCleanUpConfiguration)
    {
        _coreApiWrapperService = coreApiWrapperService;
        _dataCleanupDefaults = dataCleanupDefaults;
        _dataCleanUpConfiguration = dataCleanUpConfiguration;
    }

    public async Task<DataCleanUpResult> CleanUp(DataCleanUpRequest dataCleanUpRequest)
    {
        Log.Information($"Starting Data CleanUp {dataCleanUpRequest.CleanUpType} at {DateTime.Now}");

        var cleanUpResult = new DataCleanUpResult(dataCleanUpRequest, true, new List<string>());
       
        try
        {
            var result = JsonConvert.DeserializeObject<UpdatePersonForCheckHoldRequest>(dataCleanUpRequest.DataCleanUpPayload);
            var assumedTimezone = TZConvert.GetTimeZoneInfo(_dataCleanUpConfiguration.TimeZone);

            DateTime? resetStartDate = result.ResetStartDate.HasValue ? TimeZoneInfo.ConvertTime((DateTime)result.ResetStartDate, assumedTimezone) : null;
            DateTime? resetEndDate = result.ResetEndDate.HasValue ? TimeZoneInfo.ConvertTime((DateTime)result.ResetEndDate, assumedTimezone) : null;

            var personsForUserFieldList = await _coreApiWrapperService.GetAtmCheckHoldsForPersonNumbers(resetStartDate, resetEndDate, result.FetchSize);
            ArgumentNullException.ThrowIfNull(personsForUserFieldList);
            Log.Information($"Data CleanUp # of Persons {personsForUserFieldList.Count()} at {DateTime.Now}");
            foreach (var person in personsForUserFieldList)
            {
                cleanUpResult = await HandlePersonForCheckHolds(cleanUpResult, person);
            }
        }
        catch (Exception exception)
        {
            Log.Error(exception, "Error while updating Person for Atm Check Holds.");
            cleanUpResult.Successful = false;
            cleanUpResult.ResponseStack.Add($"Error while updating Person for Atm Check Holds.  " +
                                            $"Exception:{exception}");
        }

        Log.Information($"Ending Data CleanUp {dataCleanUpRequest.CleanUpType} at {DateTime.Now}");
        return cleanUpResult;
    }
   
    public async Task<DataCleanUpResult> HandlePersonForCheckHolds(DataCleanUpResult cleanUpResult, PersonCheckHoldsUserField person)
    {
        try
        {
            var personNumber = (int)person.PersonNumber;
            var response = new PersonUserField();
            var personValue = DeterminePersonUserFieldValue(person);

            if (person.UserFieldExists)
            {
                response = await _coreApiWrapperService.UpdateAtmCheckHoldsForPersonNumbers(personNumber, personValue);
            } 
            else
            {
                response = await _coreApiWrapperService.AddAtmCheckHoldsForPersonNumbers(personNumber, personValue);
            }

            if (response == null)
            {
                cleanUpResult.Successful = false;
                cleanUpResult.ResponseStack.Add($"Error while updating Person { person.PersonNumber } for Atm Check Holds.");
            }
        }
        catch(Exception exception)
        {
            cleanUpResult.Successful = false;
            cleanUpResult.ResponseStack.Add($"Error while updating Person { person.PersonNumber } for Atm Check Holds. " +
                                            $"Exception:{exception}");
        }

        return cleanUpResult;
    }

    public string DeterminePersonUserFieldValue(PersonCheckHoldsUserField person)
    {
        string personUserFieldValue = "";
        var assumedTimezone = TZConvert.GetTimeZoneInfo(_dataCleanUpConfiguration.TimeZone);
        DateTime checkHoldEndDateToConvert = Convert.ToDateTime(DateTime.Now.AddDays(-_dataCleanupDefaults.MemberCheckHoldsDays));
        var checkHoldEndDate = TimeZoneInfo.ConvertTime(checkHoldEndDateToConvert, assumedTimezone).Date;

        person.OldestActiveEffectiveDate = person.OldestActiveEffectiveDate.HasValue ? person.OldestActiveEffectiveDate.Value.Date : null;
        person.RecentClosedEffectiveDate = person.RecentClosedEffectiveDate.HasValue ? person.RecentClosedEffectiveDate.Value.Date : null;

        var checkHoldsUserFieldValue = new CheckHoldsUserFieldValue(person, checkHoldEndDate);

        foreach (var propertyInfo in checkHoldsUserFieldValue.GetType().GetProperties())
        {
            if (propertyInfo.PropertyType == typeof(bool))
            {
                bool value = (bool)propertyInfo.GetValue(checkHoldsUserFieldValue, null);

                if (value == true && propertyInfo.Name.Contains("NoValue"))
                {
                    personUserFieldValue = "N";
                    break;

                }
                else if (value == true && propertyInfo.Name.Contains("YesValue"))
                {
                    personUserFieldValue = "Y";
                    break;
                };
            }
        }

        return personUserFieldValue;
    }
}