Subversion Repositories SmartDukaan

package com.smartdukaan.cron.offercircular;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * Turns the "# ..." notes printed under each page's table into structured rules.

 *

 * These are real eligibility rules, not decoration, and they are PAGE-scoped: pages 2

 * and 3 of the Aug'26 circular read "HDFC, AU & SBI" where every other page reads

 * "HDFC & SBI", so AU's 3-month exclusion applies only to the Oppo and Xiaomi pages.

 * Recording them document-wide would over-apply AU; ignoring them loses the rule

 * entirely.

 *

 * Bank names are resolved with {@link BankTextParser} so footnotes get exactly the

 * same aliasing as the bank columns.

 */

public final class FootnoteParser {

    public static final String TYPE_TENURE_BANK_EXCLUSION = "TENURE_BANK_EXCLUSION";

    public static final String TYPE_BANK_RESTRICTION = "BANK_RESTRICTION";

    public static final String TYPE_BRAND_RESTRICTION = "BRAND_RESTRICTION";

    public static final String TYPE_NOTE = "NOTE";

    /** "Additional cashback not applicable on 3 Month tenure of HDFC, AU & SBI" */

    private static final Pattern TENURE_EXCLUSION = Pattern.compile(

            "additional\\s+cashback\\s+not\\s+applicable.*?(\\d+)\\s*month\\s*tenure\\s*(?:of)?\\s*(.*)$",

            Pattern.CASE_INSENSITIVE);

    /** "Instant cashback applicable on HDFC, ICICI, OneCard, ..." */

    private static final Pattern BANK_ALLOWLIST = Pattern.compile(

            "instant\\s+cashback\\s+applicable\\s+on\\s+(.*)$", Pattern.CASE_INSENSITIVE);

    /** "SBI Instant Cashback applicable on selective Brands Only." */

    private static final Pattern BRAND_RESTRICTION = Pattern.compile(

            "^(.*?)\\s+instant\\s+cashback\\s+applicable\\s+on\\s+selective\\s+brands",

            Pattern.CASE_INSENSITIVE);

    /** One row destined for offers.offer_condition. */

    public static final class Condition {

        private final int pageNo;

        private final String conditionType;

        private final Integer bankId;

        private final Integer tenureMonths;

        private final String noteText;

        private final String rawText;

        Condition(int pageNo, String conditionType, Integer bankId, Integer tenureMonths,

                  String noteText, String rawText) {

            this.pageNo = pageNo;

            this.conditionType = conditionType;

            this.bankId = bankId;

            this.tenureMonths = tenureMonths;

            this.noteText = noteText;

            this.rawText = rawText;

        }

        public int getPageNo() { return pageNo; }

        public String getConditionType() { return conditionType; }

        public Integer getBankId() { return bankId; }

        public Integer getTenureMonths() { return tenureMonths; }

        public String getNoteText() { return noteText; }

        public String getRawText() { return rawText; }

        @Override public String toString() {

            return conditionType + " p" + pageNo + " bank=" + bankId + " months=" + tenureMonths;

        }

    }

    public static final class Result {

        private final List<Condition> conditions = new ArrayList<>();

        private final List<String> warnings = new ArrayList<>();

        public List<Condition> getConditions() { return conditions; }

        public List<String> getWarnings() { return warnings; }

    }

    private FootnoteParser() { }

    public static Result parse(List<CircularExtractor.Footnote> footnotes,

                               Map<String, Integer> bankAliases) {

        Result result = new Result();

        for (CircularExtractor.Footnote footnote : footnotes) {

            int page = footnote.getPageNo();

            String text = footnote.getText().trim();

            Matcher tenure = TENURE_EXCLUSION.matcher(text);

            if (tenure.find()) {

                int months = Integer.parseInt(tenure.group(1));

                List<Integer> banks = banks(tenure.group(2), bankAliases, result, text);

                for (Integer bankId : banks) {

                    result.conditions.add(new Condition(page, TYPE_TENURE_BANK_EXCLUSION,

                            bankId, months, text, text));

                }

                if (banks.isEmpty()) {

                    result.conditions.add(new Condition(page, TYPE_TENURE_BANK_EXCLUSION,

                            null, months, text, text));

                }

                continue;

            }

            Matcher brand = BRAND_RESTRICTION.matcher(text);

            if (brand.find()) {

                List<Integer> banks = banks(brand.group(1), bankAliases, result, text);

                result.conditions.add(new Condition(page, TYPE_BRAND_RESTRICTION,

                        banks.isEmpty() ? null : banks.get(0), null, text, text));

                continue;

            }

            Matcher allow = BANK_ALLOWLIST.matcher(text);

            if (allow.find()) {

                List<Integer> banks = banks(allow.group(1), bankAliases, result, text);

                for (Integer bankId : banks) {

                    result.conditions.add(new Condition(page, TYPE_BANK_RESTRICTION,

                            bankId, null, text, text));

                }

                if (banks.isEmpty()) {

                    result.conditions.add(new Condition(page, TYPE_BANK_RESTRICTION,

                            null, null, text, text));

                }

                continue;

            }

            // An unrecognised footnote is kept verbatim rather than discarded - the

            // OEMs add new ones, and losing a rule silently is the worst outcome.

            result.warnings.add("unclassified footnote (page " + page + "): " + text);

            result.conditions.add(new Condition(page, TYPE_NOTE, null, null, text, text));

        }

        return result;

    }

    private static List<Integer> banks(String fragment, Map<String, Integer> bankAliases,

                                       Result result, String wholeNote) {

        BankTextParser.Result parsed = BankTextParser.parse(fragment, bankAliases);

        for (String unresolved : parsed.getUnresolved()) {

            result.warnings.add("footnote names an unmapped bank '" + unresolved

                    + "' in: " + wholeNote);

        }

        return parsed.getBankIds();

    }

}