Subversion Repositories SmartDukaan

package com.smartdukaan.cron.offercircular;

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Parses the "EMI tenure" cell into (months, scheme) pairs.
 *
 * The scheme marker always FOLLOWS the group of months it applies to, so months are
 * accumulated and flushed each time a marker is seen:
 *   "3,6 NC 9,12,18,24 LC" -> 3/NCE, 6/NCE, 9/LCE, 12/LCE, 18/LCE, 24/LCE
 *
 * Some cells name a payment mode rather than a tenure ("Full Swipe", "UPI", "CIB"
 * alone) and correctly yield nothing.
 */
public final class TenureParser {

    /** Tenures the OEMs actually offer; anything else is reported, not stored. */
    private static final Set<Integer> VALID_MONTHS = new LinkedHashSet<>(
            java.util.Arrays.asList(3, 6, 9, 12, 18, 24));

    private static final Pattern TOKEN = Pattern.compile("\\d+|[A-Z]+");
    private static final Pattern HAS_DIGIT = Pattern.compile("\\d");
    private static final Pattern MODE_ONLY = Pattern.compile("FULL SWIPE|UPI|CIB");

    public static final class Tenure {
        private final int months;
        private final String scheme;
        Tenure(int months, String scheme) { this.months = months; this.scheme = scheme; }
        public int getMonths() { return months; }
        public String getScheme() { return scheme; }
        @Override public boolean equals(Object o) {
            if (!(o instanceof Tenure)) { return false; }
            Tenure t = (Tenure) o;
            return months == t.months && scheme.equals(t.scheme);
        }
        @Override public int hashCode() { return months * 31 + scheme.hashCode(); }
        @Override public String toString() { return months + ":" + scheme; }
    }

    public static final class Result {
        private final List<Tenure> tenures = new ArrayList<>();
        private String warning;
        public List<Tenure> getTenures() { return tenures; }
        public String getWarning() { return warning; }
    }

    private TenureParser() { }

    private static String scheme(String token) {
        switch (token) {
            case "NCE": case "NC": return "NCE";
            case "LCE": case "LC": return "LCE";
            case "CIB":            return "CIB";
            default:               return null;
        }
    }

    public static Result parse(String cell) {
        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;
        }
        // PDF line-wrap artefacts: "(L CE)" and "1 8" (meaning 18) are one token split
        // across a line break and rejoined with a space.
        text = text.replaceAll("(?i)\\bL\\s+CE\\b", "LCE")
                   .replaceAll("(?i)\\bN\\s+CE\\b", "NCE")
                   .replaceAll("(?<=\\d)\\s+(?=\\d)", "");
        String upper = text.toUpperCase();

        if (!HAS_DIGIT.matcher(upper).find()) {
            result.warning = MODE_ONLY.matcher(upper).find() ? "mode-only" : "no-digits";
            return result;
        }

        List<Integer> pending = new ArrayList<>();
        List<Integer> rejected = new ArrayList<>();
        Set<Tenure> collected = new LinkedHashSet<>();

        Matcher m = TOKEN.matcher(upper);
        while (m.find()) {
            String token = m.group();
            if (Character.isDigit(token.charAt(0))) {
                pending.add(Integer.parseInt(token));
                continue;
            }
            String scheme = scheme(token);
            if (scheme != null) {
                flush(pending, scheme, collected, rejected);
            } else if ("M".equals(token)) {
                flush(pending, "NONE", collected, rejected);
            }
        }
        // trailing months with no marker: CIB if the cell mentions it, else unscheme
        if (!pending.isEmpty()) {
            flush(pending, upper.contains("CIB") ? "CIB" : "NONE", collected, rejected);
        }

        result.tenures.addAll(collected);
        result.tenures.sort((a, b) -> a.months != b.months
                ? Integer.compare(a.months, b.months)
                : a.scheme.compareTo(b.scheme));
        if (!rejected.isEmpty()) {
            result.warning = "bad-tenure:" + rejected;
        }
        return result;
    }

    private static void flush(List<Integer> pending, String scheme,
                              Set<Tenure> collected, List<Integer> rejected) {
        for (Integer months : pending) {
            if (VALID_MONTHS.contains(months)) {
                collected.add(new Tenure(months, scheme));
            } else {
                rejected.add(months);
            }
        }
        pending.clear();
    }
}