Subversion Repositories SmartDukaan

/**
 * 
 */
package in.shop2020.util;

import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.definitions.CMPBucketDefinition;
import in.shop2020.metamodel.definitions.Catalog;
import in.shop2020.metamodel.definitions.Category;
import in.shop2020.metamodel.definitions.DefinitionsContainer;
import in.shop2020.metamodel.util.CreationUtils;
import in.shop2020.metamodel.util.ExpandedCMPSlideRuleDefinition;
import in.shop2020.metamodel.util.ExpandedEntity;
import in.shop2020.metamodel.util.ExpandedSlide;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * @author naveen
 *
 */
public class NewCMP {
        
        /**
         * 
         */
        //private long categoryID;

        List<Entity> entities;
        
        
        /**
         * @param args
         * @throws Exception 
         */
        public static void main(String[] args) throws Exception {
                String usage = "Usage: CMP {Category ID}";
                
                if(args.length > 1) {
                        System.out.println(usage);
                        System.exit(-1);
                }
        }
        
        /**
         * 
         * @param entityIdItemMap
         */
        public NewCMP(List<Entity> entities) {
            this.entities = entities;
        }
        
        /**
         * 
         * @return Map<Long, Map<Long, Double>>
         * @throws Exception 
         */
        public Map<Long, Map<Long, Double>> getSlideScores() throws Exception {
                Map<Long, Map<Long, Double>> slideScoresByEntityID = 
                        new TreeMap<Long, Map<Long, Double>>();
                
                for(Entity entity : entities) {
                        // Skip categories with value as -1 or categories except mobile phones and tablets
                        long categoryId = entity.getCategoryID();
                        if(categoryId == -1){
                                continue;
                        }
                        Category category = Catalog.getInstance().getDefinitionsContainer().getCategory(categoryId);
                        
            if(category.isComparable()) {
                ExpandedEntity expEntity = new ExpandedEntity(entity);

                Map<Long, Double> slideScores = this.getSlideScores(expEntity, true);
                slideScoresByEntityID.put(entity.getID(), slideScores);
                        }
                }
                
                return slideScoresByEntityID;
        }

        public Map<Long, Map<Long, Double>> getSlideScores(int dummy) throws Exception {
                Map<Long, Map<Long, Double>> slideScoresByEntityID = 
                        new TreeMap<Long, Map<Long, Double>>();
                
                for(Entity entity : entities) {
                        // Skip categories with value as -1 or categories except mobile phones and tablets
                        long categoryId = entity.getCategoryID();
                        if(categoryId == -1){
                                continue;
                        }
                        ExpandedEntity expEntity = new ExpandedEntity(entity);
                        
                        Map<Long, Double> slideScores = this.getSlideScores(expEntity, false);
                        slideScoresByEntityID.put(entity.getID(), slideScores);
                }
                
                return slideScoresByEntityID;
        }
        
        /**
         * 
         * @param entity
         * @return Map<Long, Double>
         * @throws Exception 
         */
        private Map<Long, Double> getSlideScores(ExpandedEntity expEntity, boolean isCustomized) throws Exception {
                Map<Long, Double> slideScores = new HashMap<Long, Double>();
                
                DefinitionsContainer defs = 
                        Catalog.getInstance().getDefinitionsContainer();
                
                // Python wrapper for executing rule in python script
                CMPJythonWrapper cmpJW = new CMPJythonWrapper();
                Map<Long, Double> customScores = CreationUtils.getCustomSlideComparisonScores(expEntity.getID());
                
                // Scores are required for parent slides only
                List<ExpandedSlide> expSlides = expEntity.getExpandedSlides();
                if(expSlides==null){
                        return slideScores;
                }
                if (customScores==null) {
                        isCustomized = false;
                }
                for(ExpandedSlide expSlide : expSlides) {
                        long slideDefinitionID = expSlide.getSlideDefinitionID();
                        
                        if(isCustomized && customScores.containsKey(slideDefinitionID)){
                                slideScores.put(slideDefinitionID, customScores.get(slideDefinitionID));
                                continue;
                        }
                        cmpJW.reset();
                        cmpJW.initialize();
                        
                        cmpJW.setExpandedSlide(expSlide);
                        cmpJW.setCategory(expEntity.getCategory());
                        
                        ExpandedCMPSlideRuleDefinition expCMPSlideRuleDef = 
                                defs.getExpandedComparisonSlideRuleDefinition(
                                                slideDefinitionID);
                        
                        if(expCMPSlideRuleDef == null) {
                                Utils.warning("Could not find comparison definition for " + 
                                                "slide definition ID " + slideDefinitionID);
                                continue;
                        }
                        
                        cmpJW.setExpandedCMPSlideRuleDefinition(expCMPSlideRuleDef);
                        
                        cmpJW.executeRule();
                        
                        double score = cmpJW.getScore();
                        Utils.info("score=" + score);
                        
                        slideScores.put(new Long(slideDefinitionID), new Double(score));
                }
                
                return slideScores;
        }
        
        /**
         * 
         * @param slideScoresByEntity
         * @return Map<Long, Double>
         * @throws Exception 
         */
        public Map<Long, Double> getFinalScores(
                        Map<Long, Map<Long, Double>> slideScoresByEntity) throws Exception {
                Map<Long, Double> finalScoreByEntityID = new TreeMap<Long, Double>();
                
                // Considering default Weights per Slide bucket
                // Slide buckets > List(Very Important, Regular, Not-so-Important)
                // Default Weights > List(70%, 20%, 10%)
                DefinitionsContainer defs = 
                        Catalog.getInstance().getDefinitionsContainer();
                
                for(Long entityID : slideScoresByEntity.keySet()) {
                        Map<Long, Double> slideScores = slideScoresByEntity.get(entityID);
                        
                        Entity entity = CreationUtils.getEntity(entityID);
                        long categoryID = entity.getCategoryID();
                        if(categoryID == -1){
                                continue;
                        }
                        if(categoryID>10010){
                                continue;
                        }
                        
                        List<CMPBucketDefinition> bucketDefs = 
                                defs.getComparisonBucketDefinitions(categoryID);
                        
                        Map<String, Double> bucketScores = new HashMap<String, Double>();
                        Map<String, Double> bucketSlideCounts = 
                                new HashMap<String, Double>();
                        
                        for(Long slideDefinitionID : slideScores.keySet()) {
                                Double slideScore = slideScores.get(slideDefinitionID);
                                
                                String bucketName = null;
                                
                                bucketName = defs.getComparisonBucketName(categoryID, slideDefinitionID.longValue());
                                
                                if(bucketName == null) {
                                        Utils.warning("Comparison bucket not defined for " +
                                                        "Category ID=" + categoryID + 
                                                        " Slide Definition ID=" + slideDefinitionID);
                                        
                                        continue;
                                }

                                if(!bucketScores.containsKey(bucketName)) {
                                        bucketScores.put(bucketName, new Double(0));
                                }
                                
                                if(!bucketSlideCounts.containsKey(bucketName)) {
                                        bucketSlideCounts.put(bucketName, new Double(0));
                                }
                                
                                Double bucketScore = bucketScores.get(bucketName);
                                Double bucketSlideCount = bucketSlideCounts.get(bucketName);
                                
                                
                                Double newBucketScore =  new Double(
                                                bucketScore.intValue() + slideScore.intValue());
                                
                                Double newBucketSlideCount =  new Double(
                                                bucketSlideCount.intValue() + 1);
                                
                                bucketScores.put(bucketName, newBucketScore);
                                bucketSlideCounts.put(bucketName, newBucketSlideCount);
                        }
                        
                        int finalEntityScore = 0;
                        
                        // Apply weights and sum up
                        for(CMPBucketDefinition bucketDef : bucketDefs) {
                                String bucketName = bucketDef.getName();
                                Utils.info("bucketName=" + bucketName);
                                
                                if(bucketScores.get(bucketName)==null){
                                        continue;
                                }
                                double aggregateBucketScore = bucketScores.get(bucketName);
                                Utils.info("aggregateBucketScore=" + aggregateBucketScore);
                                
                                double bucketSlideCount = bucketSlideCounts.get(bucketName);
                                Utils.info("bucketSlideCount=" + bucketSlideCount);
                                
                                double defaultWeight = bucketDef.getDefaultWeight();
                                Utils.info("defaultWeight=" + defaultWeight);
                                
                                float percentageBucketScore = 
                                        (((float)aggregateBucketScore/
                                                        ((float)bucketSlideCount * 10))) * 100;
                                
                                Utils.info("percentageBucketScore=" + percentageBucketScore);
                                
                                float weightedBucketScore = 
                                        (float)percentageBucketScore * ((float)defaultWeight / 100);
                                Utils.info("weightedBucketScore=" + weightedBucketScore);
                                
                                finalEntityScore += Math.round(weightedBucketScore);
                        }
                        Utils.info("finalEntityScore=" + finalEntityScore);
                        
                        finalScoreByEntityID.put(entityID, new Double(finalEntityScore));
                }
                
                return finalScoreByEntityID;
        }
}