Subversion Repositories SmartDukaan

package com.smartdukaan.cron.offercircular;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.regex.Pattern;

/**

 * Resolves the "Credit cards" / "Debit Cards" cells to bank ids.

 *

 * The alias map must be supplied by the caller (built from offers.bank +

 * offers.bank_alias) because the circular spells the same bank several ways across

 * pages: IDFC / IDFC BANK / IDFC FIRST BANK, Indusind / Indusland (a typo in the

 * source), AU / AU Bank / Au Small Finance Bank. Without aliasing, ingest creates

 * four IDFCs.

 *

 * Note that UPI appears in these columns but is a payment mode, not an issuer, so it

 * is reported as a flag rather than resolved as a bank.

 */

public final class BankTextParser {

    /** Card-type and qualifier words that are not bank names. J and K are the halves

     *  of "J&K" left behind by splitting on '&'; J&K is deliberately out of scope. */

    private static final Pattern NOISE = Pattern.compile(

            "^(CC|DC|EMI|CARD|CARDS|BANK|ONLY|LFR|FINANCIAL|CREDIT|DEBIT|REG|FULL"

            + "|SWIPE|AND|OR|THE|SELECTED|SELECTIVE|CARDLESS|CARDLESS EMI|CARDLES S"

            + "|CARDLES|J|K|K BANK)$");

    private static final Pattern ALL_BANKS = Pattern.compile("ALL\\s*BANKS?");

    private static final Pattern ALL_BANKS_CLAUSE = Pattern.compile("ALL\\s*BANKS?\\s*(EXCEPT)?");

    private static final Pattern UPI = Pattern.compile("\\bUPI\\b");

    private static final Pattern PARENTHETICAL = Pattern.compile("\\(.*?\\)");

    private static final Pattern SEPARATOR = Pattern.compile("[,/&]| AND ");

    private static final Pattern WHITESPACE = Pattern.compile("\\s+");

    public static final class Result {

        private final List<Integer> bankIds = new ArrayList<>();

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

        private boolean allBanks;

        private boolean upi;

        public List<Integer> getBankIds() { return bankIds; }

        public List<String> getUnresolved() { return unresolved; }

        public boolean isAllBanks() { return allBanks; }

        public boolean isUpi() { return upi; }

    }

    private BankTextParser() { }

    public static Result parse(String cell, Map<String, Integer> aliasToBankId) {

        Result result = new Result();

        if (cell == null) {

            return result;

        }

        String text = cell.trim();

        if (text.isEmpty() || "-".equals(text) || "NA".equals(text) || "N/A".equals(text)) {

            return result;

        }

        String upper = text.toUpperCase();

        result.allBanks = ALL_BANKS.matcher(upper).find();

        result.upi = UPI.matcher(upper).find();

        // parentheticals are qualifiers ("(DC & CC)", "(LFR Only)"), not bank names

        String body = PARENTHETICAL.matcher(upper).replaceAll(" ");

        body = ALL_BANKS_CLAUSE.matcher(body).replaceAll(" ");

        for (String token : SEPARATOR.split(body)) {

            String name = strip(WHITESPACE.matcher(token).replaceAll(" "), " .-");

            if (name.isEmpty() || NOISE.matcher(name).matches() || "UPI".equals(name)) {

                continue;

            }

            Integer bankId = aliasToBankId.get(name);

            if (bankId == null) {

                // progressively shorter prefixes: "HDFC DEBIT" -> "HDFC"

                for (int cut = name.length(); cut > 2; cut--) {

                    bankId = aliasToBankId.get(name.substring(0, cut).trim());

                    if (bankId != null) {

                        break;

                    }

                }

            }

            if (bankId != null) {

                if (!result.bankIds.contains(bankId)) {

                    result.bankIds.add(bankId);

                }

            } else {

                result.unresolved.add(name);

            }

        }

        return result;

    }

    private static String strip(String s, String chars) {

        int from = 0;

        int to = s.length();

        while (from < to && chars.indexOf(s.charAt(from)) >= 0) { from++; }

        while (to > from && chars.indexOf(s.charAt(to - 1)) >= 0) { to--; }

        return s.substring(from, to);

    }

}