Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.offers;

import com.google.common.collect.Lists;

import com.google.gson.Gson;

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

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

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

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

import com.spice.profitmandi.common.util.FileUtil;

import com.spice.profitmandi.common.util.FormattingUtils;

import com.spice.profitmandi.common.util.Utils;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.entity.transaction.LineItem;

import com.spice.profitmandi.dao.entity.transaction.Order;

import com.spice.profitmandi.dao.entity.transaction.UserWalletHistory;

import com.spice.profitmandi.dao.entity.warehouse.WarehouseInventoryItem;

import com.spice.profitmandi.dao.entity.warehouse.WarehouseScan;

import com.spice.profitmandi.dao.enumuration.catalog.AchievementType;

import com.spice.profitmandi.dao.enumuration.catalog.AmountType;

import com.spice.profitmandi.dao.enumuration.catalog.OfferSchemeType;

import com.spice.profitmandi.dao.enumuration.transaction.SchemePayoutStatus;

import com.spice.profitmandi.dao.model.*;

import com.spice.profitmandi.dao.repository.GenericRepository;

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

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

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

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

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

import com.spice.profitmandi.dao.repository.transaction.LineItemImeisRepository;

import com.spice.profitmandi.dao.repository.warehouse.AgeingSummaryModel;

import com.spice.profitmandi.dao.repository.warehouse.WarehouseInventoryItemRepository;

import com.spice.profitmandi.dao.repository.warehouse.WarehouseScanRepository;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.pricecircular.PriceCircularService;

import com.spice.profitmandi.service.scheme.InventoryPayoutModel;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.service.wallet.WalletService;

import com.spice.profitmandi.service.whatsapp.WhatsappMessageType;

import in.shop2020.model.v1.order.WalletReferenceType;

import org.apache.commons.io.output.ByteArrayOutputStream;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.apache.poi.ss.usermodel.Cell;

import org.apache.poi.ss.usermodel.CellType;

import org.apache.poi.ss.usermodel.Row;

import org.apache.poi.ss.usermodel.Row.MissingCellPolicy;

import org.apache.poi.xssf.usermodel.XSSFRow;

import org.apache.poi.xssf.usermodel.XSSFSheet;

import org.apache.poi.xssf.usermodel.XSSFWorkbook;

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

import org.springframework.cache.CacheManager;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Component;

import java.io.IOException;

import java.io.InputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.YearMonth;

import java.util.*;

import java.util.stream.Collectors;

@Component

public class OfferServiceImpl implements OfferService {

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

    // Constants

    private static final List<String> TARGETS = Arrays.asList("Target 1", "Target 2", "Target 3", "Target 4", "Target 5");

    private static final int STOCK_AGEING_THRESHOLD_DAYS = 300;

    // Dependencies - Core

    @Autowired

    private Gson gson;

    @Autowired

    private OfferService offerServiceProxy; // self-injection for Spring cache proxy

    @Autowired

    private CacheManager redisCacheManager;

    @Autowired

    private CacheManager redisShortCacheManager;

    // Dependencies - Repositories

    @Autowired

    private GenericRepository genericRepository;

    @Autowired

    private OfferRepository offerRepository;

    @Autowired

    private OfferPayoutRepository offerPayoutRepository;

    @Autowired

    private OfferTargetSlabRepository offerTargetSlabRepository;

    @Autowired

    private ItemCriteriaRepository itemCriteriaRepository;

    @Autowired

    private ItemRepository itemRepository;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private ActivatedImeiRepository activatedImeiRepository;

    @Autowired

    private WarehouseScanRepository warehouseScanRepository;

    @Autowired

    private WarehouseInventoryItemRepository warehouseInventoryItemRepository;

    @Autowired

    private LineItemImeisRepository lineItemImeisRepository;

    @Autowired

    private InventoryItemRepository inventoryItemRepository;

    @Autowired

    private OfferEligibleImeiRepository offerEligibleImeiRepository;

    // Dependencies - Services

    @Autowired

    private NotificationService notificationService;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private PriceCircularService priceCircularService;

    @Autowired

    private WalletService walletService;

    @Override

    public void evictOfferCaches(int offerId) {

        Offer offer = offerRepository.selectById(offerId);

        YearMonth ym = YearMonth.from(offer.getStartDate());

        redisCacheManager.getCache("offer.definition").evict(offerId);

        redisCacheManager.getCache("allOffers").evict(ym);

        redisCacheManager.getCache("catalog.published_yearmonth").evict(ym);

        redisCacheManager.getCache("offer.slabpayout").evict(offerId);

        redisCacheManager.getCache("offer.achievement").clear();

        redisShortCacheManager.getCache("todayOffers").clear();

    }

    @Override

    public void addOfferService(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {

        LOGGER.info("createOfferRequest  -- {}", createOfferRequest);

        this.createOffer(createOfferRequest);

        this.createTargetSlabs(createOfferRequest);

    }

    private void createOffer(CreateOfferRequest createOfferRequest) {

        Offer offer = new Offer();

        offer.setName(createOfferRequest.getName());

        offer.setTargetType(createOfferRequest.getTargetType());

        offer.setBooster(createOfferRequest.isBooster());

        offer.setPayoutType(createOfferRequest.getPayoutType());

        offer.setSchemeType(createOfferRequest.getSchemeType());

        offer.setBaseCriteia(createOfferRequest.isBaseCriteria());

        offer.setEndDate(createOfferRequest.getEndDate());

        offer.setStartDate(createOfferRequest.getStartDate());

        offer.setBrandSharePercentage(createOfferRequest.getBrandShareTerms());

        offer.setSellinPercentage(createOfferRequest.getSellinPercentage());

        offer.setOfferNotes(createOfferRequest.getOfferNotes());

        offer.setActivationBrands(createOfferRequest.getActivationBrands());

        offer.setTerms(createOfferRequest.getTerms());

        offer.setItemCriteria(gson.toJson(createOfferRequest.getItemCriteria()));

        offer.setPartnerCriteria(gson.toJson(createOfferRequest.getPartnerCriteria()));

        offer.setDiscount(createOfferRequest.isDiscount());

        offerRepository.persist(offer);

        createOfferRequest.setId(offer.getId());

    }

    @Override

    public List<CreateOfferRequest> getPublishedOffers(int fofoId, YearMonth yearMonth) throws ProfitMandiBusinessException {

        // Past months (>1 month ago): achievement is frozen, cache the full result

        if (yearMonth.isBefore(YearMonth.now().minusMonths(1))) {

            return offerServiceProxy.getPublishedOffersCached(fofoId, yearMonth);

        }

        // Current/recent month: assemble live from cached building blocks

        return assemblePublishedOffers(fofoId, yearMonth);

    }

    @Cacheable(value = "publishedOffersWithAchievement.past", cacheManager = "redisCacheManager")

    public List<CreateOfferRequest> getPublishedOffersCached(int fofoId, YearMonth yearMonth) throws ProfitMandiBusinessException {

        return assemblePublishedOffers(fofoId, yearMonth);

    }

    private List<CreateOfferRequest> assemblePublishedOffers(int fofoId, YearMonth yearMonth) throws ProfitMandiBusinessException {

        Map<Integer, List<Offer>> publishedMapByPartner = offerRepository.selectAllPublishedMapByPartner(yearMonth);

        List<Offer> publishedOffers = publishedMapByPartner != null ? publishedMapByPartner.get(fofoId) : null;

        List<CreateOfferRequest> createOfferRequests = new ArrayList<>();

        if (publishedOffers != null) {

            for (Offer offer : publishedOffers) {

                CreateOfferRequest copy = deepCopy(this.getCreateOfferRequest(offer));

                setCriteriaPayoutAchieved(fofoId, copy);

                createOfferRequests.add(copy);

            }

        }

        return createOfferRequests;

    }

    private void setCriteriaPayoutAchieved(int fofoId, CreateOfferRequest createOfferRequest) {

        Map<Integer, Long> criteriaTransactionMap;

        if (createOfferRequest.getSchemeType().equals(OfferSchemeType.SELLIN)) {

            criteriaTransactionMap = offerRepository.getPurchaseSumForPartner(

                    createOfferRequest.getId(), fofoId, createOfferRequest);

        } else {

            criteriaTransactionMap = offerRepository.getSalesSumForPartner(

                    createOfferRequest.getId(), fofoId, createOfferRequest);

        }

        List<com.spice.profitmandi.dao.model.ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest

                .getTargetSlabs().get(0).getItemCriteriaPayouts();

        for (com.spice.profitmandi.dao.model.ItemCriteriaPayout itemCriteriaPayout : itemCriteriaPayouts) {

            itemCriteriaPayout.setNextSlab(null);

            long saleAmount = 0;

            if (criteriaTransactionMap != null

                    && criteriaTransactionMap.containsKey(itemCriteriaPayout.getItemCriteria().getId())) {

                saleAmount = criteriaTransactionMap.containsKey(0) ? criteriaTransactionMap.get(0) : criteriaTransactionMap.get(itemCriteriaPayout.getItemCriteria().getId());

            }

            itemCriteriaPayout.setAchievedValue(saleAmount);

            List<com.spice.profitmandi.service.offers.PayoutSlab> payoutSlabs = itemCriteriaPayout.getPayoutSlabs();

            for (int i = 0; i < payoutSlabs.size(); i++) {

                com.spice.profitmandi.service.offers.PayoutSlab beginSlab = payoutSlabs.get(i);

                com.spice.profitmandi.service.offers.PayoutSlab endSlab = null;

                if (payoutSlabs.size() - 1 > i) {

                    endSlab = payoutSlabs.get(i + 1);

                }

                if (beginSlab.getOnwardsAmount() > saleAmount) {

                    itemCriteriaPayout.setShortValue(beginSlab.getOnwardsAmount() - saleAmount);

                    itemCriteriaPayout.setNextSlab(beginSlab);

                    break;

                }

                if (endSlab != null) {

                    if (beginSlab.getOnwardsAmount() <= saleAmount && endSlab.getOnwardsAmount() > saleAmount) {

                        itemCriteriaPayout.setCurrentSlab(beginSlab);

                        beginSlab.setSelected(true);

                        itemCriteriaPayout.setNextSlab(endSlab);

                        itemCriteriaPayout.setShortValue(endSlab.getOnwardsAmount() - saleAmount);

                        break;

                    }

                } else {

                    beginSlab.setSelected(true);

                    itemCriteriaPayout.setCurrentSlab(beginSlab);

                }

            }

        }

    }

    @Override

    @Cacheable(value = "allOffers", cacheManager = "redisCacheManager")

    public Map<Integer, CreateOfferRequest> getAllOffers(YearMonth yearMonth) throws ProfitMandiBusinessException {

        List<Offer> allOffers = offerRepository.selectAll(yearMonth, false);

        List<CreateOfferRequest> createOfferRequests = new ArrayList<>();

        for (Offer offer : allOffers) {

            CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);

            createOfferRequests.add(createOfferRequest);

        }

        return createOfferRequests.stream().collect(Collectors.toMap(CreateOfferRequest::getId, x -> x));

    }

    private CreateOfferRequest deepCopy(CreateOfferRequest source) {

        return gson.fromJson(gson.toJson(source), CreateOfferRequest.class);

    }

    @Override

    @Cacheable(value = "offer.definition", cacheManager = "redisCacheManager", key = "#offerId")

    public CreateOfferRequest getOfferDefinition(int offerId) throws ProfitMandiBusinessException {

        Offer offer = offerRepository.selectById(offerId);

        return this.getCreateOfferRequest(offer);

    }

    @Override

    public CreateOfferRequest getOffer(int fofoId, int offerId) throws ProfitMandiBusinessException {

        CreateOfferRequest definition = offerServiceProxy.getOfferDefinition(offerId);

        if (fofoId > 0) {

            CreateOfferRequest copy = deepCopy(definition);

            copy.setCriteriaQtyAmountModel(this.getCriteriaQtyAmounModelMap(copy, fofoId));

            return copy;

        }

        return definition;

    }

    @Override

    public CreateOfferRequest getCreateOfferRequest(Offer fromOffer) throws ProfitMandiBusinessException {

        CreateOfferRequest createOfferRequest = new CreateOfferRequest();

        createOfferRequest.setName(fromOffer.getName());

        createOfferRequest.setDiscount(fromOffer.isDiscount());

        createOfferRequest.setTargetType(fromOffer.getTargetType());

        createOfferRequest.setPayoutType(fromOffer.getPayoutType());

        createOfferRequest.setSchemeType(fromOffer.getSchemeType());

        createOfferRequest.setActivationBrands(fromOffer.getActivationBrands());

        createOfferRequest.setEndDate(fromOffer.getEndDate());

        createOfferRequest.setProcessTimestamp(fromOffer.getProcessedTimestamp());

        createOfferRequest.setStartDate(fromOffer.getStartDate());

        createOfferRequest.setBooster(fromOffer.isBooster());

        createOfferRequest.setActive(fromOffer.isActive());

        createOfferRequest.setSellinPercentage(fromOffer.getSellinPercentage());

        createOfferRequest.setBrandShareTerms(fromOffer.getBrandSharePercentage());

        createOfferRequest.setOfferNotes(fromOffer.getOfferNotes());

        createOfferRequest.setTerms(fromOffer.getTerms());

        createOfferRequest.setBaseCriteria(fromOffer.isBaseCriteia());

        createOfferRequest.setItemCriteria(

                gson.fromJson(fromOffer.getItemCriteria(), com.spice.profitmandi.service.offers.ItemCriteria.class));

        createOfferRequest.setPartnerCriteria(gson.fromJson(fromOffer.getPartnerCriteria(), PartnerCriteria.class));

        createOfferRequest.setId(fromOffer.getId());

        createOfferRequest.setCreatedOn(fromOffer.getCreatedTimestamp());

        createOfferRequest.setItemCriteriaString(

                itemCriteriaRepository.getItemCriteriaDescription(createOfferRequest.getItemCriteria()));

        List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = offerTargetSlabRepository

                .getByOfferId(fromOffer.getId());

        createOfferRequest.setPartnerCriteriaString(

                this.getPartnerCriteriaString(createOfferRequest.getPartnerCriteria()));

        createOfferRequest.setTargetSlabs(targetSlabs);

        if (!targetSlabs.isEmpty() && !targetSlabs.get(0).getItemCriteriaPayouts().isEmpty()) {

            for (com.spice.profitmandi.dao.model.ItemCriteriaPayout itemCriteriaPayout : targetSlabs.get(0).getItemCriteriaPayouts()) {

                if (!itemCriteriaPayout.getPayoutSlabs().isEmpty()) {

                    itemCriteriaPayout.setNextSlab(itemCriteriaPayout.getPayoutSlabs().get(0));

                }

            }

        }

        return createOfferRequest;

    }

    @Override

    public void reverseAdditionalSelloutSchemes(List<InventoryItem> inventoryItems, String reversalReason) throws ProfitMandiBusinessException {

        Map<Integer, List<InventoryItem>> fofoInventoryItemsMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getFofoId()));

        for (Map.Entry<Integer, List<InventoryItem>> fofoInventoryItemsEntry : fofoInventoryItemsMap.entrySet()) {

            int fofoId = fofoInventoryItemsEntry.getKey();

            List<InventoryItem> partnerInventoryItems = fofoInventoryItemsEntry.getValue();

            List<OfferPayout> offerPayouts = new ArrayList<>();

            LOGGER.info("Reversing schemes for fofoId {}, InventoryItems {}", fofoId, inventoryItems);

            //As of now we are not handling non-serialised items

            List<InventoryItem> serializedItems = partnerInventoryItems.stream().filter(x -> x.getSerialNumber() != null).collect(Collectors.toList());

            if (serializedItems.size() > 0) {

                // Batch fetch: collect all serial numbers and fetch in one call per fofoId

                Set<String> serialNumbers = serializedItems.stream().map(InventoryItem::getSerialNumber).collect(Collectors.toSet());

                offerPayouts = offerPayoutRepository.selectAllBySerialNumbers(fofoId, serialNumbers)

                        .stream()

                        .filter(x -> x.getRejectTimestamp() == null)

                        .collect(Collectors.toList());

                for (OfferPayout offerPayout : offerPayouts) {

                    offerPayout.setStatus(SchemePayoutStatus.REJECTED);

                    offerPayout.setRejectTimestamp(LocalDateTime.now());

                }

                Map<Long, Double> offerPayoutAmountMap = offerPayouts.stream().collect(Collectors.groupingBy(x -> x.getOfferId(), Collectors.summingDouble(x -> x.getAmount())));

                for (Map.Entry<Long, Double> offerPayoutEntry : offerPayoutAmountMap.entrySet()) {

                    List<UserWalletHistory> histories = walletService.getAllByReference(fofoId, offerPayoutEntry.getKey().intValue(), WalletReferenceType.ADDITIONAL_SCHEME);

                    if (histories.size() > 0) {

                        walletService.rollbackAmountFromWallet(fofoId, offerPayoutEntry.getValue().floatValue(), offerPayoutEntry.getKey().intValue(),

                                WalletReferenceType.ADDITIONAL_SCHEME, reversalReason, LocalDateTime.now());

                    }

                }

            }

        }

    }

    private void createTargetSlabs(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {

        List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = createOfferRequest.getTargetSlabs().stream()

                .filter(x -> x.validate()).collect(Collectors.toList());

        if (!targetSlabs.isEmpty()) {

            Collections.sort(targetSlabs);

            for (com.spice.profitmandi.dao.model.TargetSlab targetSlab : targetSlabs) {

                if (targetSlab.validate()) {

                    List<ItemCriteriaPayout> itemCriteriaPayouts = targetSlab.getItemCriteriaPayouts();

                    for (ItemCriteriaPayout itemCriteriaPayout : itemCriteriaPayouts) {

                        ItemCriteria itemCriteria = itemCriteriaRepository.selectById(itemCriteriaPayout.getItemCriteria().getId());

                        if (itemCriteriaPayout.getItemCriteria().getId() > 0) {

                            itemCriteriaPayout.getItemCriteria().setId(0);

                        } else {

                            String itemCriteriaJson = gson.toJson(itemCriteriaPayout.getItemCriteria());

                            itemCriteria = itemCriteriaRepository.selectByCriteria(itemCriteriaJson);

                            // ItemCriteria Only once

                            if (itemCriteria == null) {

                                itemCriteria = new ItemCriteria();

                                itemCriteria.setCriteria(gson.toJson(itemCriteriaPayout.getItemCriteria()));

                                itemCriteriaRepository.persist(itemCriteria);

                            }

                        }

                        for (PayoutSlab payoutSlab : itemCriteriaPayout.getPayoutSlabs()) {

                            TargetSlabEntity targetSlabEntity = new TargetSlabEntity();

                            targetSlabEntity.setOfferId(createOfferRequest.getId());

                            targetSlabEntity.setOnwardsTarget(targetSlab.getOnwardsAmount());

                            targetSlabEntity.setTargetDescription(targetSlab.getTargetDescription());

                            targetSlabEntity.setPayoutTarget(payoutSlab.getOnwardsAmount());

                            targetSlabEntity.setPayoutValue(payoutSlab.getPayoutAmount());

                            targetSlabEntity.setItemCriteriaId(itemCriteria.getId());

                            targetSlabEntity.setAmountType(itemCriteriaPayout.getAmountType());

                            targetSlabEntity.setStartDate(itemCriteriaPayout.getStartDate());

                            targetSlabEntity.setEndDate(itemCriteriaPayout.getEndDate());

                            offerTargetSlabRepository.persist(targetSlabEntity);

                        }

                    }

                }

            }

        } else {

            throw new ProfitMandiBusinessException("Invalid Target Slabs", "Invalid Target", "");

        }

    }

    @Override

    public List<CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, int catalogId) throws ProfitMandiBusinessException {

        Map<Integer, List<Offer>> publishedMapByPartner = offerRepository.selectAllPublishedMapByPartner(YearMonth.from(date));

        List<Offer> publishedOffers = publishedMapByPartner != null ? publishedMapByPartner.get(fofoId) : null;

        List<CreateOfferRequest> createOfferRequests = new ArrayList<>();

        if (publishedOffers != null) {

            for (Offer offer : publishedOffers) {

                boolean found = false;

                List<com.spice.profitmandi.dao.model.TargetSlab> targetSlabs = offerTargetSlabRepository

                        .getByOfferId(offer.getId());

                CreateOfferRequest createOfferRequest = this.getCreateOfferRequest(offer);

                createOfferRequest.setTargetSlabs(targetSlabs);

                this.setCriteriaPayoutAchieved(fofoId, createOfferRequest);

                Set<com.spice.profitmandi.service.offers.ItemCriteria> itemCriteriaSet = targetSlabs.stream()

                        .flatMap(x -> x.getItemCriteriaPayouts().stream()).map(x -> x.getItemCriteria()).distinct()

                        .filter(x -> itemRepository.containsModel(x, catalogId)).collect(Collectors.toSet());

                for (com.spice.profitmandi.dao.model.TargetSlab targetSlab : targetSlabs) {

                    targetSlab.setItemCriteriaPayouts(targetSlab.getItemCriteriaPayouts().stream()

                            .filter(x -> itemCriteriaSet.contains(x.getItemCriteria())).collect(Collectors.toList()));

                    if (targetSlab.getItemCriteriaPayouts().size() > 0) {

                        found = true;

                    }

                }

                if (found) {

                    createOfferRequests.add(createOfferRequest);

                }

            }

        }

        return createOfferRequests;

    }

    @Override

    public void createOffers(InputStream fileInputStream) throws Exception {

        Map<CreateOfferRequest, List<PartnerTargetModel>> offerPartnerTargetMap = this.parseFromExcel(fileInputStream);

        Set<YearMonth> ymListToEvict = new HashSet<>();

        for (Map.Entry<CreateOfferRequest, List<PartnerTargetModel>> partnerTargetEntry : offerPartnerTargetMap

                .entrySet()) {

            CreateOfferRequest createOfferRequest = partnerTargetEntry.getKey();

            Map<List<Integer>, List<Integer>> targetPartnerMap = partnerTargetEntry.getValue().stream()

                    .collect(Collectors.groupingBy(PartnerTargetModel::getTargets,

                            Collectors.mapping(PartnerTargetModel::getFofoId, Collectors.toList())));

            for (Map.Entry<List<Integer>, List<Integer>> targetPartnersEntry : targetPartnerMap.entrySet()) {

                List<Integer> fofoIds = createOfferRequest.getPartnerCriteria().getFofoIds();

                List<Integer> filterFofoIds = targetPartnersEntry.getValue().stream().filter(x -> !fofoIds.contains(x))

                        .collect(Collectors.toList());

                LOGGER.info("FofoIds {}", filterFofoIds);

                List<Integer> targets = targetPartnersEntry.getKey();

                LOGGER.info("Targets  {}", targets);

                createOfferRequest.getPartnerCriteria().setFofoIds(filterFofoIds);

                int counter = 0;

                List<ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest.getTargetSlabs().get(0)

                        .getItemCriteriaPayouts();

                List<PayoutSlab> payoutSlabs = itemCriteriaPayouts.stream().flatMap(x -> x.getPayoutSlabs().stream()).collect(Collectors.toList());

                for (PayoutSlab payoutSlab : payoutSlabs) {

                    payoutSlab.setOnwardsAmount(targets.get(counter));

                    counter++;

                }

                this.addOfferService(createOfferRequest);

            }

            ymListToEvict.add(YearMonth.from(createOfferRequest.getStartDate()));

        }

        for (YearMonth ymToEvict : ymListToEvict) {

            redisCacheManager.getCache("allOffers").evict(ymToEvict);

        }

    }

    private Map<CreateOfferRequest, List<PartnerTargetModel>> parseFromExcel(InputStream inputStream)

            throws ProfitMandiBusinessException {

        Map<CreateOfferRequest, List<PartnerTargetModel>> offerPartnerTargetMap = new HashMap<>();

        XSSFWorkbook myWorkBook = null;

        try {

            myWorkBook = new XSSFWorkbook(inputStream);

            myWorkBook.setMissingCellPolicy(MissingCellPolicy.RETURN_BLANK_AS_NULL);

            for (int i = 0; i < myWorkBook.getNumberOfSheets(); i++) {

                XSSFSheet mySheet = myWorkBook.getSheetAt(i);

                int offerId = Integer.parseInt(mySheet.getSheetName());

                CreateOfferRequest existingOffer = this.getOffer(0, offerId);

                List<PartnerTargetModel> partnerTargetModels = new ArrayList<>();

                offerPartnerTargetMap.put(existingOffer, partnerTargetModels);

                this.printIterator(mySheet);

                LOGGER.info("rowCellNum {}", mySheet.getLastRowNum());

                for (int rowNumber = 1; rowNumber <= mySheet.getLastRowNum(); rowNumber++) {

                    XSSFRow row = mySheet.getRow(rowNumber);

                    LOGGER.info("row {}", row);

                    PartnerTargetModel partnerTargetModel = new PartnerTargetModel();

                    if (row.getCell(0) != null && row.getCell(0).getCellTypeEnum() == CellType.NUMERIC) {

                        partnerTargetModel.setFofoId((int) row.getCell(0).getNumericCellValue());

                    } else {

                        ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(

                                "FOFO ID", row.getCell(0).toString(), "TGLSTNG_VE_1010");

                        LOGGER.error("Excel file parse error : ", profitMandiBusinessException);

                        throw profitMandiBusinessException;

                    }

                    List<Integer> targets = new ArrayList<>();

                    long targetsSize = existingOffer.getTargetSlabs().get(0).getItemCriteriaPayouts().stream().flatMap(x -> x.getPayoutSlabs().stream()).collect(Collectors.counting());

                    for (int cellNumber = 1; cellNumber <= targetsSize; cellNumber++) {

                        if (row.getCell(cellNumber) != null

                                && row.getCell(cellNumber).getCellTypeEnum() == CellType.NUMERIC) {

                            targets.add((int) row.getCell(cellNumber).getNumericCellValue());

                        } else {

                            ProfitMandiBusinessException profitMandiBusinessException = new ProfitMandiBusinessException(

                                    "Target Column issue at " + rowNumber + ", " + cellNumber, row.getCell(cellNumber),

                                    "Invalid target");

                            LOGGER.error("Excel file parse error : ", profitMandiBusinessException);

                            throw profitMandiBusinessException;

                        }

                    }

                    partnerTargetModel.setTargets(targets);

                    partnerTargetModels.add(partnerTargetModel);

                }

            }

            myWorkBook.close();

        } catch (ProfitMandiBusinessException pbse) {

            throw pbse;

        } catch (IOException ioException) {

            ioException.printStackTrace();

            throw new ProfitMandiBusinessException(ProfitMandiConstants.EXCEL_FILE, ioException.getMessage(),

                    "EXL_VE_1000");

        } finally {

            if (myWorkBook != null) {

                try {

                    myWorkBook.close();

                } catch (IOException e) {

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

            }

        }

        LOGGER.info("offerPartnerTargetMap {}", offerPartnerTargetMap);

        return offerPartnerTargetMap;

    }

    private void printIterator(XSSFSheet sheet) {

        Iterator<Row> rowIterator = sheet.iterator();

        while (rowIterator.hasNext()) {

            Row row = rowIterator.next();

            StringBuilder rowContent = new StringBuilder();

            Iterator<Cell> cellIterator = row.cellIterator();

            while (cellIterator.hasNext()) {

                Cell cell = cellIterator.next();

                switch (cell.getCellType()) {

                    case Cell.CELL_TYPE_NUMERIC:

                        rowContent.append(cell.getNumericCellValue()).append("\t");

                        break;

                    case Cell.CELL_TYPE_STRING:

                        rowContent.append(cell.getStringCellValue()).append("\t");

                        break;

                }

            }

            LOGGER.debug("Row content: {}", rowContent);

        }

    }

    @Override

    public Map<Integer, CreateOfferRequest> getPublishedOffers(LocalDate date, int fofoId, String brand) {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    @Cacheable(value = "slabPayoutMap1", cacheManager = "oneDayCacheManager")

    public Map<Integer, Map<Integer, Long>> getSlabPayoutMap(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {

        Map<Integer, Map<Integer, Long>> catalogSlabPayoutMap = new HashMap<>();

        com.spice.profitmandi.dao.model.TargetSlab targetSlab = createOfferRequest.getTargetSlabs().get(0);

        List<ItemCriteriaPayout> payouts = targetSlab.getItemCriteriaPayouts();

        for (ItemCriteriaPayout itemCriteriaPayout : payouts) {

            com.spice.profitmandi.service.offers.ItemCriteria itemCriteria = itemCriteriaPayout.getItemCriteria();

            List<Integer> catalogIds = itemRepository.getCatalogIds(itemCriteria);

            for (PayoutSlab payoutSlab : Lists.reverse(itemCriteriaPayout.getPayoutSlabs())) {

                if (itemCriteriaPayout.getAmountType().equals(AmountType.FIXED)) {

                    for (Integer catalogId : catalogIds) {

                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {

                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());

                        }

                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),

                                (long) payoutSlab.getPayoutAmount());

                    }

                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.SLAB_FIXED)) {

                    for (Integer catalogId : catalogIds) {

                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {

                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());

                        }

                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),

                                (long) (payoutSlab.getPayoutAmount() / payoutSlab.getOnwardsAmount()));

                    }

                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.PERCENTAGE)) {

                    Map<Integer, TagListing> tagListingsMap = tagListingRepository.selectAllByCatalogIds(catalogIds);

                    for (Map.Entry<Integer, TagListing> tagListingEntry : tagListingsMap.entrySet()) {

                        TagListing tagListing = tagListingEntry.getValue();

                        if (!catalogSlabPayoutMap.containsKey(tagListingEntry.getKey())) {

                            catalogSlabPayoutMap.put(tagListingEntry.getKey(), new LinkedHashMap<>());

                        }

                        catalogSlabPayoutMap.get(tagListingEntry.getKey()).put(payoutSlab.getOnwardsAmount(),

                                (long) (tagListing.getSellingPrice() * payoutSlab.getPayoutAmount() / 100));

                    }

                }

            }

        }

        return catalogSlabPayoutMap;

    }

    @Override

    @Cacheable(value = "offer.slabpayout", cacheManager = "redisCacheManager", key = "#createOfferRequest.id")

    public Map<Integer, Map<Integer, AmountModel>> getSlabPayoutMapNew(CreateOfferRequest createOfferRequest) {

        Map<Integer, Map<Integer, AmountModel>> catalogSlabPayoutMap = new HashMap<>();

        com.spice.profitmandi.dao.model.TargetSlab targetSlab = createOfferRequest.getTargetSlabs().get(0);

        List<ItemCriteriaPayout> payouts = targetSlab.getItemCriteriaPayouts();

        for (ItemCriteriaPayout itemCriteriaPayout : payouts) {

            com.spice.profitmandi.service.offers.ItemCriteria itemCriteria = itemCriteriaPayout.getItemCriteria();

            List<Integer> catalogIds = itemRepository.getCatalogIds(itemCriteria);

            for (PayoutSlab payoutSlab : Lists.reverse(itemCriteriaPayout.getPayoutSlabs())) {

                if (itemCriteriaPayout.getAmountType().equals(AmountType.FIXED)) {

                    for (Integer catalogId : catalogIds) {

                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {

                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());

                        }

                        AmountModel amountModel = new AmountModel();

                        amountModel.setAmountType(AmountType.FIXED);

                        amountModel.setAmount(payoutSlab.getPayoutAmount());

                        amountModel.setDiscount(createOfferRequest.isDiscount());

                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),

                                amountModel);

                    }

                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.SLAB_FIXED)) {

                    for (Integer catalogId : catalogIds) {

                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {

                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());

                        }

                        AmountModel amountModel = new AmountModel();

                        amountModel.setAmountType(AmountType.FIXED);

                        amountModel.setDiscount(createOfferRequest.isDiscount());

                        amountModel.setAmount(payoutSlab.getPayoutAmount() / payoutSlab.getOnwardsAmount());

                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),

                                amountModel);

                    }

                } else if (itemCriteriaPayout.getAmountType().equals(AmountType.PERCENTAGE)) {

                    for (Integer catalogId : catalogIds) {

                        if (!catalogSlabPayoutMap.containsKey(catalogId)) {

                            catalogSlabPayoutMap.put(catalogId, new LinkedHashMap<>());

                        }

                        AmountModel amountModel = new AmountModel();

                        amountModel.setAmountType(AmountType.PERCENTAGE);

                        amountModel.setAmount(payoutSlab.getPayoutAmount());

                        amountModel.setDiscount(createOfferRequest.isDiscount());

                        catalogSlabPayoutMap.get(catalogId).put(payoutSlab.getOnwardsAmount(),

                                amountModel);

                    }

                }

            }

        }

        return catalogSlabPayoutMap;

    }

    private double getAmount(InventoryPayoutModel inventoryPayoutModel, AmountModel amountModel) {

        double rollout = 0;

        if (amountModel.getAmountType().equals(AmountType.PERCENTAGE)) {

            double effectiveDp = inventoryPayoutModel.getDp() - inventoryPayoutModel.getFixedAmount();

            double totalPercentage = inventoryPayoutModel.getPercentageAmount() + amountModel.getAmount();

            rollout = effectiveDp * (totalPercentage / (100 + totalPercentage) - (inventoryPayoutModel.getPercentageAmount() / (100 + inventoryPayoutModel.getPercentageAmount())));

        } else {

            rollout = amountModel.getAmount() * (100 / (100 + inventoryPayoutModel.getPercentageAmount()));

        }

        return rollout;

    }

    @Override

    public Map<Integer, QtyAmountModel> getCriteriaQtyAmounModelMap(CreateOfferRequest createOfferRequest, int fofoId) throws ProfitMandiBusinessException {

        Map<Integer, QtyAmountModel> qtyAmountMap;

        if (createOfferRequest.getSchemeType().equals(OfferSchemeType.SELLIN)) {

            qtyAmountMap = getCriteriaQtyAmountModelMapForSellin(createOfferRequest, fofoId);

        } else {

            qtyAmountMap = getCriteriaQtyAmountModelMapForSelloutAndActivation(createOfferRequest, fofoId);

        }

        LOGGER.info("Qty Amount Map {}", qtyAmountMap);

        return qtyAmountMap;

    }

    private PayoutSlab findEligibleSlab(List<PayoutSlab> slabs, int achievedValue) {

        PayoutSlab eligibleSlab = null;

        for (PayoutSlab slab : slabs) {

            if (slab.getOnwardsAmount() <= achievedValue) {

                eligibleSlab = slab;

            } else {

                break;

            }

        }

        return eligibleSlab;

    }

    private void setSlabProgress(ItemCriteriaPayout itemCriteriaPayout, PayoutSlab eligibleSlab, int achievedValue) {

        List<PayoutSlab> slabs = itemCriteriaPayout.getPayoutSlabs();

        itemCriteriaPayout.setCurrentSlab(eligibleSlab);

        if (eligibleSlab == null) {

            if (!slabs.isEmpty()) {

                itemCriteriaPayout.setNextSlab(slabs.get(0));

                itemCriteriaPayout.setShortValue(slabs.get(0).getOnwardsAmount() - achievedValue);

            }

        } else {

            int idx = slabs.indexOf(eligibleSlab);

            if (idx < slabs.size() - 1) {

                PayoutSlab next = slabs.get(idx + 1);

                itemCriteriaPayout.setNextSlab(next);

                itemCriteriaPayout.setShortValue(next.getOnwardsAmount() - achievedValue);

            } else {

                itemCriteriaPayout.setNextSlab(null);

                itemCriteriaPayout.setShortValue(0);

            }

        }

    }

    private double calculateFinalPayout(PayoutSlab eligibleSlab, AmountType amountType,

                                        int valueForPercentage, int valueForFixed) {

        if (eligibleSlab == null) return 0;

        eligibleSlab.setSelected(true);

        float payoutRate = eligibleSlab.getPayoutAmount();

        if (AmountType.PERCENTAGE.equals(amountType)) {

            return (payoutRate * valueForPercentage) / 100;

        } else if (AmountType.FIXED.equals(amountType)) {

            return payoutRate * valueForFixed;

        } else {

            return payoutRate;

        }

    }

    private QtyAmountModel calculateSellinQtyAndValue(List<Order> orders) {

        int qty = orders.stream().collect(Collectors.summingInt(x ->

                x.getLineItem().getQuantity() - x.getLineItem().getReturnQty()));

        int value = orders.stream().collect(Collectors.summingInt(x ->

                Math.round(x.getLineItem().getUnitPrice() *

                        (x.getLineItem().getQuantity() - x.getLineItem().getReturnQty()))));

        return new QtyAmountModel(qty, value);

    }

    private Map<Integer, QtyAmountModel> getCriteriaQtyAmountModelMapForSellin(CreateOfferRequest createOfferRequest, int fofoId) throws ProfitMandiBusinessException {

        Map<Integer, QtyAmountModel> criteriaQtyAmountMap = new HashMap<>();

        Map<Integer, List<Order>> criteriaOrdersMap = offerRepository.getPartnerWiseSellin(fofoId, createOfferRequest, true);

        List<Order> baseCriteriaOrders = criteriaOrdersMap.get(0);

        Integer userBaseQty = null;

        Integer userBaseValue = null;

        if (baseCriteriaOrders != null && baseCriteriaOrders.size() > 0) {

            QtyAmountModel baseModel = calculateSellinQtyAndValue(baseCriteriaOrders);

            userBaseQty = baseModel.getQty();

            userBaseValue = (int) baseModel.getAmount();

            criteriaQtyAmountMap.put(0, baseModel);

        } else {

            criteriaQtyAmountMap.put(0, new QtyAmountModel(0, 0));

        }

        LOGGER.info("Processing sellin");

        for (ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts()) {

            int criteriaId = itemCriteriaPayout.getItemCriteria().getId();

            QtyAmountModel qtyAmountModel = new QtyAmountModel(0, 0);

            criteriaQtyAmountMap.put(criteriaId, qtyAmountModel);

            List<Order> orders = criteriaOrdersMap.get(criteriaId);

            if (orders == null || orders.isEmpty()) continue;

            QtyAmountModel criteriaModel = calculateSellinQtyAndValue(orders);

            int criteriaQty = criteriaModel.getQty();

            int totalBaseQty = criteriaQty;

            int totalBaseValue = (int) criteriaModel.getAmount();

            if (userBaseQty != null) {

                totalBaseQty = userBaseQty;

                totalBaseValue = userBaseValue;

            }

            int purchasedValue;

            if (createOfferRequest.getTargetType().equals(AchievementType.VALUE)) {

                purchasedValue = totalBaseValue;

            } else {

                purchasedValue = totalBaseQty;

            }

            qtyAmountModel.setQty(totalBaseQty);

            qtyAmountModel.setAmount(totalBaseValue);

            PayoutSlab eligibleSlab = findEligibleSlab(itemCriteriaPayout.getPayoutSlabs(), purchasedValue);

            setSlabProgress(itemCriteriaPayout, eligibleSlab, purchasedValue);

            // For FIXED (per pc) payout, use per-criteria qty not base value

            int sellinValueForFixed = itemCriteriaPayout.getAmountType().equals(AmountType.FIXED) ? criteriaQty : purchasedValue;

            double finalPayout = calculateFinalPayout(eligibleSlab, itemCriteriaPayout.getAmountType(),

                    purchasedValue, sellinValueForFixed);

            qtyAmountModel.setFinalPayout(finalPayout);

        }

        return criteriaQtyAmountMap;

    }

    private Map<Integer, QtyAmountModel> getCriteriaQtyAmountModelMapForSelloutAndActivation(CreateOfferRequest createOfferRequest, int fofoId) {

        Map<Integer, Map<Integer, List<FofoOrderItem>>> criteriaPartnerwiseTertiary = offerRepository.getCriteriaWisePartnerTertiary(createOfferRequest, fofoId);

        Map<Integer, QtyAmountModel> qtyAmountMap;

        final Map<String, LocalDateTime> activatedImeisActivationDateMap;

        qtyAmountMap = new HashMap<>();

        if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {

            //All Serialnumbers for all eligible retailers

            List<String> serialNumbers = criteriaPartnerwiseTertiary.entrySet().stream().flatMap(x -> x.getValue().entrySet().stream().flatMap(foiList -> foiList.getValue().stream()))

                    .flatMap(y -> y.getFofoLineItems().stream()).filter(fli -> fli.getSerialNumber() != null)

                    .map(x -> x.getSerialNumber()).collect(Collectors.toList());

            if (serialNumbers.size() > 0) {

            /*if (imeisAllowedManually != null) {

                serialNumbers = serialNumbers.stream().filter(x -> imeisAllowedManually.contains(x)).collect(Collectors.toList());

            }*/

                activatedImeisActivationDateMap = activatedImeiRepository.selectBySerialNumbers(serialNumbers).stream()

                        .filter(x -> createOfferRequest.isWithinRange(x.getActivationTimestamp()))

                        .collect(Collectors.toMap(x -> x.getSerialNumber(), x -> x.getActivationTimestamp()));

            } else {

                activatedImeisActivationDateMap = null;

            }

        } else {

            activatedImeisActivationDateMap = null;

        }

        QtyAmountModel qtyAmountModel = null;

        if (createOfferRequest.isBaseCriteria()) {

            Map<Integer, List<FofoOrderItem>> baseCriteriaMap = criteriaPartnerwiseTertiary.get(0);

            List<FofoOrderItem> fofoOrderItems = baseCriteriaMap == null ? null : baseCriteriaMap.get(fofoId);

            int totalBaseQty = fofoOrderItems == null ? 0 : fofoOrderItems.stream().filter(x->createOfferRequest.isWithinRange(x.getCreateTimestamp())).collect(Collectors.summingInt(x -> (x.getQuantity())));

            int totalBaseValue = fofoOrderItems == null ? 0 : fofoOrderItems.stream().filter(x->createOfferRequest.isWithinRange(x.getCreateTimestamp())).mapToInt(x -> (Math.round(x.getDp())) * x.getQuantity()).sum();

            qtyAmountModel = new QtyAmountModel(totalBaseQty, totalBaseValue);

            if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {

                Map<Integer, Integer> inventoryItemValueMap = new HashMap<>();

                if (fofoOrderItems != null) {

                    for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

                        fofoOrderItem.getFofoLineItems().stream().filter(x -> x.getSerialNumber() != null).forEach(

                                lineItem -> {

                                    if (activatedImeisActivationDateMap == null || activatedImeisActivationDateMap.containsKey(lineItem.getSerialNumber())) {

                                        inventoryItemValueMap.put(lineItem.getInventoryItemId(), (int) fofoOrderItem.getDp());

                                    }

                                }

                        );

                    }

                }

                qtyAmountModel.setActivationQty(inventoryItemValueMap.size());

                qtyAmountModel.setActivationAmount(inventoryItemValueMap.entrySet().stream().collect(Collectors.summingInt(x -> x.getValue())));

                qtyAmountMap.put(0, qtyAmountModel);

            }

        }

        //CriteriaPayoutWise

        for (ItemCriteriaPayout itemCriteriaPayout : createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts()) {

            int criteriaId = itemCriteriaPayout.getItemCriteria().getId();

            Map<Integer, List<FofoOrderItem>> ordersMap = criteriaPartnerwiseTertiary.get(criteriaId);

            QtyAmountModel criteriaQtyAmountModel = new QtyAmountModel(0, 0);

            qtyAmountMap.put(criteriaId, criteriaQtyAmountModel);

            if (ordersMap == null) continue;

            List<FofoOrderItem> fofoOrderItems = ordersMap.get(fofoId);

            if (fofoOrderItems == null || fofoOrderItems.isEmpty()) continue;

            int totalQty = fofoOrderItems.stream().filter(x -> createOfferRequest.isWithinRange(x.getCreateTimestamp())).collect(Collectors.summingInt(x -> (x.getQuantity())));

            int totalValue = fofoOrderItems.stream().filter(x -> createOfferRequest.isWithinRange(x.getCreateTimestamp())).collect(Collectors.summingInt(x -> Math.round(x.getDp()) * (x.getQuantity())));

            int eligibleQty = totalQty;

            int eligibleValue = totalValue;

            criteriaQtyAmountModel.setQty(totalQty);

            criteriaQtyAmountModel.setAmount(totalValue);

            Map<FofoLineItem, Integer> lineItemValueMap = new HashMap<>();

            if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {

                for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

                    fofoOrderItem.getFofoLineItems().stream().filter(x -> x.getSerialNumber() != null).forEach(

                            lineItem -> {

                                if (activatedImeisActivationDateMap == null) {

                                    lineItemValueMap.put(lineItem, (int) fofoOrderItem.getDp());

                                } else if (activatedImeisActivationDateMap.containsKey(lineItem.getSerialNumber())) {

                                    if (itemCriteriaPayout.isWithinRange(activatedImeisActivationDateMap.get(lineItem.getSerialNumber()))) {

                                        lineItemValueMap.put(lineItem, (int) fofoOrderItem.getDp());

                                    }

                                }

                            }

                    );

                }

                eligibleQty = lineItemValueMap.size();

                eligibleValue = lineItemValueMap.entrySet().stream().collect(Collectors.summingInt(x -> x.getValue()));

                criteriaQtyAmountModel.setActivationQty(eligibleQty);

                criteriaQtyAmountModel.setActivationAmount(eligibleValue);

            }

            int eligibleBaseQty = eligibleQty;

            int eligibleBaseValue = eligibleValue;

            if (createOfferRequest.isBaseCriteria()) {

                eligibleBaseQty = qtyAmountModel.getActivationQty();

                eligibleBaseValue = (int) qtyAmountModel.getActivationAmount();

            }

            int eligibleSale = eligibleBaseValue;

            int eligibleCriteriaSale = eligibleValue;

            int eligibleCriteriaSaleDp = eligibleValue;

            if (createOfferRequest.getTargetType().equals(AchievementType.QUANTITY)) {

                eligibleSale = eligibleBaseQty;

                eligibleCriteriaSale = eligibleQty;

            }

            // For FIXED (per pc) payout, always use qty regardless of target type

            int valueForFixed = itemCriteriaPayout.getAmountType().equals(AmountType.FIXED) ? eligibleQty : eligibleCriteriaSale;

            PayoutSlab eligibleSlab = findEligibleSlab(itemCriteriaPayout.getPayoutSlabs(), eligibleSale);

            setSlabProgress(itemCriteriaPayout, eligibleSlab, eligibleSale);

            double finalPayout = calculateFinalPayout(eligibleSlab, itemCriteriaPayout.getAmountType(),

                    eligibleCriteriaSaleDp, valueForFixed);

            if (eligibleSlab != null) {

                LOGGER.info("Eligible Slab {}", eligibleSlab);

            }

            criteriaQtyAmountModel.setFinalPayout(finalPayout);

            LOGGER.info("Final Payout - {}", finalPayout);

        }

        return qtyAmountMap;

    }

    @Override

    public void processActivationtOffer(CreateOfferRequest createOfferRequest) throws ProfitMandiBusinessException {

        List<OfferPayout> offerPayouts = offerPayoutRepository.selectAllByOfferId(createOfferRequest.getId());

        List<ItemCriteriaPayout> itemCriteriaPayouts = createOfferRequest.getTargetSlabs().get(0).getItemCriteriaPayouts();

        Map<Integer, ItemCriteriaPayout> itemCriteriaPayoutMap = itemCriteriaPayouts.stream().collect(Collectors.toMap(x -> x.getItemCriteria().getId(), x -> x));

        LOGGER.info("itemCriteriaPayoutMap {}", itemCriteriaPayoutMap);

        LOGGER.info("offerPayouts {}", offerPayouts);

        Map<Integer, Map<Integer, Double>> fixedSlabCriteriaPartnerMap = offerPayouts.stream().filter(x -> itemCriteriaPayoutMap.get((int) x.getCriteriaId()).getAmountType().equals(AmountType.SLAB_FIXED))

                .collect(Collectors.groupingBy(x -> (int) x.getCriteriaId(), Collectors.groupingBy(x -> (int) x.getFofoId(), Collectors.summingDouble(x -> x.getSlabAmount()))));

        Map<String, Double> serialNumberPaid = offerPayouts.stream().filter(x -> x.getRejectTimestamp() == null).collect(Collectors.groupingBy(x -> x.getSerialNumber(), Collectors.summingDouble(x -> x.getSlabAmount())));

        Map<Integer, Map<Integer, List<FofoOrderItem>>> criteriaPartnerwiseTertiary = offerRepository.getCriteriaWisePartnerTertiary(createOfferRequest);

        Map<String, AgeingSummaryModel> ageingSummaryModelsMap = null;

        final Map<String, LocalDateTime> activatedImeisActivationDateMap;

        //Find Only eligible imeis if any

        List<String> imeisAllowedManually = offerEligibleImeiRepository.selectEligibleImeisByOfferId(createOfferRequest.getId());

        if (createOfferRequest.getSchemeType().equals(OfferSchemeType.ACTIVATION)) {

            //All Serialnumbers for all eligible retailers

            List<String> serialNumbers = criteriaPartnerwiseTertiary.entrySet().stream().flatMap(x -> x.getValue().entrySet().stream().flatMap(foiList -> foiList.getValue().stream()))

                    .flatMap(y -> y.getFofoLineItems().stream()).filter(fli -> fli.getSerialNumber() != null)