Subversion Repositories SmartDukaan

package com.smartdukaan.cron.offercircular;

import java.util.ArrayList;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.regex.Pattern;

import com.spice.profitmandi.dao.repository.offers.CircularIngestRepository;

/**

 * Which divisions and products are in scope. Read from offers.oem_division and

 * offers.scope_rule - this is editable configuration, never constants in code, so

 * changing scope is a data change.

 *

 * A label with no division row is reported as UNKNOWN rather than silently skipped,

 * so a new OEM division in next month's circular is visible immediately.

 */

public final class ScopeConfig {

    private static final String INCLUDE_ONLY = "INCLUDE_ONLY";

    private static final String EXCLUDE = "EXCLUDE";

    private static final class Division {

        final boolean inScope;

        final int categoryId;

        Division(boolean inScope, int categoryId) {

            this.inScope = inScope;

            this.categoryId = categoryId;

        }

    }

    private static final class Rule {

        final String type;

        final Pattern pattern;

        Rule(String type, Pattern pattern) { this.type = type; this.pattern = pattern; }

    }

    /** Outcome for one row, carrying the brand/category to match products against. */

    public static final class Decision {

        private final boolean keep;

        private final String reason;

        private final String brand;

        private final int categoryId;

        private final List<Pattern> includeOnly;

        private Decision(boolean keep, String reason, String brand, int categoryId,

                         List<Pattern> includeOnly) {

            this.keep = keep;

            this.reason = reason;

            this.brand = brand;

            this.categoryId = categoryId;

            this.includeOnly = includeOnly;

        }

        public boolean isKeep() { return keep; }

        public String getReason() { return reason; }

        public String getBrand() { return brand; }

        public int getCategoryId() { return categoryId; }

        /** Drops entities that no INCLUDE_ONLY rule accepts (Apple -> iPhone only). */

        public List<String> filterEntities(List<String> entities) {

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

                return entities;

            }

            List<String> kept = new ArrayList<>();

            for (String entity : entities) {

                for (Pattern p : includeOnly) {

                    if (p.matcher(entity).find()) {

                        kept.add(entity);

                        break;

                    }

                }

            }

            return kept;

        }

    }

    private final Map<String, Division> divisions = new LinkedHashMap<>();

    private final Map<String, List<Rule>> rules = new LinkedHashMap<>();

    private final Map<String, String> brandByLabel = new LinkedHashMap<>();

    private ScopeConfig() { }

    public static ScopeConfig load(CircularIngestRepository repository) {

        ScopeConfig config = new ScopeConfig();

        for (Object[] row : repository.selectDivisions()) {

            String label = (String) row[0];

            boolean inScope = isTrue(row[1]);

            int categoryId = ((Number) row[2]).intValue();

            config.divisions.put(label, new Division(inScope, categoryId));

            String brand = row.length > 3 && row[3] != null ? (String) row[3] : "";

            if (!brand.isEmpty()) {

                config.brandByLabel.put(label, brand);

            }

        }

        for (Object[] row : repository.selectScopeRules()) {

            String label = row[0] == null ? "" : (String) row[0];

            config.rules.computeIfAbsent(label, k -> new ArrayList<>())

                    .add(new Rule((String) row[1],

                            Pattern.compile((String) row[2], Pattern.CASE_INSENSITIVE)));

        }

        return config;

    }

    /**

     * in_scope is TINYINT(1), which MySQL Connector/J maps to Boolean while Hibernate

     * may hand back a Number. Accept either rather than depend on driver settings.

     */

    private static boolean isTrue(Object value) {

        if (value instanceof Boolean) {

            return (Boolean) value;

        }

        if (value instanceof Number) {

            return ((Number) value).intValue() == 1;

        }

        return value != null && "1".equals(value.toString());

    }

    public Decision evaluate(String label, String products) {

        Division division = divisions.get(label);

        if (division == null) {

            return new Decision(false, "UNKNOWN division label: " + label, null, 0, null);

        }

        if (!division.inScope) {

            return new Decision(false, "out of scope by config: " + label, null, 0, null);

        }

        String haystack = products == null ? "" : products;

        List<Pattern> includeOnly = new ArrayList<>();

        // division-specific rules first, then global ones (label "")

        for (String scope : new String[]{label, ""}) {

            List<Rule> scoped = rules.get(scope);

            if (scoped == null) {

                continue;

            }

            for (Rule rule : scoped) {

                if (EXCLUDE.equals(rule.type) && rule.pattern.matcher(haystack).find()) {

                    return new Decision(false,

                            "EXCLUDE rule /" + rule.pattern.pattern() + "/ on "

                                    + (scope.isEmpty() ? "all" : scope), null, 0, null);

                }

            }

            List<Pattern> includes = new ArrayList<>();

            for (Rule rule : scoped) {

                if (INCLUDE_ONLY.equals(rule.type)) {

                    includes.add(rule.pattern);

                }

            }

            if (!includes.isEmpty()) {

                boolean any = false;

                for (Pattern p : includes) {

                    if (p.matcher(haystack).find()) {

                        any = true;

                        break;

                    }

                }

                if (!any) {

                    return new Decision(false, "no INCLUDE_ONLY rule matched on " + label,

                            null, 0, null);

                }

                includeOnly.addAll(includes);

            }

        }

        String brand = brandByLabel.get(label);

        return new Decision(true, null, brand == null ? label.split(" ")[0] : brand,

                division.categoryId, includeOnly);

    }

}