Subversion Repositories SmartDukaan

package com.smartdukaan.cron.offercircular;

import java.math.BigDecimal;

import java.math.RoundingMode;

import java.util.ArrayList;

import java.util.List;

import java.util.Set;

/**

 * Resolves one product name from the circular to a catalog row.

 *

 * Resolution is strictly BRAND -> CATEGORY -> MODEL -> VARIANT. The candidate list is

 * supplied already scoped to (brand, category) and there is deliberately NO fallback

 * to a wider pool: allowing one previously matched "OnePlus Pad 4" to a OnePlus

 * phone, and "Infinix Note Edge" to Samsung's 2014 Galaxy Note Edge.

 *

 * A fuzzy hit is never auto-committed. Similarity ranks wrong matches above right

 * ones whenever models differ by a single token - "iPhone 17e" scores 0.89 against

 * "iPhone 7" - so anything not resolved by exact model key becomes REVIEW for a human.

 */

public final class ProductMatcher {

    /** Below this similarity there is no plausible suggestion at all. */

    private static final double REVIEW_THRESHOLD = 0.75;

    public static final String LEVEL_VARIANT = "VARIANT";

    public static final String LEVEL_MODEL = "MODEL";

    public static final String LEVEL_UNRESOLVED = "UNRESOLVED";

    public static final String STATUS_AUTO_EXACT = "AUTO_EXACT";

    public static final String STATUS_AUTO_MODEL = "AUTO_MODEL";

    public static final String STATUS_REVIEW = "REVIEW";

    public static final String STATUS_CATALOG_GAP = "CATALOG_GAP";

    /** A catalog row eligible for matching, pre-scoped to one (brand, category). */

    public static final class Candidate {

        private final int catalogId;

        private final String displayName;

        private final Integer superCatalogId;

        public Candidate(int catalogId, String displayName, Integer superCatalogId) {

            this.catalogId = catalogId;

            this.displayName = displayName;

            this.superCatalogId = superCatalogId;

        }

        public int getCatalogId() { return catalogId; }

        public String getDisplayName() { return displayName; }

        public Integer getSuperCatalogId() { return superCatalogId; }

    }

    public static final class Match {

        private final String matchLevel;

        private final Integer catalogId;

        private final Integer superCatalogId;

        private final String matchStatus;

        private final BigDecimal matchScore;

        Match(String matchLevel, Integer catalogId, Integer superCatalogId,

              String matchStatus, BigDecimal matchScore) {

            this.matchLevel = matchLevel;

            this.catalogId = catalogId;

            this.superCatalogId = superCatalogId;

            this.matchStatus = matchStatus;

            this.matchScore = matchScore;

        }

        public String getMatchLevel() { return matchLevel; }

        public Integer getCatalogId() { return catalogId; }

        public Integer getSuperCatalogId() { return superCatalogId; }

        public String getMatchStatus() { return matchStatus; }

        public BigDecimal getMatchScore() { return matchScore; }

        @Override public String toString() {

            return matchStatus + "/" + matchLevel + " -> " + catalogId

                    + (matchScore == null ? "" : " (" + matchScore + ")");

        }

    }

    private ProductMatcher() { }

    /** Treats 0 as "no super catalog", matching the reference implementation. */

    private static Integer superCatalogOrNull(Candidate candidate) {

        Integer id = candidate.getSuperCatalogId();

        return (id == null || id == 0) ? null : id;

    }

    /**

     * The rule: **if the circular states memory, the offer is variant-specific; if it

     * does not, the offer covers every variant of that model.**

     *

     * So this returns a LIST. A model named without memory fans out to one match per

     * sibling variant, because storing a single arbitrary sibling means a lookup for

     * any other size finds no offer at all - a partner selling the 512 GB of a phone

     * whose 256 GB was stored would see no cashback.

     */

    public static List<Match> matchAll(String rawText, List<Candidate> candidates) {

        List<Match> matches = new ArrayList<>();

        if (candidates == null || candidates.isEmpty()) {

            matches.add(new Match(LEVEL_UNRESOLVED, null, null, STATUS_CATALOG_GAP, null));

            return matches;

        }

        String wantKey = ProductNames.modelKey(rawText);

        Set<String> wantMemory = ProductNames.variantTokens(rawText);

        List<Candidate> sameModel = new ArrayList<>();

        if (!wantKey.isEmpty()) {

            for (Candidate candidate : candidates) {

                if (wantKey.equals(ProductNames.modelKey(candidate.getDisplayName()))) {

                    sameModel.add(candidate);

                }

            }

        }

        if (!sameModel.isEmpty()) {

            if (!wantMemory.isEmpty()) {

                // memory stated -> exactly this variant

                for (Candidate candidate : sameModel) {

                    if (wantMemory.equals(ProductNames.variantTokens(candidate.getDisplayName()))) {

                        matches.add(new Match(LEVEL_VARIANT, candidate.getCatalogId(),

                                superCatalogOrNull(candidate), STATUS_AUTO_EXACT,

                                BigDecimal.valueOf(1.0)));

                        return matches;

                    }

                }

                // right model, but the catalog does not carry the stated size

                Candidate first = sameModel.get(0);

                matches.add(new Match(LEVEL_MODEL, first.getCatalogId(),

                        superCatalogOrNull(first), STATUS_REVIEW, BigDecimal.valueOf(0.9)));

                return matches;

            }

            // no memory stated -> every variant of this model is covered

            for (Candidate candidate : sameModel) {

                matches.add(new Match(LEVEL_MODEL, candidate.getCatalogId(),

                        superCatalogOrNull(candidate),

                        sameModel.size() == 1 ? STATUS_AUTO_EXACT : STATUS_AUTO_MODEL,

                        BigDecimal.valueOf(sameModel.size() == 1 ? 1.0 : 0.95)));

            }

            return matches;

        }

        matches.add(match(rawText, candidates));   // fuzzy fallback, never fanned out

        return matches;

    }

    public static Match match(String rawText, List<Candidate> candidates) {

        if (candidates == null || candidates.isEmpty()) {

            return new Match(LEVEL_UNRESOLVED, null, null, STATUS_CATALOG_GAP, null);

        }

        String wantKey = ProductNames.modelKey(rawText);

        Set<String> wantVariant = ProductNames.variantTokens(rawText);

        List<Candidate> sameModel = new ArrayList<>();

        if (!wantKey.isEmpty()) {

            for (Candidate candidate : candidates) {

                if (wantKey.equals(ProductNames.modelKey(candidate.getDisplayName()))) {

                    sameModel.add(candidate);

                }

            }

        }

        if (!sameModel.isEmpty()) {

            if (!wantVariant.isEmpty()) {

                for (Candidate candidate : sameModel) {

                    if (wantVariant.equals(ProductNames.variantTokens(candidate.getDisplayName()))) {

                        return new Match(LEVEL_VARIANT, candidate.getCatalogId(),

                                superCatalogOrNull(candidate), STATUS_AUTO_EXACT,

                                BigDecimal.valueOf(1.0));

                    }

                }

                // right model, but the catalog does not carry the size the circular

                // names - a human decides whether to stock it or ignore the offer

                Candidate first = sameModel.get(0);

                return new Match(LEVEL_MODEL, first.getCatalogId(), superCatalogOrNull(first),

                        STATUS_REVIEW, BigDecimal.valueOf(0.9));

            }

            Candidate first = sameModel.get(0);

            if (sameModel.size() == 1) {

                return new Match(LEVEL_VARIANT, first.getCatalogId(), superCatalogOrNull(first),

                        STATUS_AUTO_EXACT, BigDecimal.valueOf(1.0));

            }

            // circular named a model with no size, so the offer covers every variant

            return new Match(LEVEL_MODEL, first.getCatalogId(), superCatalogOrNull(first),

                    STATUS_AUTO_MODEL, BigDecimal.valueOf(0.95));

        }

        Candidate best = null;

        double bestScore = 0.0;

        String normalisedRaw = ProductNames.norm(rawText);

        for (Candidate candidate : candidates) {

            double score = SequenceRatio.ratio(normalisedRaw,

                    ProductNames.norm(candidate.getDisplayName()));

            if (score > bestScore) {

                bestScore = score;

                best = candidate;

            }

        }

        if (best != null && bestScore >= REVIEW_THRESHOLD) {

            return new Match(LEVEL_MODEL, best.getCatalogId(), superCatalogOrNull(best),

                    STATUS_REVIEW, round3(bestScore));

        }

        return new Match(LEVEL_UNRESOLVED, null, null, STATUS_CATALOG_GAP,

                best == null ? null : round3(bestScore));

    }

    private static BigDecimal round3(double value) {

        return BigDecimal.valueOf(value).setScale(3, RoundingMode.HALF_EVEN);

    }

}