using LCU.Library.Internal.IncentiveApiModels.Entities;
using LCU.Library.Internal.IncentiveApiModels.Enums;
using LCU.API.Internal.Operations.IncentiveApiLib.Services;

namespace LCU.API.Internal.Operations.IncentiveApi.Models.ExternalActivities;

public class NewLoanSaleActivity : IExternalActivity
{
    public long ActivityNbr { get; set; }
    public DateTime ActivityDateTime { get; set; }
    public long SubjectAccountNbr { get; set; }
    public long OriginatingPersonNbr { get; set; }
    public string ActivityTypeCode { get; set; }
    public string MajorAccountType { get; set; }
    public string MinorAccountType { get; set; }
    public string AssociateFirst { get; set; }
    public string AssociateMiddleInit { get; set; }
    public string AssociateLast { get; set; }
    public string TaxPersonNbr { get; set; }
    public string TaxOrgNbr { get; set; }
    public string TaxOrgName { get; set; }
    public string TaxPersonName { get; set; }
    public DateTime AccountContractDate { get; set; }
    public string CurrentAccountStatus { get; set; }
    public long BranchOrgNbr { get; set; }
    public string BranchOrgName { get; set; }
    public string EmployeeEmail { get; set; }
    public string LoanSourceCode { get; set; }
    public decimal? LoanAmount { get; set; }
    public DateTime? DebtProtectionEffectiveDate { get; set; }
    public DateTime? DebtProtectionInactiveDate { get; set; }
    public string DebtProtectionCategory { get; set; }
    public DateTime? YoungestBirthdateOnLoan { get; set; }
    public int HasOrgRoles { get; set; }
    public string TaxPersonPhoneNumbers { get; set; }
    public string TaxPersonEmailAddresses { get; set; }

    public bool IsGapInsuranceEligible()
    {
        var isEligible = false;
        if (!MinorAccountType.Equals("BE21", StringComparison.InvariantCultureIgnoreCase) && LoanAmount.HasValue && LoanAmount.Value <= 100000 && GetProductType() == Product.Vehicle)
        {
            isEligible = true;
        }
        Log.Information($"New Loan Sale ActivityNbr {ActivityNbr} - {GetProductType()} - {MinorAccountType} - {LoanAmount} GapEligible set: {isEligible} {DateTime.UtcNow} ");
        return isEligible;
    }

    public DateTime? GapInsuranceEffectiveDate { get; set; }
    public DateTime? GapInsuranceInactiveDate { get; set; }


    static readonly List<string> DebtProtectionEligibleLoanTypes = new List<string>()
        { "DV01", "DV02", "DV03", "DV04", "DV05", "DV06", "DV07", "DV08", "SC01", "SC02", "SG01" };

    static readonly List<string> FirstMortgageEligibleLoanTypes = new List<string>()
        { "FNMA", "FRML", "FRMH","MPFR","MJ30","HM01","HM02","MF10","HM03","HM04","DEF3","ML01","ML03",
          "MJ03","MJ05","MJ07","MF15","MF20","MF30","MC93","MA55","MS30","MS10","MS15","MS20","MS40","MC09",
          "ML02","MA01","MP05","MA05","MC01","MI05","MC03","MJ55","MC91","MF40","MS05","MS07","MI03","MA03",
          "MA07","MA27","ML23","ML21","MP25","MC21","MA21","MJ27","HM05","MA23","MA25","MI25","MJ23","MJ25" };

    static readonly TimeZoneInfo AssumedSourceTimezone = TimeZoneConverter.TZConvert.GetTimeZoneInfo("America/Chicago");

    public Product GetProductType()
    {
        if (string.IsNullOrWhiteSpace(MinorAccountType))
        {
            Log.Error($"Null Loan Account Type: {MinorAccountType} for Activity with ActivityNbr: {ActivityNbr}");
            throw new Exception("Could Not Determine Loan Account Type");
        }

        if (MinorAccountType.Equals("HE01", StringComparison.InvariantCultureIgnoreCase) ||
            MinorAccountType.Equals("FE01", StringComparison.InvariantCultureIgnoreCase) ||
            MinorAccountType.Equals("MF01", StringComparison.InvariantCultureIgnoreCase) ||
            MinorAccountType.Equals("FE02", StringComparison.InvariantCultureIgnoreCase) ||
            MinorAccountType.Equals("FLML", StringComparison.InvariantCultureIgnoreCase))
        {
            return Product.Mortgage;
        }

        if (MinorAccountType.Equals("SC01", StringComparison.InvariantCultureIgnoreCase) ||
            MinorAccountType.Equals("SC02", StringComparison.InvariantCultureIgnoreCase) ||
            MinorAccountType.Equals("SG01", StringComparison.InvariantCultureIgnoreCase))
        {
            return Product.DebtProtectionEligibleLoan;
        }

        if (IsFirstMortgageLoan(MinorAccountType))
        {
            return Product.FirstMortgageReferral;
        }

        return Product.Vehicle;
    }

    public bool IsFirstMortgageLoan(string minorAccountType)
    {
        if (!string.IsNullOrWhiteSpace(minorAccountType) && FirstMortgageEligibleLoanTypes.Contains(minorAccountType.ToUpperInvariant()))
        {
            return true;
        }

        return false;
    }

    public ActivityType GetActivityType()
    {
        return ActivityType.Sale;
    }

    public Activity MapToActivity()
    {
        const int addHours = 12;

        return new Activity()
        {
            Product = GetProductType(),
            Type = GetActivityType(),
            SourceSystem = GetSystemType(),
            SourceId = ActivityNbr.ToString(),
            SourceCreated = AccountContractDate,
            Detail = new ActivityDetail()
            {
                MemberName = TaxOrgName ?? TaxPersonName,
                DnaPersonNbr = OriginatingPersonNbr.ToString(),
                BranchOrgName = BranchOrgName,
                BranchOrgNbr = BranchOrgNbr.ToString(),
                SubjectPersonNbr = TaxPersonNbr,
                SubjectOrgNbr = TaxOrgNbr,
                AccountNumber = SubjectAccountNbr.ToString(),
                AccountStatus = CurrentAccountStatus,
                AccountBalance = (double?)LoanAmount,
                DebtProtectionAddDate = DebtProtectionEffectiveDate?.Date.AddHours(addHours),
                DebtProtectionRemoveDate = DebtProtectionInactiveDate?.Date.AddHours(addHours),
                IsDebtProtectionEligible = IsEligibleForDebtProtection(),
                IsGapInsuranceEligible = IsGapInsuranceEligible(),
                GapInsuranceAddDate = GapInsuranceEffectiveDate?.Date.AddHours(addHours),
                GapInsuranceRemoveDate = GapInsuranceInactiveDate?.Date.AddHours(addHours)
            },
            MetaData = DataParsingService.MapActivityMetaData(new List<string> { TaxPersonPhoneNumbers, TaxPersonEmailAddresses }),
            DepartmentId = -1,
            EmployeeId = null,
            EmployeeEmail = EmployeeEmail,
            Accepted = AccountContractDate.Date.AddHours(addHours),
            State = ActivityState.Created
        };
    }

    public string GetSourceId()
    {
        return ActivityNbr.ToString();
    }

    public bool IsEligibleForDebtProtection()
    {
        var age = AgeOfYoungestBorrower();
        if (age == null || !DebtProtectionEligibleLoanTypes.Contains(MinorAccountType))
        {
            return false;
        }

        return age < 69 && HasOrgRoles == 0 && TaxOrgNbr == null;
    }

    public int? AgeOfYoungestBorrower()
    {
        if (YoungestBirthdateOnLoan == null)
        {
            return null;
        }

        var now = TimeZoneInfo.ConvertTime(DateTime.UtcNow, AssumedSourceTimezone);
        var age = now.Year - YoungestBirthdateOnLoan.Value.Year;
        if (now.DayOfYear > YoungestBirthdateOnLoan.Value.DayOfYear)
        {
            age--;
        }

        return age;
    }

    public SystemType GetSystemType()
    {
        return SystemType.Dna;
    }
}