Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.pricing;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.apache.commons.collections.CollectionUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.MopPriceModel;

import com.spice.profitmandi.common.model.ProfitMandiConstants;

import com.spice.profitmandi.dao.entity.catalog.TagListing;

import com.spice.profitmandi.dao.entity.dtr.GadgetCopsInsuranceCalc;

import com.spice.profitmandi.dao.entity.fofo.InventoryItem;

import com.spice.profitmandi.dao.entity.user.Address;

import com.spice.profitmandi.dao.repository.catalog.PinCodeTagRepository;

import com.spice.profitmandi.dao.repository.catalog.RetailerTagRepository;

import com.spice.profitmandi.dao.repository.catalog.TagListingRepository;

import com.spice.profitmandi.dao.repository.dtr.GadgetCopsInsuranceCalcRepository;

import com.spice.profitmandi.dao.repository.dtr.InsuranceProviderRepository;

import com.spice.profitmandi.dao.repository.dtr.RetailerRegisteredAddressRepository;

import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.service.tag.TagService;

@Component

public class PricingServiceImpl implements PricingService{

	@Autowired

	RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

	@Autowired

	AddressRepository addressRepository;

	@Autowired

	PinCodeTagRepository pinCodeTagRepository;

	@Autowired

	TagService tagService;

	@Autowired

	RetailerTagRepository retailerTagRepository;

	@Autowired

	TagListingRepository tagListingRepository;

	@Autowired

	InsuranceProviderRepository insuranceProviderRepository;

	@Autowired

	GadgetCopsInsuranceCalcRepository gadgetCopsInsuranceCalcRepository;

	@Autowired

	InventoryItemRepository inventoryItemRepository;

	private static final Logger LOGGER = LoggerFactory.getLogger(PricingServiceImpl.class);

	@Override

	public Map<Integer, Float> getPrices(Set<Integer> itemIds, int retailerId) {

		return getMopOrSellingPrice(itemIds, retailerId, false);

	}

	private Map<Integer, Float> preparePriceDefaultValues(Set<Integer> itemIds){

		Map<Integer, Float> itemIdPrice = new HashMap<>(itemIds.size());

		for(int itemId : itemIds){

			itemIdPrice.put(itemId, Float.MAX_VALUE);

		}

		return itemIdPrice;

	}

	@SuppressWarnings("unchecked")

	public Map<Integer, Float> getMopOrSellingPrice(Set<Integer> itemIds, int retailerId, boolean mop){

		Map<Integer, Float> itemIdPrice = this.preparePriceDefaultValues(itemIds);

		int addressId;

		try {

			addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailerId);

			Address retailerAddress = addressRepository.selectById(addressId);

			Set<Integer> pinCodeTagIds = tagService.getFofoTagIdsByPinCode(retailerAddress.getPinCode());

			Set<Integer> pinNegativeTagIds = tagService.getPinCodeNegativeTagIds();

			Set<Integer> pinCodeIntersection = new HashSet<>(CollectionUtils.intersection(pinCodeTagIds, pinNegativeTagIds));

			Set<Integer> filterPinCodeTagIds = new HashSet<>(CollectionUtils.subtract(pinNegativeTagIds, pinCodeIntersection));

			Set<Integer> pinPositiveTagIds = tagService.getPinCodePositiveTagIds();

			filterPinCodeTagIds.addAll(pinPositiveTagIds);

			if(filterPinCodeTagIds.isEmpty()){

				return itemIdPrice;

			}

			Set<Integer> retailerTagIds = tagService.getUserTagIdsByTagIds(filterPinCodeTagIds);

			Set<Integer> userNegativeTagIds = tagService.getUserNegativeTagIds();

			Set<Integer> userIntersection = new HashSet<>(CollectionUtils.intersection(retailerTagIds, userNegativeTagIds));

			Set<Integer> filterUserTagIds = new HashSet<>(CollectionUtils.subtract(userNegativeTagIds, userIntersection));

			Set<Integer> userPositiveTagIds = tagService.getUserPositiveTagIds();

			filterUserTagIds.addAll(userPositiveTagIds);

			if(filterUserTagIds.isEmpty()){

				return itemIdPrice;

			}

			List<TagListing> tagListings = tagListingRepository.selectByItemIdsAndTagIds(itemIds, filterUserTagIds);

			if(tagListings.isEmpty()){

				return itemIdPrice;

			}

			for(TagListing tagListing : tagListings){

				if(itemIdPrice.get(tagListing.getItemId()) > tagListing.getSellingPrice()){

					itemIdPrice.put(tagListing.getItemId(), mop ? tagListing.getMop(): tagListing.getSellingPrice());

				}

			}

		} catch (ProfitMandiBusinessException e) {

			e.printStackTrace();

		}

		return itemIdPrice;

	}

	@Override

	public Map<Integer, Float> getMopPrices(Set<Integer> itemIds, int retailerId) {

		return getMopOrSellingPrice(itemIds, retailerId, true);

	}

	@Override

	public Map<Float, GadgetCopsInsuranceCalc> getInsurancePrices(Set<Float> prices, String providerName) throws ProfitMandiBusinessException{

		insuranceProviderRepository.selectByName(providerName);

		Map<Float, GadgetCopsInsuranceCalc> pricesMap = new HashMap<>();

		if(ProfitMandiConstants.GADGET_COPS.equals(providerName)){

			List<GadgetCopsInsuranceCalc> gadgetCopsInsuranceCalcs = gadgetCopsInsuranceCalcRepository.selectAll();

			for(GadgetCopsInsuranceCalc gadgetCopsInsuranceCalc : gadgetCopsInsuranceCalcs){

				for(float price : prices){

					if(gadgetCopsInsuranceCalc.getPriceRangeMin()<= price && gadgetCopsInsuranceCalc.getPriceRangeMax() >= price){

						pricesMap.put(price, gadgetCopsInsuranceCalc);

					}

				}

			}

		}else{

			throw new ProfitMandiBusinessException(ProfitMandiConstants.PROVIDER_NAME, providerName, "");

		}

		return pricesMap;

	}

	@Override

	public Map<Integer, Float> getPurchasePrices(Set<Integer> itemIds, int retailerId) {

		Map<Integer, Float> purchasePriceMap = this.preparePriceDefaultValues(itemIds);

		List<InventoryItem> inventoryItems = inventoryItemRepository.selectByFofoIdItemIds(retailerId, itemIds);

		for(InventoryItem inventoryItem : inventoryItems){

			if(inventoryItem.getUnitPrice() < purchasePriceMap.get(inventoryItem.getItemId())){

				purchasePriceMap.put(inventoryItem.getItemId(), inventoryItem.getUnitPrice());

			}

		}

		return purchasePriceMap;

	}

	@Override

	public Map<Integer, MopPriceModel> getPurchasePriceMopPriceNotFound(Set<Integer> itemIds, int retailerId) {

		Map<Integer, Float> mopPriceMap = this.getMopPrices(itemIds, retailerId);

		Map<Integer, MopPriceModel> mopPriceModelMap = new HashMap<>();

		boolean fetchPurchasePrice = false;

		for(Map.Entry<Integer, Float> entry : mopPriceMap.entrySet()){

			MopPriceModel mopPriceModel = new MopPriceModel();

			mopPriceModel.setPrice(entry.getValue());

			if(entry.getValue() == Float.MAX_VALUE || entry.getValue() == 0f) {

				fetchPurchasePrice = true;

				mopPriceModel.setMop(false);

			}else{

				mopPriceModel.setMop(false);

			}

			mopPriceModelMap.put(entry.getKey(), mopPriceModel);

		}

		if(fetchPurchasePrice){

			Map<Integer, Float> purchasePriceMap = this.getPurchasePrices(itemIds, retailerId);

			for(Map.Entry<Integer, MopPriceModel> entry : mopPriceModelMap.entrySet()){

				if(!entry.getValue().isMop()){

					entry.getValue().setPrice(purchasePriceMap.get(entry.getKey()));

				}

			}

		}

		return mopPriceModelMap;

	}

	//Currently it only handles fofos

	public List<Integer> getTagsIdsByRetailerId(int retailerId) throws Throwable{

		//int addressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(retailerId);

		/*Address retailerAddress = addressRepository.selectById(addressId);

		Set<Integer> pinCodeTagIds = tagService.getFofoTagIdsByPinCode(retailerAddress.getPinCode());*/

		//Hardcoded temporarily

		Set<Integer> pinCodeTagIds = tagService.getFofoTagIdsByPinCode("110001");

		Set<Integer> pinNegativeTagIds = tagService.getPinCodeNegativeTagIds();

		Set<Integer> pinCodeIntersection = new HashSet<>(CollectionUtils.intersection(pinCodeTagIds, pinNegativeTagIds));

		Set<Integer> validTagIds = new HashSet<>(CollectionUtils.subtract(pinNegativeTagIds, pinCodeIntersection));

		Set<Integer> pinPositiveTagIds = tagService.getPinCodePositiveTagIds();

		validTagIds.addAll(CollectionUtils.intersection(pinPositiveTagIds, pinCodeTagIds));

		if(validTagIds.isEmpty()){

			return new ArrayList<>(validTagIds);

		}

		Set<Integer> retailerTagIds = tagService.getUserTagIdsByTagIds(validTagIds);

		Set<Integer> userNegativeTagIds = tagService.getUserNegativeTagIds();

		Set<Integer> userIntersection = new HashSet<>(CollectionUtils.intersection(retailerTagIds, userNegativeTagIds));

		validTagIds = new HashSet<>(CollectionUtils.subtract(userNegativeTagIds, userIntersection));

		Set<Integer> userPositiveTagIds = tagService.getUserPositiveTagIds();

		validTagIds.addAll(CollectionUtils.intersection(userPositiveTagIds, retailerTagIds));

		return new ArrayList<>(validTagIds);

	}

}