Subversion Repositories SmartDukaan

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

import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.Slide;
import in.shop2020.metamodel.definitions.Catalog;
import in.shop2020.metamodel.definitions.DefinitionsContainer;
import in.shop2020.metamodel.definitions.EntityContainer;
import in.shop2020.metamodel.util.ExpandedCMPSlideRuleDefinition;
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 CMP {
        
        /**
         * 
         */
        private long categoryID;

        /**
         * @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);
                }

                long categoryID = 0L;
                if(args.length > 0) {
                        try {
                                categoryID = Long.parseLong(args[0]);
                        }
                        catch (NumberFormatException nfe) {
                                System.out.println(usage);
                                System.exit(-1);
                        }
                }
                
                CMP cmp = new CMP(categoryID);
                
                // Entity ID > List(Slide ID > Score)
                Map<Long, Map<Long, Integer>> slideScoresByEntity = 
                        cmp.getSlideScores();
                
                String dbFile = Utils.COMPARISONS_DB_PATH + "slidescores.ser";
                DBUtils.store(slideScoresByEntity, dbFile);
                
                // Entity ID > Final Score 
                Map<Long, Integer> finalScoreByEntityID = cmp.getFinalScores(
                                slideScoresByEntity);
                
                dbFile = Utils.COMPARISONS_DB_PATH + "defaultentityscores.ser";
                DBUtils.store(finalScoreByEntityID, dbFile);
        }
        
        /**
         * 
         * @param categoryID
         */
        public CMP(long categoryID) {
                this.categoryID = categoryID;
        }
        
        /**
         * 
         * @return Map<Long, Map<Long, Integer>>
         * @throws Exception 
         */
        private Map<Long, Map<Long, Integer>> getSlideScores() throws Exception {
                Map<Long, Map<Long, Integer>> slideScoresByEntityID = 
                        new TreeMap<Long, Map<Long, Integer>>();
                
                // Calculate scores based on rule
                EntityContainer ents = 
                        Catalog.getInstance().getEntityContainer();
                
                Map<Long, Entity> entitiesMap = ents.getEntities();
        
                for(Long entityID : entitiesMap.keySet()) {
                        Entity entity = entitiesMap.get(entityID);
                        
                        // If provided, filter by category
                        if(this.categoryID != 0L && 
                                        (this.categoryID != entity.getCategoryID())) {
                                continue;
                        }
                        
                        Map<Long, Integer> slideScores = this.getSlideScores(entity);
                        
                        slideScoresByEntityID.put(entityID, slideScores);
                }
                
                return slideScoresByEntityID;
        }
        
        /**
         * 
         * @param entity
         * @return Map<Long, Integer>
         * @throws Exception 
         */
        private Map<Long, Integer> getSlideScores(Entity entity) throws Exception {
                Map<Long, Integer> slideScores = new HashMap<Long, Integer>();
                
                DefinitionsContainer defs = 
                        Catalog.getInstance().getDefinitionsContainer();
                
                // Python wrapper for executing rule in python script
                CMPJythonWrapper cmpJW = new CMPJythonWrapper();
                
                // Scores are required for parent slides only
                List<Slide> slides = entity.getSlides();
                for(Slide slide : slides) {
                        ExpandedSlide expSlide = new ExpandedSlide(slide);
                        cmpJW.setExpandedSlide(expSlide);
                        
                        long slideDefinitionID = slide.getSlideDefinitionID();
                        ExpandedCMPSlideRuleDefinition expCMPSlideRuleDef = 
                                defs.getExpandedComparisonSlideRuleDefinition(
                                                slideDefinitionID);
                        
                        cmpJW.setExpandedCMPSlideRuleDefinition(expCMPSlideRuleDef);
                        
                        cmpJW.execCMPRule();
                        
                        int score = cmpJW.getScore();
                        Utils.info("score=" + score);
                        
                        slideScores.put(new Long(slideDefinitionID), new Integer(score));
                }
                
                return slideScores;
        }
        
        /**
         * 
         * @param slideScoresByEntity
         * @return Map<Long, Integer>
         */
        private Map<Long, Integer> getFinalScores(
                        Map<Long, Map<Long, Integer>> slideScoresByEntity) {
                Map<Long, Integer> finalScoreByEntityID = new TreeMap<Long, Integer>();
                
                // Considering default Weights per Slide bucket
                // Slide buckets > List(Very Important, Regular, Not-so-Important)
                // Default Weights > List(70%, 20%, 10%)
                
                // TODO
                
                return finalScoreByEntityID;
        }
}