Codeunit 392 Reminder-Make

// ------------------------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// ------------------------------------------------------------------------------------------------
namespace Microsoft.Sales.Reminder;

using Microsoft.Finance.Currency;
using Microsoft.Sales.Customer;
using Microsoft.Sales.FinanceCharge;
using Microsoft.Sales.Receivables;
using System.Globalization;
using System.Telemetry;
using System.Utilities;

/// <summary>
/// Creates reminder documents for customers by analyzing overdue ledger entries and applying reminder terms.
/// </summary>
codeunit 392 "Reminder-Make"
{

    trigger OnRun()
    begin
    end;

    var
        TempCurrencyGlobal: Record Currency temporary;
        GlobalCustomer: Record Customer;
        GlobalCustLedgEntry: Record "Cust. Ledger Entry";
        GlobalCustLedgEntry2: Record "Cust. Ledger Entry";
        GlobalReminderTerms: Record "Reminder Terms";
        GlobalReminderHeaderReq: Record "Reminder Header";
        GlobalReminderHeader: Record "Reminder Header";
        GlobalReminderEntry: Record "Reminder/Fin. Charge Entry";
        TempCustLedgerEntryOnHold: Record "Cust. Ledger Entry" temporary;
        GlobalCustLedgEntryLineFeeFilters: Record "Cust. Ledger Entry";
        FeatureTelemetry: Codeunit "Feature Telemetry";
        AmountsNotDueLineInserted: Boolean;
        OverdueEntriesOnly: Boolean;
        HeaderExists: Boolean;
        IncludeEntriesOnHold: Boolean;
        OpenEntriesNotDueLbl: Label 'Open Entries Not Due';
        OpenEntriesOnHoldLbl: Label 'Open Entries On Hold';
        CustLedgEntryLastIssuedReminderLevelFilter: Text;

    /// <summary>
    /// Executes the reminder creation process for the configured customer and ledger entry filters.
    /// </summary>
    /// <returns>True if at least one reminder was created successfully; otherwise, false.</returns>
    procedure "Code"() RetVal: Boolean
    var
        ReminderLine: Record "Reminder Line";
        IsHandled: Boolean;
    begin
        CustLedgEntryLastIssuedReminderLevelFilter := GlobalCustLedgEntry.GetFilter("Last Issued Reminder Level");
        if GlobalReminderHeader."No." <> '' then begin
            HeaderExists := true;
            GlobalReminderHeader.TestField("Customer No.");
            GlobalCustomer.Get(GlobalReminderHeader."Customer No.");
            IsHandled := false;
            OnCodeOnAfterGlobalReminderGetGlobalCustomer(GlobalReminderHeader, GlobalCustomer, IsHandled, RetVal);
            if IsHandled then
                exit(RetVal);
            GlobalReminderHeader.TestField("Document Date");
            GlobalReminderHeader.TestField("Reminder Terms Code");
            GlobalReminderHeaderReq := GlobalReminderHeader;
            ReminderLine.SetRange("Reminder No.", GlobalReminderHeader."No.");
            ReminderLine.DeleteAll();
        end;

        IsHandled := false;
        OnCodeOnBeforeGetReminderTerms(GlobalCustomer, GlobalCustLedgEntry, CustLedgEntryLastIssuedReminderLevelFilter, GlobalReminderHeader, IsHandled, RetVal);
        if IsHandled then
            exit(RetVal);
        GetReminderTerms();
        if HeaderExists then
            RetVal := MakeReminder(GlobalReminderHeader."Currency Code")
        else begin
            TempCurrencyGlobal.DeleteAll();
            GlobalCustLedgEntry2.CopyFilters(GlobalCustLedgEntry);
            GlobalCustLedgEntry.SetCurrentKey("Customer No.", Open, Positive);
            GlobalCustLedgEntry.SetRange("Customer No.", GlobalCustomer."No.");
            GlobalCustLedgEntry.SetRange(Open, true);
            GlobalCustLedgEntry.SetRange(Positive, true);
            OnBeforeCustLedgerEntryFind(GlobalCustLedgEntry, GlobalReminderHeaderReq, GlobalCustomer);
            if GlobalCustLedgEntry.FindSet() then
                repeat
                    if (GlobalCustLedgEntry."On Hold" = '') or IncludeEntriesOnHold then begin
                        TempCurrencyGlobal.Code := GlobalCustLedgEntry."Currency Code";
                        if TempCurrencyGlobal.Insert() then;
                    end;
                until GlobalCustLedgEntry.Next() = 0;
            GlobalCustLedgEntry.CopyFilters(GlobalCustLedgEntry2);
            RetVal := true;
            OnCodeOnBeforeCurrencyLoop(GlobalCustLedgEntry, GlobalReminderHeaderReq, GlobalReminderTerms, OverdueEntriesOnly,
                IncludeEntriesOnHold, HeaderExists, CustLedgEntryLastIssuedReminderLevelFilter, TempCurrencyGlobal,
                GlobalCustomer, GlobalCustLedgEntryLineFeeFilters);
            if TempCurrencyGlobal.FindSet() then
                repeat
                    if not MakeReminder(TempCurrencyGlobal.Code) then
                        RetVal := false;
                until TempCurrencyGlobal.Next() = 0;
        end;

        OnAfterCode(RetVal);
    end;

    local procedure GetReminderTerms()
    var
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeGetReminderTerms(GlobalReminderHeader, GlobalReminderTerms, IsHandled);
        if IsHandled then
            exit;

        if GlobalCustomer."Reminder Terms Code" = '' then
            GlobalReminderHeader.TestField("Reminder Terms Code");

        if GlobalReminderHeader."Reminder Terms Code" = '' then begin
            GlobalCustomer.TestField("Reminder Terms Code");
            GlobalReminderTerms.Get(GlobalCustomer."Reminder Terms Code");
        end else
            GlobalReminderTerms.Get(GlobalReminderHeader."Reminder Terms Code")
    end;

    /// <summary>
    /// Initializes the reminder creation parameters for batch processing of customer reminders.
    /// </summary>
    /// <param name="Cust2">Specifies the customer to create reminders for.</param>
    /// <param name="CustLedgEntry2">Specifies the customer ledger entries filter to include.</param>
    /// <param name="ReminderHeaderReq2">Specifies the reminder header settings to use as a template.</param>
    /// <param name="OverdueEntriesOnly2">Specifies whether to include only overdue entries.</param>
    /// <param name="IncludeEntriesOnHold2">Specifies whether to include entries that are on hold.</param>
    /// <param name="CustLedgEntryLinefeeOn">Specifies the customer ledger entries filter for line fee calculation.</param>
    procedure Set(Cust2: Record Customer; var CustLedgEntry2: Record "Cust. Ledger Entry"; ReminderHeaderReq2: Record "Reminder Header"; OverdueEntriesOnly2: Boolean; IncludeEntriesOnHold2: Boolean; var CustLedgEntryLinefeeOn: Record "Cust. Ledger Entry")
    begin
        GlobalCustomer := Cust2;
        GlobalCustLedgEntry.Copy(CustLedgEntry2);
        GlobalReminderHeaderReq := ReminderHeaderReq2;
        OverdueEntriesOnly := OverdueEntriesOnly2;
        IncludeEntriesOnHold := IncludeEntriesOnHold2;
        GlobalCustLedgEntryLineFeeFilters.CopyFilters(CustLedgEntryLinefeeOn);

        OnAfterSet(GlobalCustomer, GlobalCustLedgEntry, GlobalReminderHeaderReq, OverdueEntriesOnly, IncludeEntriesOnHold, CustLedgEntryLinefeeOn);
    end;

    /// <summary>
    /// Suggests reminder lines for an existing reminder header based on overdue customer ledger entries.
    /// </summary>
    /// <param name="ReminderHeader2">Specifies the reminder header to add suggested lines to.</param>
    /// <param name="CustLedgEntry2">Specifies the customer ledger entries filter to include.</param>
    /// <param name="OverdueEntriesOnly2">Specifies whether to include only overdue entries.</param>
    /// <param name="IncludeEntriesOnHold2">Specifies whether to include entries that are on hold.</param>
    /// <param name="CustLedgEntryLinefeeOn">Specifies the customer ledger entries filter for line fee calculation.</param>
    procedure SuggestLines(ReminderHeader2: Record "Reminder Header"; var CustLedgEntry2: Record "Cust. Ledger Entry"; OverdueEntriesOnly2: Boolean; IncludeEntriesOnHold2: Boolean; var CustLedgEntryLinefeeOn: Record "Cust. Ledger Entry")
    begin
        GlobalReminderHeader := ReminderHeader2;
        GlobalCustLedgEntry.Copy(CustLedgEntry2);
        OverdueEntriesOnly := OverdueEntriesOnly2;
        IncludeEntriesOnHold := IncludeEntriesOnHold2;
        GlobalCustLedgEntryLineFeeFilters.CopyFilters(CustLedgEntryLinefeeOn);
        OnAfterSuggestLines(GlobalReminderHeader, CustLedgEntry2, OverdueEntriesOnly2, IncludeEntriesOnHold2, CustLedgEntryLinefeeOn);
    end;

    local procedure MakeReminder(CurrencyCode: Code[10]) RetVal: Boolean
    var
        ReminderLevel: Record "Reminder Level";
        ReminderLine: Record "Reminder Line";
        MakeDoc: Boolean;
        StartLineInserted: Boolean;
        NextLineNo: Integer;
        LineLevel: Integer;
        MaxLineLevel: Integer;
        MaxReminderLevel: Integer;
        CustAmount: Decimal;
        ReminderDueDate: Date;
        OpenEntriesNotDueTranslated: Text[100];
        OpenEntriesOnHoldTranslated: Text[100];
        IsHandled: Boolean;
        IsGracePeriodExpired: Boolean;
        ShouldMakeDoc: Boolean;
    begin
        IsHandled := false;
        OnBeforeMakeReminder(GlobalReminderHeader, CurrencyCode, RetVal, IsHandled, GlobalReminderHeaderReq, OverdueEntriesOnly, IncludeEntriesOnHold, HeaderExists, GlobalCustomer);
        if IsHandled then
            exit;

        FilterCustLedgEntryReminderLevel(GlobalCustLedgEntry, ReminderLevel, CurrencyCode);
        if not ReminderLevel.FindLast() then
            exit(false);
        TempCustLedgerEntryOnHold.DeleteAll();

        if not FindAndMarkReminderCandidates(GlobalCustLedgEntry, ReminderLevel, CustAmount, MakeDoc, MaxReminderLevel, MaxLineLevel) then
            exit(false);

        ReminderLevel.SetRange("Reminder Terms Code", GlobalReminderTerms.Code);
        ReminderLevel.SetRange("No.", 1, MaxLineLevel);
        if not ReminderLevel.FindLast() then
            ReminderLevel.Init();
        ShouldMakeDoc := MakeDoc and (CustAmount > 0) and (CustAmountLCY(CurrencyCode, CustAmount) >= GlobalReminderTerms."Minimum Amount (LCY)");
        OnMakeReminderOnAfterCalcShouldMakeDoc(GlobalReminderHeaderReq, GlobalReminderHeader, GlobalCustomer, ShouldMakeDoc, MakeDoc, GlobalCustLedgEntry);
        if ShouldMakeDoc then begin
            if CheckCustomerIsBlocked(GlobalCustomer) then
                exit(false);
            ReminderLine.LockTable();
            GlobalReminderHeader.LockTable();
            if not HeaderExists then begin
                GlobalReminderHeader.SetCurrentKey("Customer No.", "Currency Code");
                GlobalReminderHeader.SetRange("Customer No.", GlobalCustomer."No.");
                GlobalReminderHeader.SetRange("Currency Code", CurrencyCode);
                OnBeforeReminderHeaderFind(GlobalReminderHeader, GlobalReminderHeaderReq, GlobalReminderTerms, GlobalCustomer, GlobalCustLedgEntry);
                if GlobalReminderHeader.FindFirst() then
                    exit(false);
                GlobalReminderHeader.Init();
                GlobalReminderHeader."No." := '';
                GlobalReminderHeader."Posting Date" := GlobalReminderHeaderReq."Posting Date";
                OnBeforeReminderHeaderInsert(GlobalReminderHeader, GlobalReminderHeaderReq, GlobalReminderTerms, GlobalCustomer);
                GlobalReminderHeader.Insert(true);
                GlobalReminderHeader.Validate("Customer No.", GlobalCustomer."No.");
                GlobalReminderHeader.Validate("Currency Code", CurrencyCode);
                GlobalReminderHeader."Document Date" := GlobalReminderHeaderReq."Document Date";
                GlobalReminderHeader."Use Header Level" := GlobalReminderHeaderReq."Use Header Level";
            end;
            GlobalReminderHeader."Reminder Level" := ReminderLevel."No.";
            OnBeforeReminderHeaderModify(GlobalReminderHeader, GlobalReminderHeaderReq, HeaderExists, GlobalReminderTerms, GlobalCustomer, ReminderLevel, GlobalCustLedgEntry);
            GlobalReminderHeader.Modify();
            NextLineNo := 0;
            ReminderLevel.MarkedOnly(true);
            GlobalCustLedgEntry.MarkedOnly(true);
            ReminderLevel.FindLast();

            repeat
                StartLineInserted := false;
                FilterCustLedgEntries(ReminderLevel);
                OnMakeReminderOnAfterFilterCustLedgEntries(ReminderLine);
                AmountsNotDueLineInserted := false;
                if GlobalCustLedgEntry.FindSet() then
                    repeat
                        SetReminderLine(LineLevel, ReminderDueDate);
                        IsGracePeriodExpired := IsGracePeriodExpiredForOverdueEntry(ReminderDueDate, GlobalReminderHeaderReq."Document Date", ReminderLevel."Grace Period");
                        OnMakeReminderOnAfterCalcIsGracePeriodExpired(ReminderDueDate, GlobalReminderHeaderReq, IsGracePeriodExpired);
                        if IsGracePeriodExpired then begin
                            if (NextLineNo > 0) and not StartLineInserted then
                                InsertReminderLine(
                                  GlobalReminderHeader."No.", ReminderLine."Line Type"::"Reminder Line", '', NextLineNo);
                            InitReminderLine(
                              ReminderLine, GlobalReminderHeader."No.", ReminderLine."Line Type"::"Reminder Line", '', NextLineNo);
                            ReminderLine.Type := ReminderLine.Type::"Customer Ledger Entry";
                            ReminderLine.Validate("Entry No.", GlobalCustLedgEntry."Entry No.");
                            SetReminderLevel(GlobalReminderHeader, ReminderLine, ReminderLevel."No.");
                            OnBeforeReminderLineInsert(ReminderLine, GlobalReminderHeader, ReminderLevel, GlobalCustLedgEntry, GlobalReminderHeaderReq);
                            ReminderLine.Insert();
                            StartLineInserted := true;

                            AddLineFeeForCustLedgEntry(GlobalCustLedgEntry, ReminderLevel, NextLineNo);
                        end;
                    until GlobalCustLedgEntry.Next() = 0;

                OnMakeReminderOnAfterReminderLevelLoop(ReminderLevel, NextLineNo, StartLineInserted, GlobalReminderHeaderReq, GlobalReminderHeader, GlobalCustomer);
            until ReminderLevel.Next(-1) = 0;

            OnAfterReminderLinesInsertLoop(GlobalReminderHeader, CurrencyCode, NextLineNo, MaxReminderLevel, OverdueEntriesOnly);

            GlobalReminderHeader."Reminder Level" := MaxReminderLevel;
            GlobalReminderHeader.Validate("Reminder Level");
            OnMakeReminderOnBeforeReminderHeaderInsertLines(GlobalReminderHeader);
            GlobalReminderHeader.InsertLines();
            ReminderLine.SetRange("Reminder No.", GlobalReminderHeader."No.");
            ReminderLine.FindLast();
            NextLineNo := ReminderLine."Line No.";
            GetOpenEntriesNotDueOnHoldTranslated(GlobalCustomer."Language Code", OpenEntriesNotDueTranslated, OpenEntriesOnHoldTranslated);
            GlobalCustLedgEntry.SetRange("Last Issued Reminder Level");
            OnMakeReminderOnBeforeCustLedgEntryFindSet(GlobalCustLedgEntry, GlobalCustomer, GlobalReminderHeader, MaxReminderLevel, OverdueEntriesOnly);
            if GlobalCustLedgEntry.FindSet() then
                repeat
                    AddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilter(ReminderLine, ReminderLevel, LineLevel, ReminderDueDate, NextLineNo, OpenEntriesNotDueTranslated, StartLineInserted)
                until GlobalCustLedgEntry.Next() = 0;
            OnMakeReminderOnAfterAddRemiderLinesFromCustLedgEntriesWithNoReminderLevelFilter(GlobalCustLedgEntry, GlobalCustomer, GlobalReminderHeader, MaxReminderLevel, OverdueEntriesOnly);

            if IncludeEntriesOnHold then
                if TempCustLedgerEntryOnHold.FindSet() then begin
                    InsertReminderLine(
                      GlobalReminderHeader."No.", ReminderLine."Line Type"::"On Hold", '', NextLineNo);
                    InsertReminderLine(
                      GlobalReminderHeader."No.", ReminderLine."Line Type"::"On Hold", OpenEntriesOnHoldTranslated, NextLineNo);
                    repeat
                        InitReminderLine(
                          ReminderLine, GlobalReminderHeader."No.", ReminderLine."Line Type"::"On Hold", '', NextLineNo);
                        ReminderLine.Type := ReminderLine.Type::"Customer Ledger Entry";
                        ReminderLine.Validate("Entry No.", TempCustLedgerEntryOnHold."Entry No.");
                        ReminderLine."No. of Reminders" := 0;
                        OnMakeReminderOnBeforeOnHoldReminderLineInsert(ReminderLine, GlobalReminderHeader, ReminderLevel, GlobalCustLedgEntry, TempCustLedgerEntryOnHold);
                        ReminderLine.Insert();
                    until TempCustLedgerEntryOnHold.Next() = 0;
                end;
            OnMakeReminderOnBeforeReminderHeaderModify(GlobalReminderHeader, ReminderLine, NextLineNo, MaxReminderLevel);
            GlobalReminderHeader.Modify();
        end;

        RemoveLinesOfNegativeReminder(GlobalReminderHeader);

        ReminderLevel.Reset();
        GlobalCustLedgEntry.Reset();

        OnAfterMakeReminder(GlobalReminderHeader, ReminderLine);

        exit(true);
    end;

    local procedure AddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilter(var ReminderLine: Record "Reminder Line"; var ReminderLevel: Record "Reminder Level"; LineLevel: Integer; ReminderDueDate: Date; var NextLineNo: Integer; OpenEntriesNotDueTranslated: Text[100]; var StartLineInserted: Boolean)
    var
        IsHandled: Boolean;
        IsGracePeriodExpired: Boolean;
    begin
        IsHandled := false;
        OnBeforeAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilter(GlobalCustLedgEntry, GlobalReminderHeaderReq, GlobalReminderHeader, IsHandled, ReminderLine, NextLineNo, StartLineInserted);
        if IsHandled then
            exit;

        if (not OverdueEntriesOnly) or
           (GlobalCustLedgEntry."Document Type" in [GlobalCustLedgEntry."Document Type"::Payment, GlobalCustLedgEntry."Document Type"::Refund])
        then begin
            SetReminderLine(LineLevel, ReminderDueDate);
            IsGracePeriodExpired :=
                IsGracePeriodExpiredForOverdueEntry(ReminderDueDate, GlobalReminderHeaderReq."Document Date", ReminderLevel."Grace Period");
            if (not IsGracePeriodExpired) and (LineLevel = 1) then begin
                OnAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilterOnBeforeCheckAmountsNotDueLineInserted(
                    GlobalReminderHeader, ReminderLine, AmountsNotDueLineInserted);
                if not AmountsNotDueLineInserted then begin
                    InsertReminderLine(GlobalReminderHeader."No.", ReminderLine."Line Type"::"Not Due", '', NextLineNo);
                    InsertReminderLine(
                      GlobalReminderHeader."No.", ReminderLine."Line Type"::"Not Due", OpenEntriesNotDueTranslated, NextLineNo);
                    AmountsNotDueLineInserted := true;
                end;
                InitReminderLine(
                  ReminderLine, GlobalReminderHeader."No.", ReminderLine."Line Type"::"Not Due", '', NextLineNo);
                ReminderLine.Type := ReminderLine.Type::"Customer Ledger Entry";
                ReminderLine.Validate("Entry No.", GlobalCustLedgEntry."Entry No.");
                ReminderLine."No. of Reminders" := 0;
                OnAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilterOnBeforeReminderLineInsert(ReminderLine, GlobalReminderHeader, ReminderLevel, GlobalCustLedgEntry);
                ReminderLine.Insert();
                AmountsNotDueLineInserted := true;
                RemoveNotDueLinesInSectionReminderLine(ReminderLine);
            end;
        end;
    end;

    local procedure FindAndMarkReminderCandidates(var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; var CustAmount: Decimal; var MakeDoc: Boolean; var MaxReminderLevel: Integer; var MaxLineLevel: Integer) Result: Boolean
    var
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeFindAndMarkReminderCandidates(
            ReminderLevel, GlobalReminderHeaderReq, GlobalReminderTerms, GlobalReminderEntry,
            CustLedgEntry, TempCustLedgerEntryOnHold, CustLedgEntryLastIssuedReminderLevelFilter, CustAmount,
            MakeDoc, MaxReminderLevel, MaxLineLevel, OverdueEntriesOnly, IncludeEntriesOnHold, IsHandled, Result);
        if IsHandled then
            exit(Result);

        repeat
            FilterCustLedgEntries(ReminderLevel);
            if CustLedgEntry.FindSet() then
                repeat
                    IsHandled := false;
                    OnFindAndMarkReminderCandidatesOnBeforeCustLedgEntryLoop(CustLedgEntry, GlobalReminderHeaderReq, IsHandled);
                    if not IsHandled then
                        if CustLedgEntry."On Hold" = '' then
                            MarkReminderCandidate(CustLedgEntry, ReminderLevel, CustAmount, MakeDoc, MaxReminderLevel, MaxLineLevel, false)
                        else // The customer ledger entry is on hold
                            if IncludeEntriesOnHold then begin
                                TempCustLedgerEntryOnHold := CustLedgEntry;
                                if TempCustLedgerEntryOnHold.Insert() then;
                                MarkReminderCandidate(CustLedgEntry, ReminderLevel, CustAmount, MakeDoc, MaxReminderLevel, MaxLineLevel, true);
                            end;
                until CustLedgEntry.Next() = 0;
        until ReminderLevel.Next(-1) = 0;

        IsHandled := false;
        OnAfterFindAndMarkReminderCandidates(GlobalCustLedgEntry, ReminderLevel, CustAmount, MakeDoc, MaxReminderLevel, MaxLineLevel, IsHandled, Result);
        if IsHandled then
            exit(Result);

        exit(true);
    end;

    local procedure MarkReminderCandidate(var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; var CustAmount: Decimal; var MakeDoc: Boolean; var MaxReminderLevel: Integer; var MaxLineLevel: Integer; EntryOnHold: Boolean)
    var
        ReminderDueDate: Date;
        LineLevel: Integer;
        MarkEntry: Boolean;
        IsHandled: Boolean;
        IsGracePeriodExpired: Boolean;
    begin
        IsHandled := false;
        OnBeforeMarkReminderCandidate(CustLedgEntry, IsHandled);
        if IsHandled then
            exit;

        SetReminderLine(LineLevel, ReminderDueDate);
        IsGracePeriodExpired := IsGracePeriodExpiredForOverdueEntry(ReminderDueDate, GlobalReminderHeaderReq."Document Date", ReminderLevel."Grace Period");
        IsHandled := false;
        OnMarkReminderCandidateOnAfterCalcIsGracePeriodExpired(ReminderLevel, ReminderDueDate, GlobalReminderHeaderReq, GlobalReminderTerms, CustLedgEntry, GlobalReminderHeader, LineLevel, IsGracePeriodExpired, IsHandled);
        if IsHandled then
            exit;

        MarkEntry := false;
        if IsGracePeriodExpired and
           ((LineLevel <= GlobalReminderTerms."Max. No. of Reminders") or (GlobalReminderTerms."Max. No. of Reminders" = 0))
        then begin
            MarkEntry := true;
            CustLedgEntry.CalcFields("Remaining Amount");
            CustAmount += CustLedgEntry."Remaining Amount";
            if CustLedgEntry.Positive and IsGracePeriodExpired then
                MakeDoc := true;
        end else
            if not IsGracePeriodExpired and
               (not OverdueEntriesOnly or
                (CustLedgEntry."Document Type" in [CustLedgEntry."Document Type"::Payment, CustLedgEntry."Document Type"::Refund]))
            then
                MarkEntry := true;

        if MarkEntry then begin
            if not EntryOnHold then
                CustLedgEntry.Mark(true);
            ReminderLevel.Mark(true);
            if (ReminderLevel."No." > MaxReminderLevel) and
               (CustLedgEntry."Document Type" <> CustLedgEntry."Document Type"::"Credit Memo") and
               IsGracePeriodExpired
            then
                MaxReminderLevel := ReminderLevel."No.";
            if MaxLineLevel < LineLevel then
                MaxLineLevel := LineLevel;
        end;
    end;

    local procedure InsertReminderLine(ReminderNo: Code[50]; LineType: Enum "Reminder Line Type"; Description: Text[100]; var NextLineNo: Integer)
    var
        ReminderLine: Record "Reminder Line";
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeInsertReminderLine(ReminderNo, LineType, Description, NextLineNo, IsHandled);
        if IsHandled then
            exit;

        InitReminderLine(ReminderLine, ReminderNo, LineType, Description, NextLineNo);
        ReminderLine.Insert();
    end;

    local procedure InitReminderLine(var ReminderLine: Record "Reminder Line"; ReminderNo: Code[50]; LineType: Enum "Reminder Line Type"; Description: Text[100]; var NextLineNo: Integer)
    begin
        NextLineNo := GetLastLineNo(GlobalReminderHeader."No.") + 10000;

        ReminderLine.Init();
        ReminderLine."Reminder No." := CopyStr(ReminderNo, 1, MaxStrLen(ReminderLine."Reminder No."));
        ReminderLine."Line No." := NextLineNo;
        ReminderLine."Line Type" := LineType;
        ReminderLine.Description := Description;

        OnAfterInitReminderLine(GlobalReminderHeader, ReminderLine, LineType, Description);
    end;

    local procedure CustAmountLCY(CurrencyCode: Code[10]; Amount: Decimal): Decimal
    var
        CurrExchRate: Record "Currency Exchange Rate";
    begin
        if CurrencyCode <> '' then
            exit(
              CurrExchRate.ExchangeAmtFCYToLCY(
                GlobalReminderHeaderReq."Posting Date", CurrencyCode, Amount,
                CurrExchRate.ExchangeRate(GlobalReminderHeaderReq."Posting Date", CurrencyCode)));
        exit(Amount);
    end;

    /// <summary>
    /// Applies filters to customer ledger entries based on the specified reminder level.
    /// </summary>
    /// <param name="ReminderLevel2">Specifies the reminder level to filter customer ledger entries by.</param>
    procedure FilterCustLedgEntries(var ReminderLevel2: Record "Reminder Level")
    var
        ReminderLevel3: Record "Reminder Level";
        LastLevel: Boolean;
    begin
        if SkipCurrentReminderLevel(ReminderLevel2."No.") then begin
            GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", -1);
            exit;
        end;
        ReminderLevel3 := ReminderLevel2;
        ReminderLevel3.CopyFilters(ReminderLevel2);
        if ReminderLevel3.Next() = 0 then
            LastLevel := true
        else
            LastLevel := false;
        if GlobalReminderTerms."Max. No. of Reminders" > 0 then
            if ReminderLevel2."No." <= GlobalReminderTerms."Max. No. of Reminders" then
                if LastLevel then
                    GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", ReminderLevel2."No." - 1, GlobalReminderTerms."Max. No. of Reminders" - 1)
                else
                    GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", ReminderLevel2."No." - 1)
            else
                GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", -1)
        else
            if LastLevel then
                GlobalCustLedgEntry.SetFilter("Last Issued Reminder Level", '%1..', ReminderLevel2."No." - 1)
            else
                GlobalCustLedgEntry.SetRange("Last Issued Reminder Level", ReminderLevel2."No." - 1);
    end;

    local procedure SkipCurrentReminderLevel(ReminderLevelNo: Integer): Boolean
    var
        "Integer": Record "Integer";
    begin
        if CustLedgEntryLastIssuedReminderLevelFilter = '' then
            exit(false);

        Integer.SetFilter(Number, CustLedgEntryLastIssuedReminderLevelFilter);
        Integer.FindSet();
        if Integer.Number > ReminderLevelNo - 1 then
            exit(true);
        repeat
            if Integer.Number = ReminderLevelNo - 1 then
                exit(false)
        until Integer.Next() = 0;
        exit(true);
    end;

    local procedure FilterCustLedgEntryReminderLevel(var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; CurrencyCode: Code[10])
    begin
        CustLedgEntry.SetCurrentKey("Customer No.", Open, Positive, "Due Date", "Currency Code");
        CustLedgEntry.SetRange(Open, true);
        CustLedgEntry.SetRange("Customer No.", GlobalCustomer."No.");
        CustLedgEntry.SetRange("Currency Code", CurrencyCode);
        ReminderLevel.SetRange("Reminder Terms Code", GlobalReminderTerms.Code);

        OnAfterFilterCustLedgEntryReminderLevel(CustLedgEntry, ReminderLevel, GlobalReminderTerms, GlobalCustomer, GlobalReminderHeaderReq, GlobalReminderHeader);
    end;

    /// <summary>
    /// Calculates the reminder level and due date for a customer ledger entry based on previous reminder history.
    /// </summary>
    /// <param name="LineLevel2">Returns the calculated reminder level for the entry.</param>
    /// <param name="ReminderDueDate2">Returns the due date for the reminder entry.</param>
    procedure SetReminderLine(var LineLevel2: Integer; var ReminderDueDate2: Date)
    var
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeSetReminderLine(LineLevel2, ReminderDueDate2, IsHandled, GlobalCustLedgEntry, GlobalReminderEntry);
        if not IsHandled then begin
            if GlobalCustLedgEntry."Last Issued Reminder Level" > 0 then begin
                GlobalReminderEntry.SetCurrentKey("Customer Entry No.", Type);
                GlobalReminderEntry.SetRange("Customer Entry No.", GlobalCustLedgEntry."Entry No.");
                GlobalReminderEntry.SetRange(Type, GlobalReminderEntry.Type::Reminder);
                GlobalReminderEntry.SetRange("Reminder Level", GlobalCustLedgEntry."Last Issued Reminder Level");
                GlobalReminderEntry.SetRange(Canceled, false);
                OnSetReminderLineOnAfterSetFilters(GlobalReminderEntry);
                if GlobalReminderEntry.FindLast() then begin
                    ReminderDueDate2 := GlobalReminderEntry."Due Date";
                    LineLevel2 := GlobalReminderEntry."Reminder Level" + 1;
                    OnSetReminderLineOnAfterFindNextLineLevel(GlobalReminderEntry, LineLevel2, ReminderDueDate2);
                    exit;
                end
            end;
            ReminderDueDate2 := GlobalCustLedgEntry."Due Date";
            LineLevel2 := 1;
        end;

        OnAfterSetReminderLine(GlobalCustLedgEntry, LineLevel2, ReminderDueDate2);
    end;

    /// <summary>
    /// Adds a line fee for a customer ledger entry if applicable based on reminder level settings.
    /// </summary>
    /// <param name="CustLedgEntry">Specifies the customer ledger entry to add a line fee for.</param>
    /// <param name="ReminderLevel">Specifies the reminder level containing the line fee settings.</param>
    /// <param name="NextLineNo">Specifies the next line number to use for the reminder line.</param>
    procedure AddLineFeeForCustLedgEntry(var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; NextLineNo: Integer)
    var
        TempCustLedgEntry: Record "Cust. Ledger Entry" temporary;
        ReminderLine: Record "Reminder Line";
        IssuedReminderLine: Record "Issued Reminder Line";
        CustPostingGr: Record "Customer Posting Group";
        LineFeeAmount: Decimal;
    begin
        TempCustLedgEntry := CustLedgEntry;
        TempCustLedgEntry.Insert();
        TempCustLedgEntry.Reset();
        TempCustLedgEntry.CopyFilters(GlobalCustLedgEntryLineFeeFilters);
        if TempCustLedgEntry.IsEmpty() then
            exit;

        CustLedgEntry.CalcFields("Remaining Amount");
        OnAddLineFeeForCustLedgEntryOnAfterCalcRemainingAmount(CustLedgEntry);
        LineFeeAmount := ReminderLevel.GetAdditionalFee(CustLedgEntry."Remaining Amount",
            GlobalReminderHeader."Currency Code", true, GlobalReminderHeader."Posting Date");
        if LineFeeAmount = 0 then
            exit;

        IssuedReminderLine.SetRange(Type, IssuedReminderLine.Type::"Line Fee");
        IssuedReminderLine.SetRange("Applies-To Document Type", CustLedgEntry."Document Type");
        IssuedReminderLine.SetRange("Applies-To Document No.", CustLedgEntry."Document No.");
        IssuedReminderLine.SetRange("No. of Reminders", ReminderLevel."No.");
        IssuedReminderLine.SetRange(Canceled, false);
        if not IssuedReminderLine.IsEmpty() then
            exit;

        CustPostingGr.Get(GlobalReminderHeader."Customer Posting Group");

        NextLineNo := NextLineNo + 100;
        ReminderLine.Init();
        ReminderLine.Validate("Reminder No.", GlobalReminderHeader."No.");
        ReminderLine.Validate("Line No.", NextLineNo);
        ReminderLine.Validate(Type, ReminderLine.Type::"Line Fee");
        ReminderLine.Validate("No.", CustPostingGr.GetAddFeePerLineAccount());
        ReminderLine.Validate("No. of Reminders", ReminderLevel."No.");
        ReminderLine.Validate("Applies-to Document Type", CustLedgEntry."Document Type");
        ReminderLine.Validate("Applies-to Document No.", CustLedgEntry."Document No.");
        ReminderLine.Validate("Due Date", CalcDate(ReminderLevel."Due Date Calculation", GlobalReminderHeader."Document Date"));
        OnAddLineFeeForCustLedgEntryOnReminderLineInsert(ReminderLine);
        ReminderLine.Insert(true);
    end;

    internal procedure EmitCreateReminderTelemetry()
    begin
        FeatureTelemetry.LogUptake('0000LB0', 'Reminder', Enum::"Feature Uptake Status"::"Set up");
        FeatureTelemetry.LogUptake('0000LB1', 'Reminder', Enum::"Feature Uptake Status"::Used);
        FeatureTelemetry.LogUsage('0000LB2', 'Reminder', 'Make Reminder called.');
    end;

    local procedure GetLastLineNo(ReminderNo: Code[50]): Integer
    var
        ReminderLineExtra: Record "Reminder Line";
    begin
        ReminderLineExtra.SetRange("Reminder No.", ReminderNo);
        if ReminderLineExtra.FindLast() then;
        exit(ReminderLineExtra."Line No.");
    end;

    local procedure SetReminderLevel(ReminderHeader: Record "Reminder Header"; var ReminderLine: Record "Reminder Line"; LineLevel: Integer)
    begin
        if ReminderHeader."Use Header Level" then
            ReminderLine."No. of Reminders" := ReminderHeader."Reminder Level"
        else
            ReminderLine."No. of Reminders" := LineLevel;
    end;

    local procedure RemoveLinesOfNegativeReminder(var ReminderHeader: Record "Reminder Header")
    var
        ReminderTotal: Decimal;
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeRemoveLinesOfNegativeReminder(ReminderHeader, GlobalReminderHeaderReq, GlobalCustomer, IsHandled);
        if IsHandled then
            exit;

        ReminderHeader.CalcFields(
          "Remaining Amount", "Interest Amount", "Additional Fee", "VAT Amount");

        ReminderTotal := ReminderHeader."Remaining Amount" + ReminderHeader."Interest Amount" +
          ReminderHeader."Additional Fee" + ReminderHeader."VAT Amount";

        if ReminderTotal < 0 then
            ReminderHeader.Delete(true);
    end;

    local procedure GetOpenEntriesNotDueOnHoldTranslated(CustomerLanguageCode: Code[10]; var OpenEntriesNotDueTranslated: Text[100]; var OpenEntriesOnHoldTranslated: Text[100])
    var
        Language: Codeunit Language;
        CurrentLanguageCode: Integer;
    begin
        if CustomerLanguageCode <> '' then begin
            CurrentLanguageCode := GlobalLanguage;
            GlobalLanguage(Language.GetLanguageIdOrDefault(CustomerLanguageCode));
            OpenEntriesNotDueTranslated := OpenEntriesNotDueLbl;
            OpenEntriesOnHoldTranslated := OpenEntriesOnHoldLbl;
            GlobalLanguage(CurrentLanguageCode);
        end else begin
            OpenEntriesNotDueTranslated := OpenEntriesNotDueLbl;
            OpenEntriesOnHoldTranslated := OpenEntriesOnHoldLbl;
        end;
    end;

    local procedure RemoveNotDueLinesInSectionReminderLine(ReminderLine: Record "Reminder Line")
    var
        ReminderLineToDelete: Record "Reminder Line";
    begin
        ReminderLineToDelete.SetRange("Reminder No.", ReminderLine."Reminder No.");
        ReminderLineToDelete.SetRange(Type, ReminderLine.Type);
        ReminderLineToDelete.SetRange("Entry No.", ReminderLine."Entry No.");
        ReminderLineToDelete.SetRange("Document Type", ReminderLine."Document Type");
        ReminderLineToDelete.SetRange("Document No.", ReminderLine."Document No.");
        ReminderLineToDelete.SetFilter("Line Type", '<>%1', ReminderLine."Line Type");
        if ReminderLineToDelete.FindFirst() then
            ReminderLineToDelete.Delete(true);
    end;

    local procedure CheckCustomerIsBlocked(Customer: Record Customer) Result: Boolean
    begin
        Result := Customer.Blocked = Customer.Blocked::All;
        OnAfterCheckCustomerIsBlocked(Customer, Result);
    end;

    local procedure IsGracePeriodExpiredForOverdueEntry(DueDate: Date; ReminderDocumentDate: Date; GracePeriod: DateFormula): Boolean
    begin
        exit(CalcDate(GracePeriod, DueDate) < ReminderDocumentDate);
    end;

    /// <summary>
    /// Raised after the reminder creation process completes.
    /// </summary>
    /// <param name="RetVal">Indicates whether at least one reminder was created successfully.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterCode(var RetVal: Boolean)
    begin
    end;

    /// <summary>
    /// Raised after filters are applied to customer ledger entries based on reminder level.
    /// </summary>
    /// <param name="CustLedgerEntry">The customer ledger entry record being filtered.</param>
    /// <param name="ReminderLevel">The reminder level used for filtering.</param>
    /// <param name="ReminderTerms">The reminder terms configuration.</param>
    /// <param name="Customer">The customer record for the reminder.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderHeader">The reminder header being created.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterFilterCustLedgEntryReminderLevel(var CustLedgerEntry: Record "Cust. Ledger Entry"; var ReminderLevel: Record "Reminder Level"; ReminderTerms: Record "Reminder Terms"; Customer: Record Customer; ReminderHeaderReq: Record "Reminder Header"; ReminderHeader: Record "Reminder Header")
    begin
    end;

    /// <summary>
    /// Raised after a reminder line is initialized with default values.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header for the line.</param>
    /// <param name="ReminderLine">The initialized reminder line.</param>
    /// <param name="LineType">The type of the reminder line.</param>
    /// <param name="Description">The description for the reminder line.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterInitReminderLine(var ReminderHeader: Record "Reminder Header"; var ReminderLine: Record "Reminder Line"; LineType: Enum "Reminder Line Type"; Description: Text)
    begin
    end;

    /// <summary>
    /// Raised after a reminder document is created with all its lines.
    /// </summary>
    /// <param name="ReminderHeader">The completed reminder header.</param>
    /// <param name="ReminderLine">The last reminder line processed.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterMakeReminder(var ReminderHeader: Record "Reminder Header"; var ReminderLine: Record "Reminder Line")
    begin
    end;

    /// <summary>
    /// Raised after the reminder creation parameters are set.
    /// </summary>
    /// <param name="Cust">The customer for reminder creation.</param>
    /// <param name="CustLedgEntry">The customer ledger entries filter.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>
    /// <param name="IncludeEntriesOnHold">Indicates whether entries on hold are included.</param>
    /// <param name="CustLedgEntryLinefeeOn">The customer ledger entries filter for line fees.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterSet(var Cust: Record Customer; var CustLedgEntry: Record "Cust. Ledger Entry"; var ReminderHeaderReq: Record "Reminder Header"; var OverdueEntriesOnly: Boolean; var IncludeEntriesOnHold: Boolean; var CustLedgEntryLinefeeOn: Record "Cust. Ledger Entry")
    begin
    end;

    /// <summary>
    /// Raised after the reminder level and due date are calculated for a customer ledger entry.
    /// </summary>
    /// <param name="CustLedgEntry">The customer ledger entry being processed.</param>
    /// <param name="LineLevel2">The calculated reminder level for the entry.</param>
    /// <param name="ReminderDueDate2">The calculated due date for the reminder.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterSetReminderLine(CustLedgEntry: Record "Cust. Ledger Entry"; var LineLevel2: Integer; var ReminderDueDate2: Date)
    begin
    end;

    /// <summary>
    /// Raised after the suggest lines parameters are set for an existing reminder.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header to add lines to.</param>
    /// <param name="CustLedgEntry2">The customer ledger entries filter.</param>
    /// <param name="OverdueEntriesOnly2">Indicates whether only overdue entries are included.</param>
    /// <param name="IncludeEntriesOnHold2">Indicates whether entries on hold are included.</param>
    /// <param name="CustLedgEntryLinefeeOn">The customer ledger entries filter for line fees.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterSuggestLines(ReminderHeader: Record "Reminder Header"; var CustLedgEntry2: Record "Cust. Ledger Entry"; OverdueEntriesOnly2: Boolean; IncludeEntriesOnHold2: Boolean; var CustLedgEntryLinefeeOn: Record "Cust. Ledger Entry")
    begin
    end;

    /// <summary>
    /// Raised after the remaining amount is calculated for a customer ledger entry when adding line fees.
    /// </summary>
    /// <param name="CustLedgerEntry">The customer ledger entry with calculated remaining amount.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAddLineFeeForCustLedgEntryOnAfterCalcRemainingAmount(var CustLedgerEntry: Record "Cust. Ledger Entry")
    begin
    end;

    /// <summary>
    /// Raised before inserting a line fee reminder line.
    /// </summary>
    /// <param name="ReminderLine">The line fee reminder line to be inserted.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAddLineFeeForCustLedgEntryOnReminderLineInsert(var ReminderLine: Record "Reminder Line")
    begin
    end;

    /// <summary>
    /// Raised before checking if the amounts not due line has been inserted.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header being processed.</param>
    /// <param name="ReminderLine">The current reminder line.</param>
    /// <param name="AmountsNotDueLineInserted">Indicates whether the amounts not due line has been inserted.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilterOnBeforeCheckAmountsNotDueLineInserted(ReminderHeader: Record "Reminder Header"; ReminderLine: Record "Reminder Line"; var AmountsNotDueLineInserted: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before adding reminder lines from customer ledger entries with no reminder level filter.
    /// </summary>
    /// <param name="CustLedgEntry">The customer ledger entry to add.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderHeader">The reminder header being created.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    /// <param name="ReminderLine">The reminder line being created.</param>
    /// <param name="NextLineNo">The next line number to use.</param>
    /// <param name="StartLineInserted">Indicates whether a start line was inserted.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilter(var CustLedgEntry: Record "Cust. Ledger Entry"; ReminderHeaderReq: Record "Reminder Header"; ReminderHeader: Record "Reminder Header"; var IsHandled: Boolean; var ReminderLine: Record "Reminder Line"; var NextLineNo: Integer; var StartLineInserted: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before finding customer ledger entries for reminder creation.
    /// </summary>
    /// <param name="CustLedgerEntry">The customer ledger entry record to search.</param>
    /// <param name="ReminderHeader">The reminder header request parameters.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeCustLedgerEntryFind(var CustLedgerEntry: Record "Cust. Ledger Entry"; ReminderHeader: Record "Reminder Header"; Customer: Record Customer)
    begin
    end;

    /// <summary>
    /// Raised before retrieving the reminder terms for a customer.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header being processed.</param>
    /// <param name="ReminderTerms">The reminder terms to retrieve.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeGetReminderTerms(var ReminderHeader: Record "Reminder Header"; var ReminderTerms: Record "Reminder Terms"; var IsHandled: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before finding and marking customer ledger entries as reminder candidates.
    /// </summary>
    /// <param name="ReminderLevel">The reminder level configuration.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderTerms">The reminder terms configuration.</param>
    /// <param name="ReminderEntry">The reminder entry record for history lookup.</param>
    /// <param name="CustLedgEntry">The customer ledger entries to process.</param>
    /// <param name="TempCustLedgEntryOnHold">Temporary table for entries on hold.</param>
    /// <param name="CustLedgEntryLastIssuedReminderLevelFilter">Filter for last issued reminder level.</param>
    /// <param name="CustAmount">The cumulative customer amount.</param>
    /// <param name="MakeDoc">Indicates whether to create a reminder document.</param>
    /// <param name="MaxReminderLevel">The maximum reminder level found.</param>
    /// <param name="MaxLineLevel">The maximum line level found.</param>
    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>
    /// <param name="IncludeEntriesOnHold">Indicates whether entries on hold are included.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    /// <param name="Result">Returns the result when handling is skipped.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeFindAndMarkReminderCandidates(var ReminderLevel: Record "Reminder Level"; ReminderHeaderReq: Record "Reminder Header"; ReminderTerms: Record "Reminder Terms"; var ReminderEntry: Record "Reminder/Fin. Charge Entry"; var CustLedgEntry: Record "Cust. Ledger Entry"; var TempCustLedgEntryOnHold: Record "Cust. Ledger Entry" temporary; var CustLedgEntryLastIssuedReminderLevelFilter: Text; var CustAmount: Decimal; var MakeDoc: Boolean; var MaxReminderLevel: Integer; var MaxLineLevel: Integer; OverdueEntriesOnly: Boolean; IncludeEntriesOnHold: Boolean; var IsHandled: Boolean; var Result: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before inserting a reminder line.
    /// </summary>
    /// <param name="ReminderNo">The reminder document number.</param>
    /// <param name="LineType">The type of the reminder line.</param>
    /// <param name="Description">The description for the line.</param>
    /// <param name="NextLineNo">The next line number to use.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeInsertReminderLine(ReminderNo: Code[20]; LineType: Enum "Reminder Line Type"; Description: Text[100]; var NextLineNo: Integer; var IsHandled: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before creating a reminder for a specific currency.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header to create.</param>
    /// <param name="CurrencyCode">The currency code for the reminder.</param>
    /// <param name="RetVal">Returns the result when handling is skipped.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>
    /// <param name="IncludeEntriesOnHold">Indicates whether entries on hold are included.</param>
    /// <param name="HeaderExists">Indicates whether a reminder header already exists.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeMakeReminder(var ReminderHeader: Record "Reminder Header"; CurrencyCode: Code[10]; var RetVal: Boolean; var IsHandled: Boolean; ReminderHeaderReq: Record "Reminder Header"; OverdueEntriesOnly: Boolean; IncludeEntriesOnHold: Boolean; HeaderExists: Boolean; Customer: Record Customer)
    begin
    end;

    /// <summary>
    /// Raised before marking a customer ledger entry as a reminder candidate.
    /// </summary>
    /// <param name="CustLedgEntry">The customer ledger entry to evaluate.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeMarkReminderCandidate(var CustLedgEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before removing lines from a reminder with negative total amount.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header to evaluate.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeRemoveLinesOfNegativeReminder(var ReminderHeader: Record "Reminder Header"; ReminderHeaderReq: Record "Reminder Header"; Customer: Record Customer; var IsHandled: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before finding an existing reminder header for the customer and currency.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header record to search.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderTerms">The reminder terms configuration.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    /// <param name="CustLedgerEntry">The customer ledger entry being processed.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeReminderHeaderFind(var ReminderHeader: Record "Reminder Header"; ReminderHeaderReq: Record "Reminder Header"; ReminderTerms: Record "Reminder Terms"; Customer: Record Customer; CustLedgerEntry: Record "Cust. Ledger Entry")
    begin
    end;

    /// <summary>
    /// Raised before inserting a new reminder header.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header to insert.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderTerms">The reminder terms configuration.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeReminderHeaderInsert(var ReminderHeader: Record "Reminder Header"; ReminderHeaderReq: Record "Reminder Header"; ReminderTerms: Record "Reminder Terms"; Customer: Record Customer)
    begin
    end;

    /// <summary>
    /// Raised before modifying the reminder header with reminder level and other settings.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header to modify.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="HeaderExists">Indicates whether the header already existed.</param>
    /// <param name="ReminderTerms">The reminder terms configuration.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    /// <param name="ReminderLevel">The reminder level being applied.</param>
    /// <param name="CustLedgerEntry">The customer ledger entries being processed.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeReminderHeaderModify(var ReminderHeader: Record "Reminder Header"; var ReminderHeaderReq: Record "Reminder Header"; HeaderExists: Boolean; ReminderTerms: Record "Reminder Terms"; Customer: Record Customer; ReminderLevel: Record "Reminder Level"; var CustLedgerEntry: Record "Cust. Ledger Entry")
    begin
    end;

    /// <summary>
    /// Raised before inserting a reminder line for a customer ledger entry.
    /// </summary>
    /// <param name="ReminderLine">The reminder line to insert.</param>
    /// <param name="ReminderHeader">The reminder header for the line.</param>
    /// <param name="ReminderLevel">The reminder level for the line.</param>
    /// <param name="CustLedgerEntry">The customer ledger entry for the line.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeReminderLineInsert(var ReminderLine: Record "Reminder Line"; ReminderHeader: Record "Reminder Header"; ReminderLevel: Record "Reminder Level"; CustLedgerEntry: Record "Cust. Ledger Entry"; ReminderHeaderReq: Record "Reminder Header")
    begin
    end;

    /// <summary>
    /// Raised before processing reminders for each currency.
    /// </summary>
    /// <param name="CustLedgEntry">The customer ledger entries to process.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderTerms">The reminder terms configuration.</param>
    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>
    /// <param name="IncludeEntriesOnHold">Indicates whether entries on hold are included.</param>
    /// <param name="HeaderExists">Indicates whether a reminder header already exists.</param>
    /// <param name="CustLedgEntryLastIssuedReminderLevelFilter">Filter for last issued reminder level.</param>
    /// <param name="TempCurrency">Temporary table of currencies to process.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    /// <param name="CustLedgEntryLineFeeFilters">The customer ledger entries filter for line fees.</param>
    [IntegrationEvent(false, false)]
    local procedure OnCodeOnBeforeCurrencyLoop(CustLedgEntry: Record "Cust. Ledger Entry"; ReminderHeaderReq: Record "Reminder Header"; ReminderTerms: Record "Reminder Terms"; OverdueEntriesOnly: Boolean; IncludeEntriesOnHold: Boolean; HeaderExists: Boolean; CustLedgEntryLastIssuedReminderLevelFilter: Text; var TempCurrency: Record Currency temporary; Customer: Record Customer; var CustLedgEntryLineFeeFilters: Record "Cust. Ledger Entry")
    begin
    end;

    /// <summary>
    /// Raised before retrieving reminder terms for processing.
    /// </summary>
    /// <param name="Customer">The customer to get reminder terms for.</param>
    /// <param name="CustLedgerEntry">The customer ledger entries being processed.</param>
    /// <param name="CustLedgEntryLastIssuedReminderLevelFilter">Filter for last issued reminder level.</param>
    /// <param name="ReminderHeader">The reminder header being processed.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    /// <param name="ReturnValue">Returns the result when handling is skipped.</param>
    [IntegrationEvent(false, false)]
    local procedure OnCodeOnBeforeGetReminderTerms(var Customer: Record Customer; var CustLedgerEntry: Record "Cust. Ledger Entry"; var CustLedgEntryLastIssuedReminderLevelFilter: Text; var ReminderHeader: Record "Reminder Header"; var IsHandled: Boolean; var ReturnValue: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before processing each customer ledger entry in the reminder candidate loop.
    /// </summary>
    /// <param name="CustLedgerEntry">The customer ledger entry being processed.</param>
    /// <param name="ReminderHeader">The reminder header request parameters.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    [IntegrationEvent(false, false)]
    local procedure OnFindAndMarkReminderCandidatesOnBeforeCustLedgEntryLoop(var CustLedgerEntry: Record "Cust. Ledger Entry"; var ReminderHeader: Record "Reminder Header"; var IsHandled: Boolean)
    begin
    end;

    /// <summary>
    /// Raised after finding and marking reminder candidates from customer ledger entries.
    /// </summary>
    /// <param name="CustLedgEntry">The customer ledger entries processed.</param>
    /// <param name="ReminderLevel">The reminder level configuration.</param>
    /// <param name="CustAmount">The cumulative customer amount.</param>
    /// <param name="MakeDoc">Indicates whether to create a reminder document.</param>
    /// <param name="MaxReminderLevel">The maximum reminder level found.</param>
    /// <param name="MaxLineLevel">The maximum line level found.</param>
    /// <param name="IsHandled">Set to true to skip default result.</param>
    /// <param name="Result">Returns the result when handling is skipped.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterFindAndMarkReminderCandidates(CustLedgEntry: Record "Cust. Ledger Entry"; ReminderLevel: Record "Reminder Level"; var CustAmount: Decimal; MakeDoc: Boolean; MaxReminderLevel: Integer; MaxLineLevel: Integer; var IsHandled: Boolean; var Result: Boolean)
    begin
    end;

    /// <summary>
    /// Raised after calculating whether a reminder document should be created.
    /// </summary>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderHeader">The reminder header being created.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    /// <param name="ShouldMakeDoc">Indicates whether a reminder document should be created.</param>
    /// <param name="MakeDoc">The original make document flag.</param>
    /// <param name="CustLedgerEntry">The customer ledger entries being processed.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnAfterCalcShouldMakeDoc(ReminderHeaderReq: Record "Reminder Header"; ReminderHeader: Record "Reminder Header"; Customer: Record Customer; var ShouldMakeDoc: Boolean; MakeDoc: Boolean; var CustLedgerEntry: Record "Cust. Ledger Entry")
    begin
    end;

    /// <summary>
    /// Raised after adding reminder lines from customer ledger entries with no reminder level filter.
    /// </summary>
    /// <param name="CustLedgerEntry">The customer ledger entries processed.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    /// <param name="ReminderHeader">The reminder header being created.</param>
    /// <param name="MaxReminderLevel">The maximum reminder level.</param>
    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries are included.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnAfterAddRemiderLinesFromCustLedgEntriesWithNoReminderLevelFilter(var CustLedgerEntry: Record "Cust. Ledger Entry"; Customer: Record Customer; ReminderHeader: Record "Reminder Header"; MaxReminderLevel: Integer; var OverdueEntriesOnly: Boolean)
    begin
    end;

    /// <summary>
    /// Raised after processing each reminder level in the reminder creation loop.
    /// </summary>
    /// <param name="ReminderLevel">The reminder level processed.</param>
    /// <param name="NextLineNo">The next line number available.</param>
    /// <param name="StartLineInserted">Indicates whether a start line was inserted.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderHeader">The reminder header being created.</param>
    /// <param name="Customer">The customer for the reminder.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnAfterReminderLevelLoop(var ReminderLevel: Record "Reminder Level"; var NextLineNo: Integer; StartLineInserted: Boolean; ReminderHeaderReq: Record "Reminder Header"; ReminderHeader: Record "Reminder Header"; Customer: Record Customer)
    begin
    end;

    /// <summary>
    /// Raised after calculating whether the grace period has expired for an overdue entry.
    /// </summary>
    /// <param name="ReminderDueDate">The due date of the reminder entry.</param>
    /// <param name="ReminderHeader">The reminder header request parameters.</param>
    /// <param name="IsGracePeriodExpired">Indicates whether the grace period has expired.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnAfterCalcIsGracePeriodExpired(var ReminderDueDate: Date; var ReminderHeader: Record "Reminder Header"; var IsGracePeriodExpired: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before finding customer ledger entries for processing in the reminder creation.
    /// </summary>
    /// <param name="CustLedgEntry">The customer ledger entry record to search.</param>
    /// <param name="Cust">The customer for the reminder.</param>
    /// <param name="ReminderHeader">The reminder header being created.</param>
    /// <param name="MaxReminderLevel">The maximum reminder level.</param>
    /// <param name="OverDueEntriesOnly">Indicates whether only overdue entries are included.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnBeforeCustLedgEntryFindSet(var CustLedgEntry: Record "Cust. Ledger Entry"; Cust: Record Customer; ReminderHeader: Record "Reminder Header"; MaxReminderLevel: Integer; var OverDueEntriesOnly: Boolean)
    begin
    end;

    /// <summary>
    /// Raised before inserting a reminder line for an on-hold customer ledger entry.
    /// </summary>
    /// <param name="ReminderLine">The reminder line to insert.</param>
    /// <param name="ReminderHeader">The reminder header for the line.</param>
    /// <param name="ReminderLevel">The reminder level configuration.</param>
    /// <param name="CustLedgerEntry">The customer ledger entries being processed.</param>
    /// <param name="CustLedgEntryOnHoldTEMP">Temporary table of entries on hold.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnBeforeOnHoldReminderLineInsert(var ReminderLine: Record "Reminder Line"; ReminderHeader: Record "Reminder Header"; ReminderLevel: Record "Reminder Level"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var CustLedgEntryOnHoldTEMP: Record "Cust. Ledger Entry" temporary)
    begin
    end;

    /// <summary>
    /// Raised before modifying the reminder header after all lines are processed.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header to modify.</param>
    /// <param name="ReminderLine">The last reminder line processed.</param>
    /// <param name="NextLineNo">The next line number available.</param>
    /// <param name="MaxReminderLevel">The maximum reminder level.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnBeforeReminderHeaderModify(var ReminderHeader: Record "Reminder Header"; var ReminderLine: Record "Reminder Line"; var NextLineNo: Integer; MaxReminderLevel: Integer)
    begin
    end;

    /// <summary>
    /// Raised after calculating whether the grace period has expired when marking reminder candidates.
    /// </summary>
    /// <param name="ReminderLevel">The reminder level configuration.</param>
    /// <param name="ReminderDueDate">The due date of the reminder entry.</param>
    /// <param name="ReminderHeaderReq">The reminder header request parameters.</param>
    /// <param name="ReminderTerms">The reminder terms configuration.</param>
    /// <param name="CustLedgerEntry">The customer ledger entry being evaluated.</param>
    /// <param name="ReminderHeader">The reminder header being created.</param>
    /// <param name="LineLevel">The calculated line level.</param>
    /// <param name="IsGracePeriodExpired">Indicates whether the grace period has expired.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMarkReminderCandidateOnAfterCalcIsGracePeriodExpired(var ReminderLevel: Record "Reminder Level"; var ReminderDueDate: Date; var ReminderHeaderReq: Record "Reminder Header"; var ReminderTerms: Record "Reminder Terms"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var ReminderHeader: Record "Reminder Header"; var LineLevel: Integer; var IsGracePeriodExpired: Boolean; var IsHandled: Boolean)
    begin
    end;

    /// <summary>
    /// Raised after setting filters on the reminder entry record when calculating reminder level.
    /// </summary>
    /// <param name="ReminderFinChargeEntry">The reminder entry record with filters applied.</param>
    [IntegrationEvent(false, false)]
    local procedure OnSetReminderLineOnAfterSetFilters(var ReminderFinChargeEntry: Record "Reminder/Fin. Charge Entry")
    begin
    end;

    /// <summary>
    /// Raised after finding the next line level from the reminder entry history.
    /// </summary>
    /// <param name="ReminderEntry">The reminder entry record found.</param>
    /// <param name="LineLevel2">The calculated next line level.</param>
    /// <param name="ReminderDueDate2">The due date from the reminder entry.</param>
    [IntegrationEvent(false, false)]
    local procedure OnSetReminderLineOnAfterFindNextLineLevel(ReminderEntry: Record "Reminder/Fin. Charge Entry"; var LineLevel2: Integer; var ReminderDueDate2: Date)
    begin
    end;

    /// <summary>
    /// Raised before inserting a reminder line for entries not due with no reminder level filter.
    /// </summary>
    /// <param name="ReminderLine">The reminder line to insert.</param>
    /// <param name="ReminderHeader">The reminder header for the line.</param>
    /// <param name="ReminderLevel">The reminder level configuration.</param>
    /// <param name="CustLedgerEntry">The customer ledger entry for the line.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAddRemiderLinesFromCustLedgEntryWithNoReminderLevelFilterOnBeforeReminderLineInsert(var ReminderLine: Record "Reminder Line"; ReminderHeader: Record "Reminder Header"; ReminderLevel: Record "Reminder Level"; var CustLedgerEntry: Record "Cust. Ledger Entry")
    begin
    end;

    /// <summary>
    /// Raised after checking if a customer is blocked.
    /// </summary>
    /// <param name="Customer">The customer record that was checked.</param>
    /// <param name="Result">Returns whether the customer is blocked.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterCheckCustomerIsBlocked(Customer: Record Customer; var Result: Boolean)
    begin
    end;

    /// <summary>
    /// Raised after filtering customer ledger entries in the make reminder process.
    /// </summary>
    /// <param name="ReminderLine">The reminder line being processed.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnAfterFilterCustLedgEntries(var ReminderLine: Record "Reminder Line")
    begin
    end;

    /// <summary>
    /// Raised before the reminder header inserts its standard lines.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header about to insert lines.</param>
    [IntegrationEvent(false, false)]
    local procedure OnMakeReminderOnBeforeReminderHeaderInsertLines(var ReminderHeader: Record "Reminder Header")
    begin
    end;

    /// <summary>
    /// Raised before setting the reminder line level and due date.
    /// </summary>
    /// <param name="LineLevel2">The line level to be set.</param>
    /// <param name="ReminderDueDate2">The reminder due date to be set.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    /// <param name="CustLedgerEntry">The customer ledger entry being processed.</param>
    /// <param name="ReminderFinChargeEntry">The reminder entry record for history lookup.</param>
    [IntegrationEvent(false, false)]
    local procedure OnBeforeSetReminderLine(var LineLevel2: Integer; var ReminderDueDate2: Date; var IsHandled: Boolean; var CustLedgerEntry: Record "Cust. Ledger Entry"; var ReminderFinChargeEntry: Record "Reminder/Fin. Charge Entry")
    begin
    end;

    /// <summary>
    /// Raised after inserting all reminder lines in the loop.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header with inserted lines.</param>
    /// <param name="CurrencyCode">The currency code for the reminder.</param>
    /// <param name="NextLineNo">The next available line number.</param>
    /// <param name="MaxReminderLevel">The maximum reminder level applied.</param>
    /// <param name="OverdueEntriesOnly">Indicates whether only overdue entries were included.</param>
    [IntegrationEvent(false, false)]
    local procedure OnAfterReminderLinesInsertLoop(var ReminderHeader: Record "Reminder Header"; CurrencyCode: Code[10]; var NextLineNo: Integer; var MaxReminderLevel: Integer; OverdueEntriesOnly: Boolean);
    begin
    end;

    /// <summary>
    /// Raised after retrieving the customer for an existing reminder header.
    /// </summary>
    /// <param name="ReminderHeader">The reminder header being processed.</param>
    /// <param name="Customer">The customer retrieved for the reminder.</param>
    /// <param name="IsHandled">Set to true to skip default processing.</param>
    /// <param name="ReturnValue">Returns the result when handling is skipped.</param>
    [IntegrationEvent(false, false)]
    local procedure OnCodeOnAfterGlobalReminderGetGlobalCustomer(var ReminderHeader: Record "Reminder Header"; var Customer: Record Customer; var IsHandled: Boolean; var ReturnValue: Boolean)
    begin
    end;
}