Subversion Repositories SmartDukaan

/**

 * 

 */

package in.shop2020.util;

import in.shop2020.metamodel.core.Entity;

import in.shop2020.metamodel.core.Slide;

import in.shop2020.metamodel.definitions.CMPBucketDefinition;

import in.shop2020.metamodel.definitions.Catalog;

import in.shop2020.metamodel.definitions.DefinitionsContainer;

import in.shop2020.metamodel.util.CreationUtils;

import in.shop2020.metamodel.util.ExpandedCMPSlideRuleDefinition;

import in.shop2020.metamodel.util.ExpandedSlide;

import java.io.File;

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 > Map(Slide ID > Score)

		Map<Long, Map<Long, Integer>> slideScoresByEntity = 

			cmp.getSlideScores();

		Utils.info("slideScoresByEntity=" + slideScoresByEntity);

		CreationUtils.storeSlideScores(slideScoresByEntity);

		// Entity ID > Final Score 

		Map<Long, Integer> finalScoreByEntityID = cmp.getFinalScores(

				slideScoresByEntity);

		Utils.info("finalScoreByEntityID=" + finalScoreByEntityID);

		CreationUtils.storeDefaultEntityScores(finalScoreByEntityID);

	}

	/**

	 * 

	 * @param categoryID

	 */

	public CMP(long categoryID) {

		this.categoryID = categoryID;

	}

	/**

	 * 

	 * @return Map<Long, Map<Long, Integer>>

	 * @throws Exception 

	 */

	public 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

		Map<Long, Entity> entitiesMap = CreationUtils.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();

		if(slides==null){

			return slideScores;

		}

		for(Slide slide : slides) {

			ExpandedSlide expSlide = new ExpandedSlide(slide);

			cmpJW.reset();

			cmpJW.initialize();

			cmpJW.setExpandedSlide(expSlide);

			long slideDefinitionID = slide.getSlideDefinitionID();

			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();

			int score = cmpJW.getScore();

			Utils.info("score=" + score);

			slideScores.put(new Long(slideDefinitionID), new Integer(score));

		}

		return slideScores;

	}

	/**

	 * 

	 * @param slideScoresByEntity

	 * @return Map<Long, Integer>

	 * @throws Exception 

	 */

	public Map<Long, Integer> getFinalScores(

			Map<Long, Map<Long, Integer>> slideScoresByEntity) throws Exception {

		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%)

		DefinitionsContainer defs = 

			Catalog.getInstance().getDefinitionsContainer();

		for(Long entityID : slideScoresByEntity.keySet()) {

			Map<Long, Integer> 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, Integer> bucketScores = new HashMap<String, Integer>();

			Map<String, Integer> bucketSlideCounts = 

				new HashMap<String, Integer>();

			for(Long slideDefinitionID : slideScores.keySet()) {

				Integer slideScore = slideScores.get(slideDefinitionID);

				Slide slide = CreationUtils.getSlide(entityID, slideDefinitionID);

				String bucketName = null;

				if(CreationUtils.isBorrowedSlide(slide.getSlideDefinitionID(), entity.getCategoryID())) {

					long borrowedCategoryID = CreationUtils.getBorrowedCategoryID(slide.getSlideDefinitionID(), entity.getCategoryID());

					bucketName = defs.getComparisonBucketName(borrowedCategoryID, slideDefinitionID.longValue());

				}

				else {

					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 Integer(0));

				}

				if(!bucketSlideCounts.containsKey(bucketName)) {

					bucketSlideCounts.put(bucketName, new Integer(0));

				}

				Integer bucketScore = bucketScores.get(bucketName);

				Integer bucketSlideCount = bucketSlideCounts.get(bucketName);

				Integer newBucketScore =  new Integer(

						bucketScore.intValue() + slideScore.intValue());

				Integer newBucketSlideCount =  new Integer(

						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;

				}

				int aggregateBucketScore = bucketScores.get(bucketName);

				Utils.info("aggregateBucketScore=" + aggregateBucketScore);

				int bucketSlideCount = bucketSlideCounts.get(bucketName);

				Utils.info("bucketSlideCount=" + bucketSlideCount);

				int 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 Integer(finalEntityScore));

		}

		return finalScoreByEntityID;

	}

}