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

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

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

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.catalog.StockTransactionType;

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

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

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

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

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

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

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

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

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

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

import java.time.YearMonth;

import java.util.*;

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<SchemeType> FULL_DAYS_CD_SCHEME_TYPES = Arrays.asList(SchemeType.CASH_DISCOUNT, SchemeType.CASH_DISCOUNT1);

    private static final List<SchemeType> HALF_DAYS_CD_REJECT_SCHEME_TYPES = Arrays.asList(SchemeType.CASH_DISCOUNT1);

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

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

    @Autowired

    SchemeBlockedImeiRepository schemeBlockedImeiRepository;

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

    @Autowired

    private SamsungExceptionRepository samsungExceptionRepository;

    @Override

    public List<String> getBlockedImeis() {

        List<SchemeBlockedImei> schemeBlockedImeis = schemeBlockedImeiRepository.selectAll();

        return schemeBlockedImeis.stream().filter(x -> x.isBlocked()).map(x -> x.getImei()).collect(Collectors.toList());

    }

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

            schemeItem.setStartDate(createSchemeRequest.getStartDate());

            schemeItem.setEndDate(createSchemeRequest.getEndDate());

            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) throws ProfitMandiBusinessException {

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

         */

    }

    @Override

    public void activeSchemeByIds(List<Scheme> schemes) throws ProfitMandiBusinessException {

        if (schemes.size() > 0) {

            for (Scheme scheme : schemes) {

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

                    continue;

                }

                scheme.setActiveTimestamp(LocalDateTime.now());

            }

            this.sendCombinedSchemesNotification(schemes);

        }

    }

    @Override

    public void expireSchemeByIds(List<Scheme> schemes) throws ProfitMandiBusinessException {

        if (schemes.size() > 0) {

            for (Scheme scheme : schemes) {

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

                    continue;

                }

                scheme.setExpireTimestamp(scheme.getEndDateTime());

            }

            //this.sendCombinedSchemesNotification(schemes);

        }

    }

    private void sendSchemeNotification(Scheme scheme) throws ProfitMandiBusinessException {

        if (NOFITY_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 = "Important Notice!\n\n %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://smartdukaan.com/pages/home/notifications");

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

            List<SchemeRegion> schemeRegionList = schemeRegionRepository.selectAllBySchemeIds(Arrays.asList(scheme.getId()));

            sendNotificationModel.setRegionIds(schemeRegionList.stream().map(x->x.getRegionId()).collect(Collectors.toList()));

            notificationService.sendNotification(sendNotificationModel);

        }

    }

    @Autowired

    LoanRepository loanRepository;

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

        }

        LocalDateTime originalEndDate = scheme.getEndDateTime();

        scheme.setEndDateTime(expiryTime);

        List<SchemeItem> schemeItems = schemeItemRepository.selectBySchemeId(schemeId);

        for (SchemeItem schemeItem : schemeItems) {

            if (schemeItem.getEndDate().equals(originalEndDate)) {

                schemeItem.setEndDate(expiryTime);

            }

        }

    }

    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) throws ProfitMandiBusinessException {

        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;

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

        scheme.setReference(createSchemeRequest.getReference());

        return scheme;

    }

    @Autowired

    OfferRepository offerRepository;

    @Autowired

    OfferPayoutRepository offerPayoutRepository;

    @Autowired

    AgeingService ageingService;

    @Override

    public void sendCombinedSchemesNotification(List<Scheme> schemes) throws ProfitMandiBusinessException {

        if (schemes == null || schemes.isEmpty()) return;

        List<Scheme> filteredSchemes = schemes.stream()

                .filter(s -> NOFITY_SCHEME_TYPES.contains(s.getType())).collect(Collectors.toList());

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

        Map<Integer, List<Integer>> schemeIdRegionIdsMap = schemeRegionRepository.selectAllBySchemeIds(new ArrayList<>(schemesMap.keySet()))

                .stream().collect(Collectors.groupingBy(SchemeRegion::getSchemeId,

                        Collectors.collectingAndThen(Collectors.mapping(SchemeRegion::getRegionId, Collectors.toList()),

                                list -> {

                                    list.sort(Integer::compareTo); // sort ascending

                                    return list;

                                })));

        // Batch fetch all schemeItems for all filtered schemes at once

        Map<Integer, List<SchemeItem>> schemeItemsBySchemeId = schemeItemRepository.selectBySchemeIds(schemesMap.keySet())

                .stream().collect(Collectors.groupingBy(SchemeItem::getSchemeId));

        // Collect all catalogIds for batch fetching items

        Set<Integer> allCatalogIdsForFetch = schemeItemsBySchemeId.values().stream()

                .flatMap(List::stream)

                .map(SchemeItem::getCatalogId)

                .collect(Collectors.toSet());

        // Batch fetch all items by catalogIds once

        Map<Integer, List<Item>> itemsByCatalogId = allCatalogIdsForFetch.isEmpty()

                ? Collections.emptyMap()

                : itemRepository.selectAllByCatalogIds(allCatalogIdsForFetch).stream()

                        .collect(Collectors.groupingBy(Item::getCatalogItemId));

        Map<List<Integer>, Map<String, List<Scheme>>> groupedByRegionDate = filteredSchemes.stream()

                .collect(Collectors.groupingBy(s -> schemeIdRegionIdsMap.get(s.getId()), Collectors.groupingBy(s ->

                        String.valueOf(s.getStartDateTime()).substring(0, 10) + " - " +

                                String.valueOf(s.getEndDateTime()).substring(0, 10)

                )));

        for (Map.Entry<List<Integer>, Map<String, List<Scheme>>> regionIdsDateKeyset : groupedByRegionDate.entrySet()) {

            SendNotificationModel sendNotificationModel = new SendNotificationModel();

            StringBuilder messageBuilder = new StringBuilder();

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

            Set<String> allBrands = new HashSet<>();

            String schemeTypeLabel = null;

            List<Integer> regionIds = regionIdsDateKeyset.getKey();

            for (Map.Entry<String, List<Scheme>> entry : regionIdsDateKeyset.getValue().entrySet()) {

                String dateRange = entry.getKey();

                List<Scheme> groupedSchemes = entry.getValue();

                messageBuilder.append(String.format("Duration: %s\n", dateRange));

                for (Scheme scheme : groupedSchemes) {

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

                        schemeTypeLabel = "Special Support";

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

                        schemeTypeLabel = "Sellout Scheme";

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

                        schemeTypeLabel = "Sellin Scheme";

                    }

                    // Use pre-fetched schemeItems instead of N+1 query

                    List<SchemeItem> schemeItems = schemeItemsBySchemeId.getOrDefault(scheme.getId(), Collections.emptyList());

                    Set<Integer> catalogIds = schemeItems.stream()

                            .map(SchemeItem::getCatalogId)

                            .collect(Collectors.toSet());

                    allCatalogIds.addAll(catalogIds);

                    // Use pre-fetched items instead of duplicate DB calls

                    List<Item> catalogItems = catalogIds.stream()

                            .flatMap(cid -> itemsByCatalogId.getOrDefault(cid, Collections.emptyList()).stream())

                            .collect(Collectors.toList());

                    List<String> itemBrand = catalogItems.stream()

                            .map(Item::getBrand)

                            .filter(Objects::nonNull)

                            .distinct()

                            .collect(Collectors.toList());

                    allBrands.addAll(itemBrand);

                    List<String> itemDescriptions = catalogItems.stream()

                            .filter(Utils.distinctByKey(Item::getCatalogItemId))

                            .map(Item::getItemDescriptionNoColor)

                            .collect(Collectors.toList());

                    messageBuilder.append(String.format("%s of Rs.%s on Models: %s\n",

                            schemeTypeLabel,

                            FormattingUtils.formatDecimal(scheme.getAmount()),

                            String.join(", ", itemDescriptions)));

                }

                messageBuilder.append("\n");

            }

            if (allBrands.isEmpty() || schemeTypeLabel == null) return;

            String title = String.format("%s for %s",

                    schemeTypeLabel,

                    String.join(", ", allBrands));

            sendNotificationModel.setCampaignName("activationscheme");

            sendNotificationModel.setUrl("https://store.smartdukaan.com/pages/home/notifications");

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

            sendNotificationModel.setTitle(title);

            sendNotificationModel.setMessage(messageBuilder.toString().trim());

            sendNotificationModel.setType("url");

            sendNotificationModel.setMessageType(MessageType.scheme);

            sendNotificationModel.setRegionIds(regionIds);

            System.out.println(sendNotificationModel);

            notificationService.sendNotification(sendNotificationModel);

        }

    }

    //CDs would be rejected based on cdFreeDays

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

        LOGGER.info("Processing scheme in  for purchaseId - {}", purchaseId);

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

        String purchaseInvoice = purchase.getPurchaseReference();

        Loan loan = loanRepository.selectLoanByInvoice(purchaseInvoice);

        PartnerType partnerType = partnerTypeChangeService.getTypeOnMonth(retailerId,

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

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

        //Remove imeis from blocked imeis list

        List<String> blockedImeis = this.getBlockedImeis();

        inventoryItems = inventoryItems.stream().filter(inventoryItem -> !blockedImeis.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()), billingDate);

        int itemsCount = 0;

        float totalCashback = 0;

        //LOGGER.info("catalogSchemeSummaryMap - {}", catalogSchemeSummaryMap);

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

            CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();

            List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue().stream().filter(Objects::nonNull).collect(Collectors.toList());

            schemeSummaryModels.stream().filter(x -> x != null && x.getSchemeType().getTransactionType().equals(StockTransactionType.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) {

                inventoryItemRepository.selectForUpdate(inventoryItem.getId());

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

                if (loan != null && loan.getCdFreeDays() > 0) {

                    List<SchemeType> rejectedCDTypes = HALF_DAYS_CD_REJECT_SCHEME_TYPES;

                    if (loan.getCdFreeDays() == ProfitMandiConstants.LOAN_FULL_CREDIT_DAYS

                            || loan.getCdFreeDays() == ProfitMandiConstants.PREMIUM_LOAN_FULL_CREDIT_DAYS) {

                        rejectedCDTypes = FULL_DAYS_CD_SCHEME_TYPES;

                    }

                    for (SchemeType rejectedCDType : rejectedCDTypes) {

                        // Fixed: single DB call instead of duplicate calls

                        List<SchemeInOut> cdSios = schemeInOutRepository.selectAllByType(rejectedCDType, inventoryItem.getId());

                        SchemeInOut sio = cdSios.isEmpty() ? null : cdSios.get(0);

                        if (sio == null) continue;

                        sio.setStatus(SchemePayoutStatus.REJECTED);

                        //Noone should change this

                        sio.setStatusDescription("Rejected due to free days availed");

                        sio.setRolledBackTimestamp(LocalDateTime.now());

                        inventoryItemCashback -= sio.getAmount();

                    }

                }

                if (inventoryItemCashback > 0.01f) {

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

        }

    }

    // Calculate payout amount for an inventory item based on scheme type.

    // For PERCENTAGE schemes: uses price-drop-adjusted DP (purchase price minus any price drop).

    //   GRN (IN): dpForCalc = purchasePrice - priceDropAmount

    //   Sale (OUT): dpForCalc = min(purchasePrice - priceDropAmount, currentSellingPrice)

    //   On price increase, priceDropAmount stays 0 so payout is on original purchase price.

    // For FIXED schemes (IN only): returns the fixed scheme amount directly.

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

        if (this.getBlockedImeis().contains(inventoryItem.getSerialNumber())) {

            return 0;

        }

        float amount = 0;

        float dpForCalc = 0;

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

            if (scheme.getType().getTransactionType().equals(StockTransactionType.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 for itemId {}", inventoryItem.getItemId());

                }

            }

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

            LOGGER.debug("Scheme payout: invId={}, imei={}, schemeId={}, dpForCalc={}, schemeAmt={}%, payout={}",

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

                    dpForCalc, scheme.getAmount(), amount);

        } else if (scheme.getType().getTransactionType().equals(StockTransactionType.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) throws ProfitMandiBusinessException {

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

        InventoryPayoutModel inventoryPayoutModel = priceCircularService.getPayouts(inventoryItem);

        //Get all schemes

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

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

        List<SchemeInOut> paidSios = inventoryPayoutModel.getPaidSios();

        List<SchemeInOut> pendingSios = inventoryPayoutModel.getPendingSios();

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

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

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

        Map<SchemeType, Float> schemeTypeCancelledAmountMap = new HashMap<>();

        double percentageToPay = 0d;

        double fixedToPay = 0d;

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

        for (SchemeSummaryModel schemeSummaryModelToProcess : inventoryPayoutModelToProcess) {

            if (paidSchemesMap.containsKey(schemeSummaryModelToProcess.getSchemeId()) || pendingSchemesMap.containsKey(schemeSummaryModelToProcess.getSchemeId()))

                continue;

            //All Valid margins are supposed to be credited invalid margins should be rejected

            if (SchemeType.SPECIAL_SUPPORT.equals(schemeSummaryModelToProcess.getSchemeType())) {

                //Create only if the activation date is not known

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

                if (activatedImei == null || activatedImei.getActivationTimestamp() == null) {

                    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 (!StockTransactionType.IN.equals(schemeSummaryModelToProcess.getSchemeType().getTransactionType())) {

                //We have got non repeating scheme type

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

                    //Check for rejected CashDiscounts dont continue if its ever rejected once

                    if (SchemeType.CDS.contains(schemeSummaryModelToProcess.getSchemeType())) {

                        List<SchemeInOut> cdSchemeInOuts = schemeInOutRepository.selectAllByType(schemeSummaryModelToProcess.getSchemeType(), inventoryItem.getId());

                        LOGGER.info(cdSchemeInOuts);

                        if (!cdSchemeInOuts.isEmpty() && cdSchemeInOuts.get(0).getStatusDescription().equals("Rejected due to free days availed"))

                            continue;

                    }

                    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) + schemeTypeCancelledAmountMap.getOrDefault(schemeSummaryModel.getSchemeType(), 0f));

                    if (schemeSummaryModel.getSchemeType().getTransactionType().equals(StockTransactionType.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) {

            LOGGER.info("inventoryPayoutModel.getFixedAmount() ----> {}", inventoryPayoutModel.getFixedAmount());

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

                            schemeTypeCancelledAmountMap.getOrDefault(schemeSummaryModel.getSchemeType(), 0f));

                    if (schemeSummaryModel.getSchemeType().getTransactionType().equals(StockTransactionType.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);

        // Batch fetch all Samsung activated imeis at once to avoid N+1 queries

        List<String> samsungSerialNumbers = partnerAgeingModels.stream()

                .filter(p -> "Samsung".equalsIgnoreCase(p.getBrand()))

                .map(PartnerAgeingModel::getSerialNumber)

                .collect(Collectors.toList());

        Map<String, ActivatedImei> activatedImeiMap = samsungSerialNumbers.isEmpty()

                ? Collections.emptyMap()

                : activatedImeiRepository.selectBySerialNumbers(samsungSerialNumbers).stream()

                        .collect(Collectors.toMap(ActivatedImei::getSerialNumber, x -> x, (a, b) -> a));

        for (PartnerAgeingModel partnerAgeingModel : partnerAgeingModels) {

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

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

                ActivatedImei activatedImei = activatedImeiMap.get(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;

    }

    @Autowired

    WarehouseInventoryItemRepository warehouseInventoryItemRepository;

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

            LOGGER.info("OrderDate - {}, Partner Type - {}", fofoOrder.getCreateTimestamp(), partnerType);

            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;

            // Cache blocked imeis to avoid repeated DB calls inside stream

            Set<String> blockedImeisSet = new HashSet<>(this.getBlockedImeis());

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

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

                    .collect(Collectors.toSet());

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

            //Do not consider imei above 90 days for samsung

            List<String> samsungSerialNumbers = inventoryItems.stream().filter(x -> x.getItem().getBrand().equalsIgnoreCase("samsung")).map(x -> x.getSerialNumber()).collect(Collectors.toList());

            if (samsungSerialNumbers.size() > 0) {

                List<AgeingSummaryModel> billedImeiModels = warehouseInventoryItemRepository.findStockAgeingByFofoIdSerialNumbers(retailerId, samsungSerialNumbers);

                List<String> agedSerialNumbers = billedImeiModels.stream().filter(x -> x.isAgedAbove(365)).map(x -> x.getSerialNumber()).collect(Collectors.toList());

                if (agedSerialNumbers.size() > 0) {

                    List<String> samsungExceptionsSerialNumbers = samsungExceptionRepository.selectAllBySerialNumber(agedSerialNumbers).stream().map(x -> x.getSerialNumber()).collect(Collectors.toList());

                    agedSerialNumbers.removeAll(samsungExceptionsSerialNumbers);

                }

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

            }

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

            // Resolve GRN billing date per inventory item: InventoryItem.purchaseId -> Purchase.purchaseReference -> Order.billingTimestamp.

            // Scheme resolution for OUT must use each item's own GRN billing date, not fofoOrder.createTimestamp.

            Set<Integer> purchaseIds = inventoryItems.stream().map(InventoryItem::getPurchaseId).collect(Collectors.toSet());

            Map<Integer, LocalDateTime> purchaseBillingDateMap = new HashMap<>();

            for (Integer purchaseId : purchaseIds) {

                purchaseBillingDateMap.put(purchaseId, purchaseService.getBillingDateOfPurchase(purchaseId));

            }

            // Group items by (GRN billingDate -> catalogId -> items). Items with identical GRN billing date share a scheme lookup.

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

                    .collect(Collectors.groupingBy(

                            x -> purchaseBillingDateMap.get(x.getPurchaseId()),

                            Collectors.groupingBy(x -> x.getItem().getCatalogItemId())));

            // N+1 fix: Batch fetch all SchemeInOut records for all inventoryItems at once

            Set<Integer> allInventoryItemIds = inventoryItems.stream().map(InventoryItem::getId).collect(Collectors.toSet());

            List<SchemeInOut> allSchemeInOuts = schemeInOutRepository.selectByInventoryItemIds(allInventoryItemIds);

            Map<Integer, List<SchemeInOut>> schemeInOutByInventoryItemId = allSchemeInOuts.stream()

                    .collect(Collectors.groupingBy(SchemeInOut::getInventoryItemId));

            int count = 0;

            for (Map.Entry<LocalDateTime, Map<Integer, List<InventoryItem>>> billingDateEntry : billingDateCatalogItemsMap.entrySet()) {

                LocalDateTime grnBillingDate = billingDateEntry.getKey();

                Map<Integer, List<InventoryItem>> catalogInventoryItemMap = billingDateEntry.getValue();

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

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

                LOGGER.info("catalogSchemeSummaryMap (grnBillingDate={}) - {}", grnBillingDate, catalogSchemeSummaryMap);

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

                    CatalogSummaryModel catalogSummaryModel = catalogSummaryModelListEntry.getKey();

                    List<SchemeSummaryModel> schemeSummaryModels = catalogSummaryModelListEntry.getValue().stream().filter(x -> x != null).collect(Collectors.toList());

                    schemeSummaryModels.stream().filter(x -> x.getSchemeType().getTransactionType().equals(StockTransactionType.OUT)).forEach(x -> x.setProcess(true));

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

                    // Create map once per catalog instead of per inventoryItem

                    Map<Integer, SchemeSummaryModel> schemeSummaryModelMap = schemeSummaryModels.stream().collect(Collectors.toMap(x -> x.getSchemeId(), x -> x));

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

                    for (InventoryItem inventoryItem : modelInventoryItems) {

                    // N+1 fix: Use pre-fetched schemeInOut map instead of querying per inventoryItem

                    List<SchemeInOut> sios = schemeInOutByInventoryItemId.getOrDefault(inventoryItem.getId(), Collections.emptyList());

                    List<Integer> creditedSchemeIds = sios.stream()

                            .filter(x -> x.getStatus().equals(SchemePayoutStatus.CREDITED))

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

                    double sioRejectedValue = 0;

                    if (creditedSchemeIds.size() > 0) {

                        //Also ignore special support

                        //This code block needs to be deleted

                        List<Integer> schemeIdsToReject = null;

                        if (Arrays.asList(1025588, 1025589).contains(inventoryItem.getItem().getCatalogItemId())) {

                            schemeIdsToReject = schemeRepository.selectBySchemeIds(creditedSchemeIds).stream()

                                    .filter(x -> !SchemeType.SPECIAL_SUPPORT.equals(x.getType()))

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

                            //List<Integer> schemeIdsToReject = schemeRepository.selectBySchemeIds(creditedSchemeIds).stream()

                            //This code block needs to be deleted

                        } else {

                            schemeIdsToReject = schemeRepository.selectBySchemeIds(creditedSchemeIds).stream()

                                    .filter(x -> SchemeType.OUT_TYPES.contains(x.getType()) && !SchemeType.SPECIAL_SUPPORT.equals(x.getType()))