Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.pricing;

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.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
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;
        
        @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.getUnitPrice())){
                                purchasePriceMap.put(inventoryItem.getItemId(), inventoryItem.getUnitPrice());
                        }
                }
                return purchasePriceMap;
        }
        
        @Override
        public Map<Integer, Float> getPurchasePriceMopPriceNotFound(Set<Integer> itemIds, int retailerId) {
                Map<Integer, Float> mopPriceMap = this.getMopPrices(itemIds, retailerId);
                boolean fetchPurchasePrice = false;
                for(Map.Entry<Integer, Float> entry : mopPriceMap.entrySet()){
                        if(entry.getValue() == Float.MAX_VALUE){
                                fetchPurchasePrice = true;
                                break;
                        }
                }
                if(fetchPurchasePrice){
                        Map<Integer, Float> privateDealsPriceMap = this.getPurchasePrices(itemIds, retailerId);
                        for(Map.Entry<Integer, Float> entry : mopPriceMap.entrySet()){
                                if(entry.getValue() == Float.MAX_VALUE){
                                        entry.setValue(privateDealsPriceMap.get(entry.getKey()));
                                }
                        }
                }
                return mopPriceMap;
        }
}