Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.pricing;

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.Item;
import com.spice.profitmandi.dao.entity.catalog.TagListing;
import com.spice.profitmandi.dao.entity.dtr.GadgetCopsInsuranceCalc;
import com.spice.profitmandi.dao.entity.user.Address;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
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.fofo.PartnerTypeChangeService;
import com.spice.profitmandi.dao.repository.user.AddressRepository;
import com.spice.profitmandi.service.scheme.SchemeService;
import com.spice.profitmandi.service.tag.TagService;
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 java.util.*;

@Component
public class PricingServiceImpl implements PricingService{

        @Autowired
        private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;
        
        @Autowired
        private AddressRepository addressRepository;
        
        @Autowired
        private ItemRepository itemRepository;
        
        @Autowired
        private SchemeService schemeService;
        
        @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;
        }

        @Autowired
        PartnerTypeChangeService partnerTypeChangeService;


        public static final List<Integer> mopVoilatedRetailerIds = Arrays.asList();

        @Override
        public List<Integer> getMopVoilatedRetailerIds() {
                return mopVoilatedRetailerIds;
        }
        @Override
    public Map<Integer, PriceModel> getMopPrices(Set<Integer> itemIds, int retailerId) throws ProfitMandiBusinessException {
                //Set Price with max value
                Map<Integer, PriceModel> itemPriceMap = this.preparePriceModelDefaultValues(itemIds);
                List<TagListing> tagListings = this.getTagListing(itemIds, retailerId);
                for(TagListing tagListing : tagListings){
                        Item item = null;
                        try {
                                item = itemRepository.selectById(tagListing.getItemId());
                        } catch (Exception e) {
                                LOGGER.info("Could not find item {}", tagListing.getItemId());
                                continue;
                        }
                        PriceModel priceModel = itemPriceMap.get(tagListing.getItemId());
                        //In case of hot deal mop is set to retailer buying price
                        priceModel.setPurchasePrice(tagListing.getSellingPrice());
                        priceModel.setMrp(tagListing.getMrp());
                        if(tagListing.isHotDeals()) {
                                priceModel.setMop(true);
                                priceModel.setPrice(tagListing.getSellingPrice());
                        } else if (itemPriceMap.get(tagListing.getItemId()).getPrice() > tagListing.getMop()) {
                                priceModel.setPrice(tagListing.getMop());
                                priceModel.setMop(true);
                                Map<Integer, Float> catalogSchemeCashBack =  schemeService.getCatalogSchemeCashBack(retailerId, Arrays.asList(item.getCatalogItemId()));
                                if(catalogSchemeCashBack.get(item.getCatalogItemId()) != null && catalogSchemeCashBack.get(item.getCatalogItemId()) > 0) {
                                        priceModel.setMaxDiscountAmount(catalogSchemeCashBack.get(item.getCatalogItemId()));
                                }
                        } else if (item.getHsnCode().equals("85171400")) {
                                priceModel.setMop(false);
                                priceModel.setPrice(tagListing.getSellingPrice());
                        }
            if (mopVoilatedRetailerIds.contains(retailerId) || "almost new".equals(item.getBrand().toLowerCase())) {
                                priceModel.setMop(false);
                        }
                }
                return itemPriceMap;
        }

        @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, PriceModel> getPurchasePriceMopPriceNotFound(Set<Integer> itemIds, int retailerId) throws ProfitMandiBusinessException {
                return this.getMopPrices(itemIds, retailerId);
        }
        
        //Currently it only handles fofos
        @SuppressWarnings("unchecked")
    public List<Integer> getTagsIdsByRetailerId(int retailerId) throws ProfitMandiBusinessException {
                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);
        }
}