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.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

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

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

import org.springframework.stereotype.Component;

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

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

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.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

	private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

	@Autowired

	private AddressRepository addressRepository;

	@Autowired

	private TagService tagService;

	@Autowired

	private TagListingRepository tagListingRepository;

	@Autowired

	private InsuranceProviderRepository insuranceProviderRepository;

	@Autowired

	private GadgetCopsInsuranceCalcRepository gadgetCopsInsuranceCalcRepository;

	@Autowired

	@Qualifier("fofoInventoryItemRepository")

	private InventoryItemRepository inventoryItemRepository;

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

	@Override

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

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

		List<TagListing> tagListings = this.getTagListing(itemIds, retailerId);

		for(TagListing tagListing : tagListings){

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

				itemIdPrice.put(tagListing.getItemId(), tagListing.getSellingPrice());

			}

		}

		return itemIdPrice;

	}

	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;

	}

	private Map<Integer, PriceModel> preparePriceModelDefaultValues(Set<Integer> itemIds){

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

		for(int itemId : itemIds){

			PriceModel priceModel = new PriceModel();

			priceModel.setPrice(Float.MAX_VALUE);

			itemIdPrice.put(itemId, priceModel);

		}

		return itemIdPrice;

	}

	@SuppressWarnings("unchecked")

	private List<TagListing> getTagListing(Set<Integer> itemIds, int retailerId){

		Map<Integer, TagListing> itemIdTagListing = new HashMap<>();

		List<TagListing> tagListings = new ArrayList<>();

		try {

			if(itemIds.isEmpty()) {

				return tagListings;

			}

			int 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 tagListings;

			}

			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 tagListings;

			}

			tagListings = tagListingRepository.selectByItemIdsAndTagIds(itemIds, filterUserTagIds);

			if(tagListings.isEmpty()){

				return tagListings;

			}

			for(TagListing tagListing : tagListings){

				if(!itemIdTagListing.containsKey(tagListing.getItemId()))

				{

					itemIdTagListing.put(tagListing.getItemId(), tagListing);

				}else{

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

						itemIdTagListing.put(tagListing.getItemId(), tagListing);

					}

				}

			}

		} catch (ProfitMandiBusinessException e) {

			e.printStackTrace();

		}

		return tagListings;

	}

	@Override

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

		Map<Integer, PriceModel> itemIdPrice = this.preparePriceModelDefaultValues(itemIds);

		List<TagListing> tagListings = this.getTagListing(itemIds, retailerId);

		for(TagListing tagListing : tagListings){

			if(itemIdPrice.get(tagListing.getItemId()).getPrice() > tagListing.getMop()){

				itemIdPrice.get(tagListing.getItemId()).setPrice(tagListing.getMop());

				itemIdPrice.get(tagListing.getItemId()).setMop(true);

				itemIdPrice.get(tagListing.getItemId()).setPurchasePrice(tagListing.getSellingPrice());

				itemIdPrice.get(tagListing.getItemId()).setMaxDiscountAmount(tagListing.getMaxDiscountPrice());

			}

		}

		return itemIdPrice;

	}

	@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, "INSRNC_PRVDR_1000");

		}

		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, PriceModel> getPurchasePriceMopPriceNotFound(Set<Integer> itemIds, int retailerId) {

		Map<Integer, PriceModel> mopPriceModelMap = this.getMopPrices(itemIds, retailerId);

		Set<Integer> purchasePriceItemIds = new HashSet<>();

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

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

				purchasePriceItemIds.add(entry.getKey());

			}

		}

		if(!purchasePriceItemIds.isEmpty()){

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

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

				mopPriceModelMap.get(entry.getKey()).setMop(false);

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

				mopPriceModelMap.get(entry.getKey()).setPurchasePrice(entry.getValue());

				mopPriceModelMap.get(entry.getKey()).setMaxDiscountAmount(0);

			}

		}

		return mopPriceModelMap;

	}

	//Currently it only handles fofos

	@SuppressWarnings("unchecked")

	public List<Integer> getTagsIdsByRetailerId(int retailerId){

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

	}

}