Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.scheme;

import com.spice.profitmandi.common.enumuration.ItemType;

import com.spice.profitmandi.common.enumuration.MessageType;

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

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

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

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

import com.spice.profitmandi.common.services.ReporticoService;

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

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

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

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

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

import com.spice.profitmandi.dao.entity.inventory.PartnerAgeingModel;

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

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

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

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

import com.spice.profitmandi.dao.enumuration.fofo.ScanType;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.authentication.RoleManager;

import com.spice.profitmandi.service.inventory.AgeingService;

import com.spice.profitmandi.service.inventory.PurchaseService;

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

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

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

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

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

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.query.Query;

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

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

import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Component;

import javax.persistence.TypedQuery;

import javax.persistence.criteria.CriteriaBuilder;

import javax.persistence.criteria.CriteriaQuery;

import javax.persistence.criteria.Predicate;

import javax.persistence.criteria.Root;

import java.text.MessageFormat;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.YearMonth;

import java.util.*;

import java.util.function.Function;

import java.util.stream.Collectors;

@Component

public class SchemeServiceImpl implements SchemeService {

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

    private static final Set<Integer> tagIds = new HashSet<>(Arrays.asList(4));

    private static final List<String> BLOCKED_IMEIS = Arrays.asList("864883056397593", "864883054606656", "864883056567815", "861950056518271", "869175055649511", "861362058924574", "866009066803036", "866009066816699", "866009066816137", "866009066815873", "866009066805536", "866009066803010", "866009066821939", "866009066802756", "866009066820592", "866009066820311", "866009066816491", "866009066816376", "866009066815899", "866009066815774", "866009066817937", "866009066819859", "866009066817655", "866009066820691", "866009066820832", "866009066803291", "866009066820733", "866009066814496", "866009066820451", "866009066820659", "866009066804976", "866009066820717", "866009066816095", "861362054898434", "869599051117852", "869599056695332", "869599056695894", "864883057389656", "862661052418692", "860118051929254", "862888051664998", "862680054625831", "862888051666316", "860118051738895", "868066050447970", "868066052424399", "865084051552576", "865084050755097", "865084050755295", "865084050754819", "864883057487278", "864883057389599", "864883057437455", "864883057388278", "862680058278058", "869599056810139", "862200053994193", "861932057188916", "861175050581774", "863933065909093", "863933065635391", "861362054889177", "864004062055154", "864004062069239", "862661050221676", "862661052416993", "866812058631475", "869599051118173", "869599051504273", "868066052729250", "864883057701397", "864883054123033", "864883054947316", "864883056235694", "868066052727692", "866030052139896", "866030052140175", "860588051522053", "860588051513193", "861932056969779", "869599056171995", "865594061074932", "863935059410491", "866088059072718", "869599055375894", "869599054306916", "863782054006472", "863782054012371", "860588053486992", "868066052726835", "868066052726694", "860688053876430", "860688053869674", "868494052222110", "868494054682394", "869599053512357");

    private static final List<SchemeType> ACTIVATION_SCHEME_TYPES = Arrays.asList(SchemeType.ACTIVATION, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT);

    @Autowired

    StateGstRateRepository stateGstRateRepository;

    @Autowired

    NotificationService notificationService;

    @Autowired

    @Qualifier("fofoInventoryItemRepository")

    private InventoryItemRepository inventoryItemRepository;

    @Autowired

    private ActivatedImeiRepository activatedImeiRepository;

    @Autowired

    private PartnerTypeChangeService partnerTypeChangeService;

    @Autowired

    private PurchaseService purchaseService;

    @Autowired

    private ScanRecordRepository scanRecordRepository;

    @Autowired

    private SessionFactory sessionFactory;

    @Autowired

    private SchemeRepository schemeRepository;

    @Autowired

    private PriceDropRepository priceDropRepository;

    @Autowired

    private RoleManager roleManager;

    @Autowired

    private RetailerRepository retailerRepository;

    @Autowired

    private ReporticoService reporticoService;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private SchemeInOutRepository schemeInOutRepository;

    @Autowired

    @Qualifier("catalogItemRepository")

    private ItemRepository itemRepository;

    @Autowired

    private SchemeItemRepository schemeItemRepository;

    @Autowired

    private SchemeRegionRepository schemeRegionRepository;

    @Autowired

    private WalletService walletService;

    @Autowired

    private PurchaseRepository purchaseRepository;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private PriceCircularService priceCircularService;

    @Override

    public void saveScheme(int creatorId, CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {

        this.validateCreateSchemeRequest(createSchemeRequest);

        Scheme scheme = this.toScheme(creatorId, createSchemeRequest);

        if (scheme.getStartDateTime().isAfter(scheme.getEndDateTime())) {

            throw new ProfitMandiBusinessException(

                    ProfitMandiConstants.START_DATE + ", " + ProfitMandiConstants.END_DATE,

                    scheme.getStartDateTime() + ", " + scheme.getEndDateTime(), "SCHM_VE_1005");

        }

        // this.validateItemIds(createSchemeRequest);

        schemeRepository.persist(scheme);

        for (int catalogId : createSchemeRequest.getCatalogIds()) {

            SchemeItem schemeItem = new SchemeItem();

            schemeItem.setSchemeId(scheme.getId());

            schemeItem.setCatalogId(catalogId);

            schemeItemRepository.persist(schemeItem);

        }

        for (int regionId : createSchemeRequest.getRegionIds()) {

            SchemeRegion schemeRegion = new SchemeRegion();

            schemeRegion.setSchemeId(scheme.getId());

            schemeRegion.setRegionId(regionId);

            schemeRegionRepository.persist(schemeRegion);

        }

    }

    private void validateCreateSchemeRequest(CreateSchemeRequest createSchemeRequest)

            throws ProfitMandiBusinessException {

        if (createSchemeRequest.getName() == null || createSchemeRequest.getName().isEmpty()) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.NAME, createSchemeRequest.getName(),

                    "SCHM_VE_1000");

        }

        if (createSchemeRequest.getAmount() <= 0) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),

                    "SCHM_VE_1001");

        }

        if (createSchemeRequest.getAmountType().equals(AmountType.PERCENTAGE)

                && createSchemeRequest.getAmount() > 100) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.AMOUNT, createSchemeRequest.getAmount(),

                    "SCHM_VE_1002");

        }

        if (createSchemeRequest.getStartDate() == null) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.START_DATE, createSchemeRequest.getStartDate(),

                    "SCHM_VE_1003");

        }

        if (createSchemeRequest.getEndDate() == null) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.END_DATE, createSchemeRequest.getEndDate(),

                    "SCHM_VE_1004");

        }

    }

    private void validateItemIds(CreateSchemeRequest createSchemeRequest) throws ProfitMandiBusinessException {

        if (createSchemeRequest.getCatalogIds() == null || createSchemeRequest.getCatalogIds().isEmpty()) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getCatalogIds(),

                    "SCHM_1003");

        }

        List<Integer> foundItemIds = itemRepository.selectIdsByIdsAndType(createSchemeRequest.getCatalogIds(),

                ItemType.SERIALIZED);

        if (foundItemIds.size() != createSchemeRequest.getCatalogIds().size()) {

            createSchemeRequest.getCatalogIds().removeAll(foundItemIds);

            throw new ProfitMandiBusinessException(ProfitMandiConstants.ITEM_ID, createSchemeRequest.getCatalogIds(),

                    "SCHM_1004");

        }

    }

    @Override

    public Scheme getSchemeById(int schemeId) throws ProfitMandiBusinessException {

        Scheme scheme = schemeRepository.selectById(schemeId);

        List<Integer> catalogIds = schemeItemRepository.selectCatalogIdsBySchemeId(scheme.getId());

        if (catalogIds.size() > 0) {

            List<Item> items = itemRepository.selectAllByCatalogIds(new HashSet<>(catalogIds));

            scheme.setCatalogStringMap(this.toCatalogStringMap(items));

        }

        return scheme;

    }

    public Map<Integer, String> toCatalogStringMap(List<Item> items) {

        Map<Integer, String> catalogMap = new HashMap<>();

        for (Item item : items) {

            if (!catalogMap.containsKey(item.getCatalogItemId())) {

                catalogMap.put(item.getCatalogItemId(), item.getItemDescriptionNoColor());

            }

        }

        return catalogMap;

    }

    private Set<Integer> schemeItemsToCatalogIds(List<SchemeItem> schemeItems) {

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

        for (SchemeItem schemeItem : schemeItems) {

            catalogId.add(schemeItem.getCatalogId());

        }

        return catalogId;

    }

    @Override

    public List<SchemeModel> getAllSchemeModels(LocalDateTime startDateTime, LocalDateTime endDateTime) {

        List<Scheme> schemes = schemeRepository.selectAllBetweenCreateTimestamp(startDateTime, endDateTime);

        Map<Integer, Scheme> schemeIdSchemeMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(schemeIdSchemeMap.keySet());

        Set<Integer> catalogIds = schemeItems.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());

        List<Item> items = itemRepository.selectAllByCatalogIds(catalogIds);

        Map<Integer, String> catalogStringMap = this.toCatalogStringMap(items);

        this.addCatalogIdsToSchemes(schemeItems, schemeIdSchemeMap, catalogStringMap);

        return this.toSchemeModels(schemeIdSchemeMap);

    }

    private List<SchemeModel> toSchemeModels(Map<Integer, Scheme> schemeIdSchemeMap) {

        List<SchemeModel> schemeModels = new ArrayList<>();

        for (Map.Entry<Integer, Scheme> schemeIdSchemeEntry : schemeIdSchemeMap.entrySet()) {

            schemeModels.add(this.toSchemeModel(schemeIdSchemeEntry.getValue()));

        }

        return schemeModels;

    }

    private SchemeModel toSchemeModel(Scheme scheme) {

        SchemeModel schemeModel = new SchemeModel();

        schemeModel.setSchemeId(scheme.getId());

        schemeModel.setName(scheme.getName());

        schemeModel.setDescription(scheme.getDescription());

        schemeModel.setSchemeType(scheme.getType().toString());

        schemeModel.setAmountType(scheme.getAmountType().toString());

        schemeModel.setAmount(scheme.getAmount());

        schemeModel.setStartDateTime(StringUtils.toString(scheme.getStartDateTime()));

        schemeModel.setEndDateTime(StringUtils.toString(scheme.getEndDateTime()));

        schemeModel.setCreateTimestamp(StringUtils.toString(scheme.getCreateTimestamp()));

        schemeModel.setActiveTimestamp(StringUtils.toString(scheme.getActiveTimestamp()));

        schemeModel.setExpireTimestamp(StringUtils.toString(scheme.getExpireTimestamp()));

        schemeModel.setCreatedBy(scheme.getCreatedBy());

        schemeModel.setCatalogStringMap(scheme.getCatalogStringMap());

        schemeModel.setRetailerIds(scheme.getRetailerIds());

        return schemeModel;

    }

    private void addCatalogIdsToSchemes(List<SchemeItem> schemeItems, Map<Integer, Scheme> schemeIdSchemeMap,

                                        Map<Integer, String> catalogStringMap) {

        for (SchemeItem schemeItem : schemeItems) {

            Scheme scheme = schemeIdSchemeMap.get(schemeItem.getSchemeId());

            scheme.getCatalogStringMap().put(schemeItem.getCatalogId(), catalogStringMap.get(schemeItem.getCatalogId()));

        }

    }

    @Override

    public void activeSchemeById(int schemeId) throws ProfitMandiBusinessException {

        Scheme scheme = schemeRepository.selectById(schemeId);

        if (scheme.getActiveTimestamp() != null) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),

                    "SCHM_1005");

        }

        if (scheme.getExpireTimestamp() != null) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),

                    "SCHM_1006");

        }

        scheme.setActiveTimestamp(LocalDateTime.now());

        this.sendSchemeNotification(scheme);

        /*

         * if (scheme.getType() == SchemeType.IN) {

         * this.processPreviousPurchases(scheme); } else if (scheme.getType() ==

         * SchemeType.OUT) { this.processPreviousSales(scheme); }

         */

    }

    private void sendSchemeNotification(Scheme scheme) throws ProfitMandiBusinessException {

        if (ACTIVATION_SCHEME_TYPES.contains(scheme.getType())) {

            SendNotificationModel sendNotificationModel = new SendNotificationModel();

            List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIds(Collections.singleton(scheme.getId()));

            Set<Integer> catalogIds = schemeItems.stream().map(x -> x.getCatalogId()).collect(Collectors.toSet());

            List<String> itemDescriptions = itemRepository.selectAllByCatalogIds(catalogIds).stream().filter(Utils.distinctByKey(Item::getCatalogItemId))

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

            String titleTemplate = "%s of Rs.%s for %s";

            String schemeString = "Activation scheme";

            if (scheme.getType().equals(SchemeType.SPECIAL_SUPPORT)) {

                schemeString = "Special Support";

            }

            String message = "Duration from - " + FormattingUtils.formatDateMonth(scheme.getStartDateTime()) + " - " + FormattingUtils.formatDateMonth(scheme.getEndDateTime());

            sendNotificationModel.setCampaignName("activationscheme");

            sendNotificationModel.setUrl("https://app.smartdukaan.com/pages/home/scheme/" + scheme.getId());

            sendNotificationModel.setExpiresat(LocalDateTime.now().plusDays(1));

            sendNotificationModel.setMessage(message);

            sendNotificationModel.setTitle(String.format(titleTemplate, schemeString, FormattingUtils.formatDecimal(scheme.getAmount()), org.apache.commons.lang3.StringUtils.abbreviate(String.join(", ", itemDescriptions), 25)));

            sendNotificationModel.setType("url");

            sendNotificationModel.setMessageType(MessageType.scheme);

            notificationService.sendNotificationToAll(sendNotificationModel);

        }

    }

    @Override

    public void expireSchemeById(int schemeId, LocalDateTime expiryTime) throws ProfitMandiBusinessException {

        Scheme scheme = schemeRepository.selectById(schemeId);

        if (scheme == null || scheme.getActiveTimestamp() == null) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.ACTIVE_TIMESTAMP, scheme.getActiveTimestamp(),

                    "SCHM_1007");

        }

        if (scheme.getExpireTimestamp() != null) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),

                    "SCHM_1008");

        }

        scheme.setExpireTimestamp(LocalDateTime.now());

        if (expiryTime.isAfter(scheme.getEndDateTime())) {

            throw new ProfitMandiBusinessException(ProfitMandiConstants.EXPIRE_TIMESTAMP, scheme.getExpireTimestamp(),

                    "End Date cant be extended during expiry");

        }

        scheme.setEndDateTime(expiryTime);

        schemeRepository.persist(scheme);

    }

    private Map<Integer, Scheme> toSchemeIdSchemeMap(List<Scheme> schemes) {

        Map<Integer, Scheme> schemeIdSchemeMap = new HashMap<>();

        for (Scheme scheme : schemes) {

            schemeIdSchemeMap.put(scheme.getId(), scheme);

        }

        return schemeIdSchemeMap;

    }

    private Map<Integer, Set<Scheme>> toCatalogIdSchemesMap(List<SchemeItem> schemeItems, List<Scheme> schemes) {

        Map<Integer, Scheme> schemesMap = schemes.stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        Map<Integer, Set<Scheme>> catalogSchemesMap = new HashMap<>();

        for (SchemeItem schemeItem : schemeItems) {

            if (!catalogSchemesMap.containsKey(schemeItem.getCatalogId())) {

                catalogSchemesMap.put(schemeItem.getCatalogId(), new HashSet<>());

            }

            Set<Scheme> schemesSet = catalogSchemesMap.get(schemeItem.getCatalogId());

            schemesSet.add(schemesMap.get(schemeItem.getSchemeId()));

        }

        return catalogSchemesMap;

    }

    private Map<InventoryItem, Set<Scheme>> toInventoryItemSchemesMap(List<Scheme> schemes,

                                                                      List<InventoryItem> inventoryItems) {

        Set<Integer> schemeIds = schemes.stream().map(x -> x.getId()).collect(Collectors.toSet());

        Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());

        Set<Integer> catalogIds = itemRepository.selectByIds(itemIds).stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());

        List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeIdsAndCatalogIds(schemeIds, catalogIds);

        Map<Integer, Set<Scheme>> catalogIdSchemesMap = this.toCatalogIdSchemesMap(schemeItems, schemes);

        Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = new HashMap<>();

        for (InventoryItem inventoryItem : inventoryItems) {

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

            LOGGER.info("inventoryItem.getItem() {}", inventoryItem.getItem());

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

            if (catalogIdSchemesMap.containsKey(inventoryItem.getItem().getCatalogItemId())) {

                inventoryItemSchemesMap.put(inventoryItem, catalogIdSchemesMap.get(inventoryItem.getItem().getCatalogItemId()));

            }

        }

        return inventoryItemSchemesMap;

    }

    @Autowired

    OfferTargetSlabRepository offerTargetSlabRepository;

    /*@Override

    public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {

        LOGGER.info("Trying to process SchemeIn with purchaseId [{}] and retailerId [{}]", purchaseId, retailerId);

        Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);

        // TODO - SCHEME

        PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,

                YearMonth.from(purchase.getCreateTimestamp()));

        // PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId,

        // purchase.getCreateTimestamp().toLocalDate());

        List<Scheme> schemes = schemeRepository.selectActiveAll(Arrays.asList(SchemeType.IN), partnerType,

                purchase.getCreateTimestamp().toLocalDate(), false);

        List<Integer> validSchemeIds = schemeRepository.selectSchemesByRetailerIdsSchemeIds(retailerId, schemes.stream().map(x -> x.getId()).collect(Collectors.toList()));

        schemes = schemes.stream().filter(x -> validSchemeIds.contains(x.getId())).collect(Collectors.toList());

        float totalCashback = 0;

        if (schemes.isEmpty()) {

            return;

        }

        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);

        //Remove imeis from blocked imeis list

        inventoryItems = inventoryItems.stream().filter(inventoryItem -> !BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())).collect(Collectors.toList());

        if (inventoryItems.size() == 0) return;

        Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());

        Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        inventoryItems.stream().forEach(x -> x.setItem(itemsMap.get(x.getItemId())));

        LocalDateTime billingDate = purchaseService.getBillingDateOfPurchase(purchaseId);

        Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()

                .filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(billingDate)).map(x -> x.getItemId())

                .collect(Collectors.toSet());

        // Only consider inventory items that were not returned

        inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))

                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD))

                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());

        LOGGER.info(inventoryItems);

        if (inventoryItems.size() == 0)

            return;

        Map<InventoryItem, Set<Scheme>> inventoryItemSchemesMap = this.toInventoryItemSchemesMap(schemes,

                inventoryItems);

        if (inventoryItemSchemesMap.isEmpty()) {

            return;

        }

        Map<InventoryItem, Set<Scheme>> allInventoryItemSchemesMap = new HashMap<>();

        for (Map.Entry<InventoryItem, Set<Scheme>> inventoryItemSchemesEntry : inventoryItemSchemesMap.entrySet()) {

            Set<Scheme> allSchemes = new HashSet<>();

            for (Scheme scheme : inventoryItemSchemesEntry.getValue()) {

                allSchemes.add(scheme);

            }

            allInventoryItemSchemesMap.put(inventoryItemSchemesEntry.getKey(), allSchemes);

        }

        //

        int itemsCount = 0;

        for (Map.Entry<InventoryItem, Set<Scheme>> allInventoryItemSchemesEntry : allInventoryItemSchemesMap

                .entrySet()) {

            float inventoryItemCashback = 0;

            for (Scheme scheme : allInventoryItemSchemesEntry.getValue()) {

                InventoryItem inventoryItem = allInventoryItemSchemesEntry.getKey();

                float cashback = this.createSchemeInOut(null, inventoryItem, partnerType);

                inventoryItemCashback += cashback;

            }

            if (inventoryItemCashback > 0) {

                totalCashback += inventoryItemCashback;

                itemsCount++;

            }

        }

        LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);

        if (itemsCount > 0) {

            walletService.addAmountToWallet(

                    retailerId, purchaseId, WalletReferenceType.SCHEME_IN, "Added for SCHEME IN against invoice "

                            + purchase.getPurchaseReference() + " (total " + itemsCount + " pcs)",

                    totalCashback, purchase.getCreateTimestamp());

            LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,

                    purchase.getPurchaseReference(), itemsCount);

            purchase.setCashback(purchase.getCashback() + totalCashback);

            purchaseRepository.persist(purchase);

        }

    }*/

    private Scheme toScheme(int creatorId, CreateSchemeRequest createSchemeRequest) {

        Scheme scheme = new Scheme();

        scheme.setName(createSchemeRequest.getName());

        scheme.setDescription(createSchemeRequest.getDescription());

        scheme.setType(createSchemeRequest.getType());

        scheme.setAmountType(createSchemeRequest.getAmountType());

        scheme.setAmount(createSchemeRequest.getAmount());

        scheme.setPartnerType(createSchemeRequest.getPartnerType());

        scheme.setStartDateTime(createSchemeRequest.getStartDate());

        scheme.setEndDateTime(createSchemeRequest.getEndDate());

        scheme.setCreatedBy(creatorId);

        scheme.setCashback(createSchemeRequest.isCashback());

        return scheme;

    }

    @Autowired

    OfferRepository offerRepository;

    @Autowired

    OfferPayoutRepository offerPayoutRepository;

    @Autowired

    AgeingService ageingService;

    public void processSchemeIn(int purchaseId, int retailerId) throws ProfitMandiBusinessException {

        Purchase purchase = purchaseRepository.selectByIdAndFofoId(purchaseId, retailerId);

        PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,

                YearMonth.from(purchase.getCreateTimestamp()));

        List<InventoryItem> inventoryItems = inventoryItemRepository.selectByPurchaseId(purchaseId);

        //Remove imeis from blocked imeis list

        inventoryItems = inventoryItems.stream().filter(inventoryItem -> !BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())).collect(Collectors.toList());

        if (inventoryItems.size() == 0) return;

        Set<Integer> itemIds = inventoryItems.stream().map(x -> x.getItemId()).collect(Collectors.toSet());

        Map<Integer, Item> itemsMap = itemRepository.selectByIds(itemIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

        inventoryItems.stream().forEach(x -> x.setItem(itemsMap.get(x.getItemId())));

        LocalDateTime billingDate = purchaseService.getBillingDateOfPurchase(purchaseId);

        Set<Integer> itemIdsSet = tagListingRepository.selectByItemIdsAndTagIds(itemIds, tagIds).stream()

                .filter(x -> x.getEolDate() == null || x.getEolDate().isAfter(billingDate)).map(x -> x.getItemId())

                .collect(Collectors.toSet());

        // Only consider inventory items that were not returned and not eol

        inventoryItems = inventoryItems.stream().filter(x -> itemIdsSet.contains(x.getItemId()))

                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET_BAD))

                .filter(x -> !x.getLastScanType().equals(ScanType.PURCHASE_RET)).collect(Collectors.toList());

        if (inventoryItems.size() == 0) return;

        Map<Integer, List<InventoryItem>> catalogInventoryItemMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getItem().getCatalogItemId()));

        Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSchemeSummaryMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(retailerId,

                partnerType, new ArrayList<>(catalogInventoryItemMap.keySet()), purchase.getCreateTimestamp());

        int itemsCount = 0;

        float totalCashback = 0;

        for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogSchemeSummaryMap.entrySet()) {

            CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();

            List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue();

            schemeSummaryModels.stream().filter(x -> x.getSchemeType().equals(SchemeType.IN)).forEach(x -> x.setProcess(true));

            if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;

            List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());

            for (InventoryItem inventoryItem : modelInventoryItems) {

                float inventoryItemCashback = this.createSchemeInOut(schemeSummaryModels, inventoryItem, partnerType);

                if (inventoryItemCashback > 0) {

                    itemsCount++;

                    totalCashback += inventoryItemCashback;

                }

            }

        }

        LOGGER.info("Items count for purchase id {} is {}", purchaseId, itemsCount);

        if (itemsCount > 0) {

            walletService.addAmountToWallet(

                    retailerId, purchaseId, WalletReferenceType.SCHEME_IN, "Added for SCHEME IN against invoice "

                            + purchase.getPurchaseReference() + " (total " + itemsCount + " pcs)",

                    totalCashback, purchase.getCreateTimestamp());

            LOGGER.info("Added Rs.{} for SCHEME IN against invoice {} total pcs({}) {}", totalCashback,

                    purchase.getPurchaseReference(), itemsCount);

        }

    }

    // We are maintaining price drop after grn

    private float getAmount(InventoryItem inventoryItem, Scheme scheme) throws ProfitMandiBusinessException {

        if (BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())) {

            return 0;

        }

        float amount = 0;

        float dpForCalc = 0;

        float taxableSellingPrice = 0;

        //float totalTaxRate = stateGstRateRepository.getTotalTaxRate(inventoryItem.getItemId());

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

            if (scheme.getType().equals(SchemeType.IN)) {

                dpForCalc = inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount();

            } else {

                try {

                    dpForCalc = Math.min(inventoryItem.getUnitPrice() - inventoryItem.getPriceDropAmount(),

                            tagListingRepository.selectByItemId(inventoryItem.getItemId()).getSellingPrice());

                } catch (Exception e) {

                    LOGGER.info("Could not find tag Listing entry in {}", inventoryItem.getItemId());

                    e.printStackTrace();

                }

            }

            //TODO:Should be calculated on unit price

            //taxableSellingPrice = dpForCalc / (1 + totalTaxRate / 100);

            //amount = taxableSellingPrice * scheme.getAmount() / 100;

            amount = dpForCalc * scheme.getAmount() / 100;

            System.out.println(String.format("%d\t%s\t%d\t%d\t%s\t%s\t%s\t%s\t%f\t%f\t%f\t%f", inventoryItem.getId(),

                    inventoryItem.getSerialNumber(), inventoryItem.getItemId(), scheme.getId(), scheme.getName(),

                    scheme.getType(), scheme.getAmountType(), scheme.getPartnerType(), dpForCalc, taxableSellingPrice,

                    scheme.getAmount(), amount));

        } else if (scheme.getType().equals(SchemeType.IN)) {

            amount = scheme.getAmount();

        }

        return amount;

    }

    //Only in and activation margins are allowed to be rolled out more than twice

    private float createSchemeInOut(List<SchemeSummaryModel> schemeSummaryModels, InventoryItem inventoryItem, PartnerType partnerType) throws ProfitMandiBusinessException {

        InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(inventoryItem);

        //Get all schemes

        List<SchemeSummaryModel> inventoryPayoutModelToProcess = schemeSummaryModels.stream().filter(x -> x.isProcess()).collect(Collectors.toList());

        float actualCredit = 0;

        List<SchemeInOut> sios = inventoryPayoutModel.getSchemePayouts();

        Map<SchemeType, List<SchemeInOut>> paidSchemeTypesMap = inventoryPayoutModel.getSchemePayouts().stream().collect(Collectors.groupingBy(x -> x.getScheme().getType()));

        Map<Integer, SchemeInOut> paidSchemesMap = sios.stream().collect(Collectors.toMap(x -> x.getSchemeId(), x -> x));

        double percentageToPay = 0d;

        double fixedToPay = 0d;

        Map<SchemeSummaryModel, AmountModel> payoutSchemeSummaryModelMap = new HashMap<>();

        for (SchemeSummaryModel schemeSummaryModelToProcess : inventoryPayoutModelToProcess) {

            if (paidSchemesMap.containsKey(schemeSummaryModelToProcess.getSchemeId())) continue;

            //If different type but on higher side provide the higher margin

            if (Arrays.asList(SchemeType.ACTIVATION, SchemeType.SPECIAL_SUPPORT).contains(schemeSummaryModelToProcess.getSchemeType())) {

                SchemeInOut sio = new SchemeInOut();

                sio.setAmount(0);

                sio.setInventoryItemId(inventoryItem.getId());

                sio.setSchemeId(schemeSummaryModelToProcess.getSchemeId());

                sio.setStatusDescription("Activation pending for IMEI#" + inventoryItem.getSerialNumber());

                sio.setStatus(SchemePayoutStatus.PENDING);

                schemeInOutRepository.persist(sio);

            } else if (!SchemeType.IN.equals(schemeSummaryModelToProcess.getSchemeType())) {

                //We have got non repeating scheme type

                if (paidSchemeTypesMap.containsKey(schemeSummaryModelToProcess.getSchemeType())) {

                    SchemeInOut sio = paidSchemeTypesMap.get(schemeSummaryModelToProcess.getSchemeType()).get(0);

                    Scheme paidScheme = sio.getScheme();

                    //Don't entertain if amount types do not match for same type

                    if (paidScheme.getAmountType().equals(schemeSummaryModelToProcess.getAmountType()) &&

                            schemeSummaryModelToProcess.getAmount() > paidScheme.getAmount() + Utils.DOUBLE_EPSILON) {

                        sio.setRolledBackTimestamp(LocalDateTime.now());

                        sio.setStatus(SchemePayoutStatus.REJECTED);

                        sio.setStatusDescription("Eligible for higher margin for " + sio.getSchemeType() + " new entry added");

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

                            percentageToPay += schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount();

                        } else {

                            fixedToPay += schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount();

                        }

                        payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount() - paidScheme.getAmount(), schemeSummaryModelToProcess.getAmountType()));

                    }

                } else {

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

                        percentageToPay += schemeSummaryModelToProcess.getAmount();

                    } else {

                        fixedToPay += schemeSummaryModelToProcess.getAmount();

                    }

                    payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount(), schemeSummaryModelToProcess.getAmountType()));

                }

            } else {

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

                    percentageToPay += schemeSummaryModelToProcess.getAmount();

                } else {

                    fixedToPay += schemeSummaryModelToProcess.getAmount();

                }

                payoutSchemeSummaryModelMap.put(schemeSummaryModelToProcess, new AmountModel(schemeSummaryModelToProcess.getAmount(), schemeSummaryModelToProcess.getAmountType()));

            }

        }

        double walletCredit = 0d;

        if (fixedToPay > 0) {

            double fixedRollout = fixedToPay * (100 / (100 + inventoryPayoutModel.getPercentageAmount()));

            for (Map.Entry<SchemeSummaryModel, AmountModel> schemeSummaryModelAmountModelEntry : payoutSchemeSummaryModelMap.entrySet()) {

                SchemeSummaryModel schemeSummaryModel = schemeSummaryModelAmountModelEntry.getKey();

                AmountModel amountModel = schemeSummaryModelAmountModelEntry.getValue();

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

                    SchemeInOut sio = new SchemeInOut();

                    sio.setSchemeId(schemeSummaryModel.getSchemeId());

                    sio.setInventoryItemId(inventoryItem.getId());

                    sio.setStatus(SchemePayoutStatus.CREDITED);

                    sio.setCreditTimestamp(LocalDateTime.now());

                    sio.setAmount((float) (fixedRollout * amountModel.getAmount() / fixedToPay));

                    if (schemeSummaryModel.getSchemeType().equals(SchemeType.IN))

                        sio.setStatusDescription("Credited for GRN of IMEI-" + inventoryItem.getSerialNumber());

                    else

                        sio.setStatusDescription("Credited for Sale of IMEI-" + inventoryItem.getSerialNumber());

                    schemeInOutRepository.persist(sio);

                }

            }

            walletCredit += fixedRollout;

        }

        if (percentageToPay > 0) {

            double effectiveDP = inventoryPayoutModel.getDp() - (inventoryPayoutModel.getFixedAmount() + fixedToPay);

            double totalPercentage = inventoryPayoutModel.getPercentageAmount() + percentageToPay;

            double percentageRollout = effectiveDP * (totalPercentage / (100 + totalPercentage) - (inventoryPayoutModel.getPercentageAmount() / (100 + inventoryPayoutModel.getPercentageAmount())));

            for (Map.Entry<SchemeSummaryModel, AmountModel> schemeSummaryModelAmountModelEntry : payoutSchemeSummaryModelMap.entrySet()) {

                SchemeSummaryModel schemeSummaryModel = schemeSummaryModelAmountModelEntry.getKey();

                AmountModel amountModel = schemeSummaryModelAmountModelEntry.getValue();

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

                    SchemeInOut sio = new SchemeInOut();

                    sio.setInventoryItemId(inventoryItem.getId());

                    sio.setSchemeId(schemeSummaryModel.getSchemeId());

                    sio.setStatus(SchemePayoutStatus.CREDITED);

                    sio.setCreditTimestamp(LocalDateTime.now());

                    sio.setAmount((float) (percentageRollout * amountModel.getAmount() / percentageToPay));

                    if (schemeSummaryModel.getSchemeType().equals(SchemeType.IN))

                        sio.setStatusDescription("Credited for GRN of IMEI-" + inventoryItem.getSerialNumber());

                    else

                        sio.setStatusDescription("Credited for Sale of IMEI-" + inventoryItem.getSerialNumber());

                    schemeInOutRepository.persist(sio);

                }

            }

            walletCredit += percentageRollout;

        }

        return (float) walletCredit;

    }

    private Set<Integer> filterImeisByAgeing(Set<Integer> inventoryItemIds, FofoOrder fofoOrder) {

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

        List<PartnerAgeingModel> partnerAgeingModels = ageingService.filterAgedInventory(inventoryItemIds);

        for (PartnerAgeingModel partnerAgeingModel : partnerAgeingModels) {

            LOGGER.info("Serial Number - {}", partnerAgeingModel.getSerialNumber());

            if (partnerAgeingModel.getBrand().equalsIgnoreCase("Samsung")) {

                ActivatedImei activatedImei = activatedImeiRepository.selectBySerialNumber(partnerAgeingModel.getSerialNumber());

                if (activatedImei != null && activatedImei.getActivationTimestamp().toLocalDate()

                        .isBefore(partnerAgeingModel.getBillingDate().plusDays(partnerAgeingModel.getMaxAgeingDays()))) {

                    //Lets give money if activation is there and is before the ageing limit of that brand.

                    filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());

                } else {

                    //If billing happens before ageing expiry

                    if (fofoOrder.getCreateTimestamp().toLocalDate().isBefore(partnerAgeingModel.getBillingDate().plusDays(partnerAgeingModel.getMaxAgeingDays()))) {

                        filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());

                    }

                }

            } else {

                filteredInventoryIds.add(partnerAgeingModel.getInventoryItemId());

            }

        }

        return filteredInventoryIds;

    }

    @Override

    public float processSchemeOut(int fofoOrderId, int retailerId) throws ProfitMandiBusinessException {

        float totalCashback = 0;

        FofoOrder fofoOrder = fofoOrderRepository.selectByFofoIdAndOrderId(retailerId, fofoOrderId);

        // Process only if order is not cancelled

        if (fofoOrder.getCancelledTimestamp() == null) {

            // PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(retailerId,

            // fofoOrder.getCreateTimestamp().toLocalDate());

            // TODO - SCHEME

            PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,

                    YearMonth.from(fofoOrder.getCreateTimestamp()));

            List<ScanRecord> scanRecords = scanRecordRepository.selectAllByOrderId(fofoOrderId);

            if (scanRecords.size() == 0) return 0;

            Set<Integer> inventoryItemIds = scanRecords.stream().map(x -> x.getInventoryItemId())

                    .collect(Collectors.toSet());

            //Check for ageing

            //inventoryItemIds = this.filterImeisByAgeing(inventoryItemIds, fofoOrder);

            //ageingService.filterAgedInventory(inventoryItemIds);

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

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

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

            if (inventoryItemIds.size() == 0) return 0;

            Set<InventoryItem> inventoryItems = inventoryItemRepository.selectByIds(inventoryItemIds).stream()

                    .filter(x -> x.getSerialNumber() != null && !x.getSerialNumber().equals(""))

                    .collect(Collectors.toSet());

            inventoryItems = inventoryItems.stream().filter(inventoryItem -> !BLOCKED_IMEIS.contains(inventoryItem.getSerialNumber())).collect(Collectors.toSet());

            if (inventoryItems.size() == 0) return 0;

            Map<Integer, List<InventoryItem>> catalogInventoryItemMap = inventoryItems.stream().collect(Collectors.groupingBy(x -> x.getItem().getCatalogItemId()));

            Map<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSchemeSummaryMap = tagListingRepository.getModelSchemesByCatalogIdsAndType(retailerId,

                    partnerType, new ArrayList<>(catalogInventoryItemMap.keySet()), fofoOrder.getCreateTimestamp());

            int count = 0;

            for (Map.Entry<CatalogSummaryModel, List<SchemeSummaryModel>> catalogSummaryModelListEntry : catalogSchemeSummaryMap.entrySet()) {

                CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();

                List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue();

                List<SchemeType> allOutSchemeTypes = new ArrayList<>();

                allOutSchemeTypes.addAll(Arrays.asList(SchemeType.ACTIVATION, SchemeType.INVESTMENT, SchemeType.SPECIAL_SUPPORT, SchemeType.SELLOUT));

                allOutSchemeTypes.addAll(OUT_SCHEME_TYPES);

                schemeSummaryModels.stream().filter(x -> allOutSchemeTypes.contains(x.getSchemeType())).forEach(x -> x.setProcess(true));

                if (schemeSummaryModels.stream().filter(x -> x.isProcess()).count() == 0) continue;

                List<InventoryItem> modelInventoryItems = catalogInventoryItemMap.get(catalogSummaryModel.getCatalogId());

                for (InventoryItem inventoryItem : modelInventoryItems) {

                    float inventoryItemCashback = this.createSchemeInOut(schemeSummaryModels, inventoryItem, partnerType);

                    if (inventoryItemCashback > 0) {

                        count++;

                        totalCashback += inventoryItemCashback;

                    }

                }

            }

            if (count > 0) {

                walletService.addAmountToWallet(

                        retailerId, fofoOrderId, WalletReferenceType.SCHEME_OUT, "Sales margin for invoice number "

                                + fofoOrder.getInvoiceNumber() + ". Total " + count + " pc(s)",

                        totalCashback, fofoOrder.getCreateTimestamp());

                fofoOrder.setCashback(totalCashback + fofoOrder.getCashback());

            }

        }

        return totalCashback;

    }

    @Override

    //Tax rate has been passed to 0 to ensure no tax deduction

    public float getSpecialSupportAmount(float supportAmount, PartnerType partnerType, LocalDate onDate,

                                         int catalogId) throws ProfitMandiBusinessException {

        //int itemId = itemRepository.selectAllByCatalogItemId(catalogId).stream().findAny().get().getId();

        //float totalTaxRate = stateGstRateRepository.getTotalTaxRate(itemId);

        return this.getSpecialSupportAmount(supportAmount, partnerType, onDate, catalogId, 0);

    }

    @Override

    public float getSpecialSupportAmount(float supportAmount, PartnerType partnerType, LocalDate onDate,

                                         int catalogId, float taxRate) throws ProfitMandiBusinessException {

        float totalMargin = this.selectPercentageScheme(partnerType, onDate, catalogId, false, 0, 0).stream().collect(Collectors.summingDouble(x -> x.getAmount())).floatValue();

        float amountToCredit = supportAmount * (1 - (totalMargin / (100 + taxRate)));

        return amountToCredit;

    }

    private void processSpecialSupport(FofoOrder fofoOrder, List<Scheme> supportSchemes, InventoryItem

            inventoryItem, PartnerType partnerType, LocalDateTime saleDate) throws ProfitMandiBusinessException {

        int catalogId = inventoryItem.getItem().getCatalogItemId();

        float totalMargin = this.selectPercentageScheme(partnerType, saleDate.toLocalDate(), catalogId, false, 0, 0).stream().collect(Collectors.summingDouble(x -> x.getAmount())).floatValue();

        LOGGER.info("total percentage margin - {}", totalMargin);

        for (Scheme scheme : supportSchemes) {

            float amountToCredit = scheme.getAmount() * (1 - (totalMargin / 100));

            List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByScheme(scheme.getId(), inventoryItem.getId());

            SchemeInOut schemeInOut = schemeInOuts.stream().filter(x -> x.getRolledBackTimestamp() == null).findFirst().orElse(null);

            if (schemeInOut == null) {

                schemeInOut = new SchemeInOut();

                schemeInOut.setInventoryItemId(inventoryItem.getId());

                schemeInOut.setSchemeId(scheme.getId());

                schemeInOut.setInventoryItemId(inventoryItem.getId());

                schemeInOut.setCreateTimestamp(LocalDateTime.now());

                if (SchemeType.SELLOUT.equals(scheme.getType())) {

                    schemeInOut.setStatus(SchemePayoutStatus.CREDITED);

                    schemeInOut.setCreditTimestamp(LocalDateTime.now());

                    schemeInOut.setStatusDescription("Modelwise sellout support credited");

                    walletService.addAmountToWallet(inventoryItem.getFofoId(), fofoOrder.getId(), WalletReferenceType.SPECIAL_SUPPORT,

                            "Modelwise sellout support credited for Imei - " + inventoryItem.getSerialNumber(), amountToCredit,

                            fofoOrder.getCreateTimestamp());

                } else {

                    schemeInOut.setStatusDescription("Special support, Activation pending for IMEI#" + inventoryItem.getSerialNumber());

                    schemeInOut.setStatus(SchemePayoutStatus.PENDING);

                }

                schemeInOut.setAmount(amountToCredit);

                schemeInOutRepository.persist(schemeInOut);

            } else if (Double.valueOf(schemeInOut.getAmount()).intValue() != Double.valueOf(amountToCredit).intValue()) {

                SchemeInOut schemeInOutNew = new SchemeInOut();

                schemeInOutNew.setInventoryItemId(inventoryItem.getId());

                schemeInOutNew.setSchemeId(scheme.getId());

                schemeInOutNew.setCreateTimestamp(LocalDateTime.now());

                schemeInOutNew.setAmount(amountToCredit);

                if (schemeInOut.getStatus().equals(SchemePayoutStatus.PENDING)) {

                    schemeInOutNew.setStatus(SchemePayoutStatus.PENDING);

                    schemeInOutNew.setStatusDescription("Special support, Activation pending for IMEI#" + inventoryItem.getSerialNumber());

                    schemeInOutRepository.persist(schemeInOutNew);

                } else if (schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {

                    schemeInOutNew.setStatus(SchemePayoutStatus.CREDITED);

                    schemeInOutNew.setCreditTimestamp(LocalDateTime.now());

                    schemeInOutNew.setStatusDescription("Special support credited");

                    schemeInOutRepository.persist(schemeInOutNew);

                    walletService.addAmountToWallet(inventoryItem.getFofoId(), fofoOrder.getId(), WalletReferenceType.SPECIAL_SUPPORT,

                            "Special support adjusted against overall margin gains for Imei - " + inventoryItem.getSerialNumber(), amountToCredit - schemeInOut.getAmount(),

                            fofoOrder.getCreateTimestamp());

                }

                schemeInOut.setStatus(SchemePayoutStatus.REJECTED);

                schemeInOut.setStatusDescription("Failed!!, New Margin Entry added");

                schemeInOut.setRolledBackTimestamp(LocalDateTime.now());

            }

        }

    }

    @Override

    public void rollbackSchemes(List<Integer> inventoryItemIds, int rollbackReference, String rollbackReason)

            throws Exception {

        Set<Integer> inventoryItemIdSet = new HashSet<>(inventoryItemIds);

        float amountToRollback = 0;

        List<SchemeInOut> schemes = schemeInOutRepository.selectByInventoryItemIds(inventoryItemIdSet);

        for (SchemeInOut schemeInOut : schemes) {

            if (schemeInOut.getRolledBackTimestamp() == null) {

                schemeInOut.setRolledBackTimestamp(LocalDateTime.now());

                if (schemeInOut.getStatus() == null || schemeInOut.getStatus().equals(SchemePayoutStatus.CREDITED)) {

                    amountToRollback += schemeInOut.getAmount();

                }

                schemeInOut.setStatus(SchemePayoutStatus.REJECTED);

                schemeInOut.setStatusDescription(rollbackReason);

            }

        }

        if (amountToRollback > 0) {

            int inventoryItemId = inventoryItemIds.get(0);

            InventoryItem ii = inventoryItemRepository.selectById(inventoryItemId);

            Integer fofoId = ii.getFofoId();

            // Purchase p = purchaseRepository.selectById(ii.getPurchaseId());

            // TODO//

            walletService.rollbackAmountFromWallet(fofoId, amountToRollback, ii.getPurchaseId(),

                    WalletReferenceType.SCHEME_IN, rollbackReason, LocalDateTime.now());

        }

    }

    @Override

    public Map<String, Object> getSchemes(Set<Integer> roleIds, int offset, int limit)

            throws ProfitMandiBusinessException {

        Map<String, Object> map = new HashMap<>();

        List<Scheme> schemes = null;

        long size = 0;

        if (roleManager.isAdmin(roleIds)) {

            schemes = schemeRepository.selectAll(offset, limit);

            size = schemeRepository.selectAllCount();

        } else {

            schemes = schemeRepository.selectActiveAll(offset, limit);

            size = schemeRepository.selectAllActiveCount();

        }

        map.put("schemes", schemes);

        map.put("start", offset + 1);

        map.put("size", size);

        if (schemes.size() < limit) {

            map.put("end", offset + schemes.size());

        } else {

            map.put("end", offset + limit);

        }

        return map;

    }

    @Override

    public List<Scheme> getPaginatedSchemes(Set<Integer> roleIds, int offset, int limit)

            throws ProfitMandiBusinessException {

        LOGGER.info("requested offset=[{}], limit = [{}]", offset, limit);

        List<Scheme> schemes = null;

        if (roleManager.isAdmin(roleIds)) {

            schemes = schemeRepository.selectAll(offset, limit);

        } else {

            schemes = schemeRepository.selectActiveAll(offset, limit);

        }

        return schemes;

    }

    @Override

    // This is being called to reverse schemes while processing price Drop

    public void reverseSchemes(List<InventoryItem> inventoryItems, int priceDropId, String reversalReason)

            throws ProfitMandiBusinessException {

        PriceDrop priceDrop = priceDropRepository.selectById(priceDropId);

        Map<Integer, List<InventoryItem>> purchaseInventoryListMap = inventoryItems.stream()

                .collect(Collectors.groupingBy(InventoryItem::getPurchaseId, Collectors.toList()));

        for (Map.Entry<Integer, List<InventoryItem>> purchaseEntry : purchaseInventoryListMap.entrySet()) {

            float amountToCredit = 0;

            float amountToDebit = 0;

            int purchaseId = purchaseEntry.getKey();

            List<InventoryItem> purchaseInventoryItemList = purchaseEntry.getValue();

            Map<Integer, InventoryItem> inventoryItemsMap = purchaseInventoryItemList.stream()

                    .collect(Collectors.toMap(x -> x.getId(), x -> x));

            List<SchemeInOut> schemeInOuts = schemeInOutRepository.selectByInventoryItemIds(inventoryItemsMap.keySet());

            LOGGER.info("Scheme InOuts , {}", schemeInOuts);

            if (schemeInOuts.size() == 0) {

                continue;

            }

            List<Integer> schemeIds = schemeInOuts.stream().map(x -> x.getSchemeId()).collect(Collectors.toList());

            Map<Integer, Scheme> schemesMap = schemeRepository.selectBySchemeIds(schemeIds, 0, schemeIds.size())

                    .stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

            for (SchemeInOut schemeInOut : schemeInOuts) {

                InventoryItem ii = inventoryItemsMap.get(schemeInOut.getInventoryItemId());

                Scheme scheme = schemesMap.get(schemeInOut.getSchemeId());

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

                    continue;

                }

                if (scheme.getType().equals(SchemeType.IN) && schemeInOut.getRolledBackTimestamp() == null) {

                    float newAmount = getAmount(ii, scheme);

                    if (Math.abs(schemeInOut.getAmount() - newAmount) >= 0.01f) {

                        schemeInOut.setRolledBackTimestamp(LocalDateTime.now());

                        SchemeInOut sioNew = new SchemeInOut();

                        sioNew.setAmount(newAmount);

                        sioNew.setStatus(schemeInOut.getStatus());

                        sioNew.setStatusDescription(schemeInOut.getStatusDescription());

                        sioNew.setInventoryItemId(schemeInOut.getInventoryItemId());

                        sioNew.setSchemeId(schemeInOut.getSchemeId());

                        sioNew.setCreditTimestamp(LocalDateTime.now());

                        schemeInOutRepository.persist(sioNew);

                        schemeInOut.setStatus(SchemePayoutStatus.REJECTED);

                        schemeInOut.setStatusDescription("Change in margins due to price drop");

                        // IF not credited then dont consider any credit/debit for that sio entry

                        if (schemeInOut.getCreditTimestamp() != null) {

                            amountToCredit += sioNew.getAmount();

                            amountToDebit += schemeInOut.getAmount();