Subversion Repositories SmartDukaan

package com.smartdukaan.cron.offercircular;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Parses the "Offer Description" cell into a value per payment mode.
 *
 * One circular row routinely carries two different values, and even two different
 * calculation types:
 *   "10% cashback up to 2500 on CC EMI & Rs 1500 on CC Full Swipe"
 *     -> CC_EMI        = PERCENT 10% capped at 2500
 *        CC_FULL_SWIPE = FLAT 1500
 * which is exactly why the amount belongs on (offer, mode) and never on the offer.
 */
public final class BenefitParser {

    public static final String CALC_FLAT = "FLAT";
    public static final String CALC_PERCENT = "PERCENT";

    /** Order matters: the compound forms must be tested before the simple ones. */
    private static final Object[][] MODE_PATTERNS = {
        {"CC\\s*/\\s*DC\\s*FULL\\s*SWIPE", new String[]{"CC_FULL_SWIPE", "DC_FULL_SWIPE"}},
        {"CC\\s*/\\s*DC\\s*EMI",           new String[]{"CC_EMI", "DC_EMI"}},
        {"DC\\s*EMI",                      new String[]{"DC_EMI"}},
        {"CC\\s*EMI",                      new String[]{"CC_EMI"}},
        {"CCEMI",                          new String[]{"CC_EMI"}},
        {"DC\\s*FULL\\s*SWIPE",            new String[]{"DC_FULL_SWIPE"}},
        {"CC\\s*FULL\\s*SWIPE",            new String[]{"CC_FULL_SWIPE"}},
        {"CC\\s*REG",                       new String[]{"CC_FULL_SWIPE"}},
        {"FULL\\s*SWIPE",                  new String[]{"CC_FULL_SWIPE"}},
        {"\\bFS\\b",                       new String[]{"CC_FULL_SWIPE"}},
        {"\\bUPI\\b",                      new String[]{"UPI"}},
        {"CARDLESS",                       new String[]{"CARDLESS_EMI"}},
    };

    private static final List<Pattern> MODE_REGEX = new ArrayList<>();
    static {
        for (Object[] row : MODE_PATTERNS) {
            MODE_REGEX.add(Pattern.compile((String) row[0], Pattern.CASE_INSENSITIVE));
        }
    }

    private static final Pattern PERCENT = Pattern.compile("(\\d+(?:\\.\\d+)?)\\s*%");
    private static final Pattern CAP =
            Pattern.compile("(?:up\\s*to|upto)\\s*(?:rs\\.?\\s*)?(\\d[\\d,]*)", Pattern.CASE_INSENSITIVE);
    private static final Pattern FLAT =
            Pattern.compile("(?:rs\\.?\\s*)?(\\d[\\d,]{2,})", Pattern.CASE_INSENSITIVE);
    private static final Pattern EMI_ONLY =
            Pattern.compile("only\\s*nc\\s*emi", Pattern.CASE_INSENSITIVE);

    public static final class Benefit {
        private final String calcType;
        private final BigDecimal flatAmount;
        private final BigDecimal percent;
        private final BigDecimal maxAmount;
        Benefit(String calcType, BigDecimal flatAmount, BigDecimal percent, BigDecimal maxAmount) {
            this.calcType = calcType;
            this.flatAmount = flatAmount;
            this.percent = percent;
            this.maxAmount = maxAmount;
        }
        public String getCalcType() { return calcType; }
        public BigDecimal getFlatAmount() { return flatAmount; }
        public BigDecimal getPercent() { return percent; }
        public BigDecimal getMaxAmount() { return maxAmount; }
        @Override public String toString() {
            return CALC_PERCENT.equals(calcType)
                    ? percent + "%" + (maxAmount == null ? "" : " cap " + maxAmount)
                    : String.valueOf(flatAmount);
        }
    }

    public static final class Result {
        /** payment mode -> value; insertion-ordered */
        private final Map<String, Benefit> benefits = new LinkedHashMap<>();
        private String warning;
        public Map<String, Benefit> getBenefits() { return benefits; }
        public String getWarning() { return warning; }
    }

    private BenefitParser() { }

    private static List<String> findModes(String text) {
        Set<String> ordered = new LinkedHashSet<>();
        for (int i = 0; i < MODE_REGEX.size(); i++) {
            if (MODE_REGEX.get(i).matcher(text).find()) {
                ordered.addAll(Arrays.asList((String[]) MODE_PATTERNS[i][1]));
            }
        }
        return new ArrayList<>(ordered);
    }

    private static BigDecimal num(String raw) {
        return new BigDecimal(raw.replace(",", ""));
    }

    private static Benefit findValue(String text) {
        Matcher pct = PERCENT.matcher(text);
        if (pct.find()) {
            Matcher cap = CAP.matcher(text);
            return new Benefit(CALC_PERCENT, null, new BigDecimal(pct.group(1)),
                    cap.find() ? num(cap.group(1)) : null);
        }
        Matcher flat = FLAT.matcher(text);
        if (flat.find()) {
            return new Benefit(CALC_FLAT, num(flat.group(1)), null, null);
        }
        return null;
    }

    public static Result parse(String cell) {
        Result result = new Result();
        if (cell == null) {
            result.warning = "blank";
            return result;
        }
        String text = cell.trim();
        if (text.isEmpty() || "-".equals(text) || "NA".equals(text) || "N/A".equals(text)) {
            result.warning = "blank";
            return result;
        }
        if (EMI_ONLY.matcher(text).find()) {
            result.warning = "emi-only-no-cashback";
            return result;
        }

        // '&' separates the per-mode clauses: "Rs.4000 on CC EMI & Rs.3000 CC Full Swipe"
        List<Benefit> values = new ArrayList<>();
        List<List<String>> modesPerSegment = new ArrayList<>();
        Benefit carried = null;
        for (String segment : text.split("\\s*&\\s*")) {
            if (segment.trim().isEmpty()) {
                continue;
            }
            Benefit value = findValue(segment);
            if (value == null) {
                value = carried;            // "…& UPI" inherits the preceding amount
            } else {
                carried = value;
            }
            if (value == null) {
                continue;
            }
            List<String> modes = findModes(segment);
            values.add(value);
            modesPerSegment.add(modes.isEmpty() ? null : modes);
        }
        if (values.isEmpty()) {
            result.warning = "no-value-found";
            return result;
        }

        // A clause naming no mode of its own applies to whatever modes the whole cell
        // mentions and no other clause has claimed; ANY when the cell names none.
        List<String> allModes = findModes(text);
        if (allModes.isEmpty()) {
            allModes = new ArrayList<>(Arrays.asList("ANY"));
        }
        Set<String> claimed = new LinkedHashSet<>();
        for (List<String> modes : modesPerSegment) {
            if (modes != null) {
                claimed.addAll(modes);
            }
        }
        for (int i = 0; i < values.size(); i++) {
            List<String> targets = modesPerSegment.get(i);
            if (targets == null) {
                targets = new ArrayList<>();
                for (String mode : allModes) {
                    if (!claimed.contains(mode)) {
                        targets.add(mode);
                    }
                }
                if (targets.isEmpty()) {
                    targets = Arrays.asList("ANY");
                }
            }
            for (String mode : targets) {
                // first clause wins for a given mode
                result.benefits.putIfAbsent(mode, values.get(i));
            }
        }
        return result;
    }
}