Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.order;

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

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

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

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

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

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.common.web.client.RestClient;

import com.spice.profitmandi.dao.cart.SmartCartService;

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.entity.user.Address;

import com.spice.profitmandi.dao.entity.user.Counter;

import com.spice.profitmandi.dao.entity.user.PrivateDealUser;

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

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

import com.spice.profitmandi.dao.enumuration.dtr.PaymentOptionReferenceType;

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

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

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

import com.spice.profitmandi.dao.enumuration.inventory.ScratchedGift;

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

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

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

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

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

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

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.dao.repository.user.CounterRepository;

import com.spice.profitmandi.dao.repository.user.PrivateDealUserRepository;

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

import com.spice.profitmandi.service.catalog.BrandsService;

import com.spice.profitmandi.service.integrations.bharti.model.PlanVariant;

import com.spice.profitmandi.service.integrations.zest.InsuranceService;

import com.spice.profitmandi.service.integrations.zest.MobileInsurancePlan;

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

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

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

import com.spice.profitmandi.service.offers.ItemCriteria;

import com.spice.profitmandi.service.pricing.PricingService;

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

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

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.json.JSONObject;

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

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

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

import org.springframework.cache.annotation.Cacheable;

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Component;

import javax.persistence.criteria.CriteriaBuilder;

import javax.persistence.criteria.CriteriaQuery;

import javax.persistence.criteria.Predicate;

import javax.persistence.criteria.Root;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.util.AbstractMap.SimpleEntry;

import java.util.*;

import java.util.function.Function;

import java.util.stream.Collectors;

@Component

public class OrderServiceImpl implements OrderService {

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

    private static Map<String, Integer> serialNumberOrderIdMap = new HashMap<>();

    static {

        serialNumberOrderIdMap.put("862897055749275", 67228);

    }

    @Autowired

    BrandsService brandsService;

    @Autowired

    @Qualifier("fofoInventoryItemRepository")

    private InventoryItemRepository inventoryItemRepository;

    @Autowired

    private StateGstRateRepository stateGstRateRepository;

    @Autowired

    private SaholicInventoryService saholicInventoryService;

    @Autowired

    private LiveDemoBillingRespository liveDemoBillingRespository;

    @Autowired

    private InsuranceService insuranceService;

    @Autowired

    @Qualifier("fofoCurrentInventorySnapshotRepository")

    private CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired

    private InvoiceNumberGenerationSequenceRepository invoiceNumberGenerationSequenceRepository;

    @Autowired

    private PurchaseReturnService purchaseReturnService;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private CustomerRepository customerRepository;

    @Autowired

    private PurchaseReturnItemRepository purchaseReturnItemRepository;

    @Autowired

    private AddressRepository addressRepository;

    @Autowired

    private FofoLineItemRepository fofoLineItemRepository;

    @Autowired

    private FofoNonSerializeSerialRepository fofoNonSerializeSerialRepository;

    @Autowired

    private WarehouseInventoryItemRepository warehouseInventoryItemRepository;

    @Autowired

    private FofoOrderItemRepository fofoOrderItemRepository;

    @Autowired

    private PaymentOptionRepository paymentOptionRepository;

    @Autowired

    private CustomerReturnItemRepository customerReturnItemRepository;

    @Autowired

    @Qualifier("fofoScanRecordRepository")

    private ScanRecordRepository scanRecordRepository;

    @Autowired

    private FofoOrderRepository fofoOrderRepository;

    @Autowired

    private RetailerRepository retailerRepository;

    @Autowired

    private UserRepository userRepository;

    @Autowired

    private UserAccountRepository userAccountRepository;

    @Autowired

    private RetailerRegisteredAddressRepository retailerRegisteredAddressRepository;

    @Autowired

    private CustomerAddressRepository customerAddressRepository;

    @Autowired

    @Qualifier("catalogItemRepository")

    private ItemRepository itemRepository;

    @Autowired

    private InsuranceProviderRepository insuranceProviderRepository;

    @Autowired

    private InsurancePolicyRepository insurancePolicyRepository;

    @Autowired

    private StateRepository stateRepository;

    @Autowired

    private PolicyNumberGenerationSequenceRepository policyNumberGenerationSequenceRepository;

    @Autowired

    private PricingService pricingService;

    @Autowired

    private PrivateDealUserRepository privateDealUserRepository;

    @Autowired

    private TagListingRepository tagListingRepository;

    @Autowired

    private CounterRepository counterRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private PaymentOptionTransactionRepository paymentOptionTransactionRepository;

    @Autowired

    private SchemeService schemeService;

    private static final List<Integer> orderIdsConsumed = new ArrayList<>();

    @Autowired

    @Qualifier("fofoInventoryService")

    private InventoryService inventoryService;

    @Autowired

    private CustomerCreditNoteRepository customerCreditNoteRepository;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private CategoryRepository categoryRepository;

    @Autowired

    private HygieneDataRepository hygieneDataRepository;

    @Autowired

    private SessionFactory sessionFactory;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private PendingOrderRepository pendingOrderRepository;

    @Autowired

    private PendingOrderService pendingOrderService;

    @Autowired

    private PendingOrderItemRepository pendingOrderItemRepository;

    @Autowired

    private ScratchOfferRepository scratchOfferRepository;

    @Autowired

    RestClient restClient;

    @Autowired

    UpSaleOrderRepository upSaleOrderRepository;

    @Autowired

    private CustomerOfferRepository customerOfferRepository;

    @Autowired

    private CustomerOfferItemRepository customerOfferItemRepository;

    @Autowired

    private UpgradeOfferRepository upgradeOfferRepository;

    @Autowired

    private SmartCartService smartCartService;

    @Autowired

    private PartnerTypeChangeService partnerTypeChangeService;

    @Value("${prod}")

    private boolean prodEnv;

    private static final String SMS_GATEWAY = "http://api.pinnacle.in/index.php/sms/send";

    private static final String SENDER = "SMTDKN";

    public static final String APP_DOWNLOAD_BILLING_TEMPLATE_ID = "1507163542403945677";

    public static final String APP_DOWNLOAD_BILLING_OFFER = "Dear Customer, Thank you for purchasing from SmartDukaan pls click %s to download our app to see you invoice and special offers. SmartDukaan";

    static Map<Double, List<ScratchedGift>> GIFT_SERIES = new TreeMap<>(Comparator.reverseOrder());

    // Define eligible partners for LED & Microwave Oven

    private static final Set<Integer> PREMIUM_ELIGIBLE_PARTNERS = new HashSet<>(Arrays.asList(175139615, 175139583));

    private static Map<ScratchedGift, Integer> GIFT_QUANTITIES = new HashMap<>();

    List<Double> PRICE_RANGE = Arrays.asList(0.0, Double.MAX_VALUE);

    static {

        GIFT_QUANTITIES.put(ScratchedGift.ACCESSORIES_50_PERCENT_OFF, 500);

        GIFT_QUANTITIES.put(ScratchedGift.NECK_BAND, 280);

        GIFT_QUANTITIES.put(ScratchedGift.LED, 1);

        GIFT_QUANTITIES.put(ScratchedGift.MICROWAVE_OVEN, 1);

    }

    static {

        GIFT_SERIES.put(0.0, Arrays.asList(ScratchedGift.ACCESSORIES_50_PERCENT_OFF, ScratchedGift.NECK_BAND));

        GIFT_SERIES.put(30001.0, Arrays.asList(ScratchedGift.NECK_BAND, ScratchedGift.MICROWAVE_OVEN, ScratchedGift.LED));

    }

    private void persistNonSerializedWithCustomSerialNumber(CustomFofoOrderItem customFofoOrderItem, int orderItemId) {

        // Create a new instance of FofoNonSerializeSerial

        for (String accSerialNumber : customFofoOrderItem.getCustomSerialNumbers()) {

            if (!accSerialNumber.isEmpty()) {

                FofoNonSerializeSerial nonSerializeSerial = new FofoNonSerializeSerial();

                // Populate the entity with relevant information

                nonSerializeSerial.setOrderItemId(orderItemId);

                nonSerializeSerial.setSerialNumber(accSerialNumber);

                // Save the entity to the database

                fofoNonSerializeSerialRepository.persist(nonSerializeSerial);

            }

        }

    }

    public void sendAppDownloadBillingOffer(String mobileNumber) throws Exception {

        String sdurl = "http://surl.li/anhfn";

        try {

            if (prodEnv) {

                this.sendSms(APP_DOWNLOAD_BILLING_TEMPLATE_ID, String.format(APP_DOWNLOAD_BILLING_OFFER, sdurl), mobileNumber);

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public void sendSms(String dltTemplateId, String message, String mobileNumber) throws Exception {

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

        map.put("sender", SENDER);

        map.put("messagetype", "TXT");

        map.put("apikey", "b866f7-c6c483-682ff5-054420-ad9e2c");

        map.put("numbers", "91" + mobileNumber);

        LOGGER.info("Message {}", message);

        // OTP Message Template

        map.put("message", message);

        map.put("dlttempid", dltTemplateId);

        String response = restClient.post(SMS_GATEWAY, map, new HashMap<>());

        LOGGER.info(response);

    }

    private void createScratchOffer(int fofoId, String invoiceNumber, int customerId) {

        //ScratchedGift gift = getScratchedGiftRandom(fofoId, customerId);

        //  LocalDateTime endDate = LocalDateTime.of(LocalDate.now().getYear(), LocalDate.now().getMonth(), 27, 21, 00);

        List<ScratchOffer> scratchOffers = scratchOfferRepository.selectBycCustomerIdAndDate(customerId, ProfitMandiConstants.SCRATCH_OFFER_START_DATE, ProfitMandiConstants.SCRATCH_OFFER_END_DATE);

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

            ScratchOffer so2 = new ScratchOffer();

            so2.setInvoiceNumber(invoiceNumber);

            so2.setScratched(false);

            so2.setCreatedTimestamp(LocalDateTime.now());

            so2.setExpiredTimestamp(ProfitMandiConstants.SCRATCH_OFFER_END_DATE.plusDays(1).atTime(LocalTime.MAX));

            so2.setOfferName(String.valueOf(ScratchedGift.BLNT));

            so2.setCustomerId(customerId);

            LocalDateTime today830PM = LocalDate.now().atTime(20, 30);

            LocalDateTime today9PM = LocalDate.now().atTime(21, 0);

            so2.setUnlockedAt(LocalDateTime.now());

//            if (LocalDateTime.now().isAfter(today830PM)) {

//                so2.setUnlockedAt(today9PM.plusDays(0));

//            } else {

//                so2.setUnlockedAt(today9PM);

//            }

            scratchOfferRepository.persist(so2);

        }

    }

    @Override

    public int createOrder(CreateOrderRequest createOrderRequest, int fofoId, boolean accessoriesDeals) throws Exception {

        LOGGER.info("fofoId -- {} Order Request -- {}", fofoId, createOrderRequest);

        CustomCustomer customCustomer = createOrderRequest.getCustomer();

        Customer customer = customerRepository.selectById(customCustomer.getCustomerId());

        if ((createOrderRequest.getCustomer().getGender() != null && createOrderRequest.getCustomer().getGender().equals("2"))) {

            customer.setGender("Female");

        } else {

            customer.setGender("Male");

        }

        if (!StringUtils.isValidGstNumber(customCustomer.getGstNumber())) {

            LOGGER.error("invalid customer gstNumber {} ", customCustomer.getGstNumber());

            throw new ProfitMandiBusinessException(ProfitMandiConstants.CUSTOMER_GST_NUMBER, customCustomer.getGstNumber(), "VE_1072");

        }

        Map<Integer, Integer> itemIdQuantity = new HashMap<>(); // this is for error

        Map<Integer, CustomFofoOrderItem> itemIdCustomFofoOrderItemMap = new HashMap<>();

        Map<Integer, Float> lineItemPrice = new HashMap<>(); // this is for pricing error

        float totalAmount = 0;

        boolean noGST = false;

        // N+1 fix: Batch fetch all PendingOrderItems before the validation loop

        List<Integer> validationPoiIds = createOrderRequest.getFofoOrderItems().stream()

                .map(CustomFofoOrderItem::getPoiId)

                .filter(id -> id > 0)

                .collect(Collectors.toList());

        Map<Integer, PendingOrderItem> pendingOrderItemMap = new HashMap<>();

        if (!validationPoiIds.isEmpty()) {

            List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByIds(validationPoiIds);

            pendingOrderItemMap = pendingOrderItems.stream()

                    .collect(Collectors.toMap(PendingOrderItem::getId, poi -> poi));

        }

        for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {

            if (customFofoOrderItem.getPoiId() > 0) {

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

                PendingOrderItem pendingOrderItem = pendingOrderItemMap.get(customFofoOrderItem.getPoiId());

                if (pendingOrderItem == null) {

                    throw new ProfitMandiBusinessException("poiId", customFofoOrderItem.getPoiId(), "Pending order item not found");

                }

                if (customFofoOrderItem.getQuantity() > pendingOrderItem.getQuantity()) {

                    throw new ProfitMandiBusinessException("itemIdQuantity", customFofoOrderItem.getItemId(), "Quantity should not be greater than order item quantity");

                }

                if (pendingOrderItem.getQuantity() > customFofoOrderItem.getQuantity()) {

                    pendingOrderService.duplicatePendingOrder(pendingOrderItem, customFofoOrderItem.getQuantity());

                }

            }

            // itemIds.add(customFofoOrderItem.getItemId());

            Set<String> serialNumbers = this.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());

            if (!serialNumbers.isEmpty() && customFofoOrderItem.getQuantity() != serialNumbers.size()) {

                itemIdQuantity.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());

            }

            if (!(customFofoOrderItem.getSellingPrice() > 0)) {

                lineItemPrice.put(customFofoOrderItem.getItemId(), customFofoOrderItem.getSellingPrice());

            } else {

                totalAmount = totalAmount + customFofoOrderItem.getSellingPrice() * customFofoOrderItem.getQuantity();

                for (SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()) {

                    if (serialNumberDetail.getAmount() > 0) {

                        totalAmount = totalAmount + serialNumberDetail.getAmount();

                    }

                }

            }

            itemIdCustomFofoOrderItemMap.put(customFofoOrderItem.getItemId(), customFofoOrderItem);

        }

        if (!itemIdQuantity.isEmpty()) {

            // if item quantity does not match with given serialnumbers size

            LOGGER.error("itemId's quantity should be equal to given serialnumber size {} ", itemIdQuantity);

            throw new ProfitMandiBusinessException("itemIdQuantity", itemIdQuantity, "FFORDR_1001");

            // return "error";

        }

        this.validatePaymentOptionsAndTotalAmount(createOrderRequest.getPaymentOptions(), totalAmount);

        if (!lineItemPrice.isEmpty()) {

            // given fofo line item price must be greater than zero

            LOGGER.error("requested itemId's selling price must greater than 0");

            throw new ProfitMandiBusinessException(ProfitMandiConstants.PRICE, lineItemPrice, "FFORDR_1002");

        }

        List<CurrentInventorySnapshot> currentInventorySnapshots = currentInventorySnapshotRepository.selectByFofoItemIds(fofoId, itemIdCustomFofoOrderItemMap.keySet());

        this.validateCurrentInventorySnapshotQuantities(currentInventorySnapshots, itemIdCustomFofoOrderItemMap);

        List<Item> items = itemRepository.selectByIds(itemIdCustomFofoOrderItemMap.keySet());

        if (items.size() != itemIdCustomFofoOrderItemMap.keySet().size()) {

            LOGGER.error("Requested ItemIds not found in catalog");

            // invalid itemIds

            throw new ProfitMandiBusinessException("invalidItemIds", itemIdCustomFofoOrderItemMap.keySet(), "FFORDR_1003");

        }

        Map<Integer, Item> itemMap = this.toItemMap(items);

        // Validate brand code eligibility - block orders for brands without dealer code

        FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

        if (!fofoStore.isInternal()) {

            List<String> partnerIneligibleBrands = brandsService.partnerIneligibleBrands(fofoId);

            for (Item item : items) {

                if (partnerIneligibleBrands.contains(item.getBrand())) {

                    LOGGER.error("Brand code not active for brand {}, fofoId {}", item.getBrand(), fofoId);

                    throw new ProfitMandiBusinessException("Brand is not allowed",

                            "Brand code not active for " + item.getBrand() + ". Please contact your RBM for further details.", "FFORDR_1018");

                }

            }

        }

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

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

        List<InsuranceModel> insuredModels = new ArrayList<>();

        noGST = items.stream().anyMatch(item -> "NOGST".equals(item.getHsnCode()));

        for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {

            Item item = itemMap.get(customFofoOrderItem.getItemId());

            if (item.getType().equals(ItemType.SERIALIZED)) {

                for (SerialNumberDetail serialNumberDetail : customFofoOrderItem.getSerialNumberDetails()) {

                    serialNumbers.add(serialNumberDetail.getSerialNumber());

                    if (serialNumberDetail.getAmount() > 0) {

                        if (customer.getEmailId() == null || customer.getEmailId().equals("")) {

                            throw new ProfitMandiBusinessException("Email Id is required for insurance", "Email Id is required for insurance", "Email Id is required for insurance");

                        }

                        InsuranceModel im = new InsuranceModel();

                        im.setBrand(item.getBrand());

                        im.setColor(item.getColor());

                        im.setModelName(item.getModelName() + item.getModelNumber());

                        im.setInsuranceAmount(serialNumberDetail.getAmount());

                        im.setDeviceSellingPrice(customFofoOrderItem.getSellingPrice());

                        im.setInsuranceUId(serialNumberDetail.getInsurance());

                        im.setCorrelationId(serialNumberDetail.getCorrelationId());

                        PlanVariant oneAssistpremium = insuranceService.getOneAssistPremiumByVariantId(serialNumberDetail.getInsurance());

                        if (oneAssistpremium != null) {

                            im.setInsuranceId(String.valueOf(oneAssistpremium.getId()));

                        } else {

                            im.setInsuranceId(String.valueOf(insuranceService.getICICIPremiumByVariantId(serialNumberDetail.getInsurance()).getId()));

                        }

                        im.setSerialNumber(serialNumberDetail.getSerialNumber());

                        im.setMemory(serialNumberDetail.getMemory());

                        im.setRam(serialNumberDetail.getRam());

                        im.setMfgDate(serialNumberDetail.getMfgDate());

                        insuredModels.add(im);

                        // Check for free insurance code

                        try {

                            Map<String, List<MobileInsurancePlan>> mobileInsurancePlanMap = insuranceService.getAllPlans(item.getId(), im.getDeviceSellingPrice(), false);

                            MobileInsurancePlan mobileInsurancePlan = mobileInsurancePlanMap.entrySet().stream().flatMap(x -> x.getValue().stream()).filter(x -> x.getProductId().equals(serialNumberDetail.getInsurance())).findFirst().get();

/*                            if (mobileInsurancePlan.getPlanName().equals("OneAssist Damage Protection Plan")) {

                                MobileInsurancePlan freePlan = mobileInsurancePlanMap.get("Prolong Extendended Warranty(SmartDukaan Special Price)").get(0);

                                InsuranceModel imFree = new InsuranceModel();

                                imFree.setBrand(item.getBrand());

                                imFree.setColor(item.getColor());

                                imFree.setModelName(item.getModelName() + item.getModelNumber());

                                imFree.setInsuranceAmount(0);

                                imFree.setDeviceSellingPrice(customFofoOrderItem.getSellingPrice());

                                LOGGER.info("freePlan.getProductId() {}", freePlan.getProductId());

                                imFree.setInsuranceUId(freePlan.getProductId());

                                imFree.setInsuranceId(String.valueOf(insuranceService.getOneAssistPremiumByVariantId(freePlan.getProductId()).getId()));

                                imFree.setSerialNumber(serialNumberDetail.getSerialNumber());

                                imFree.setMemory(serialNumberDetail.getMemory());

                                imFree.setRam(serialNumberDetail.getRam());

                                imFree.setMfgDate(serialNumberDetail.getMfgDate());

                                insuredModels.add(imFree);

                            }*/

                        } catch (Exception e) {

                            LOGGER.error("Exception - {}", e);

                            throw new ProfitMandiBusinessException("problem fetching plans", "problem fetching plans", "problem fetching plans");

                        }

                    }

                }

            } else {

                nonSerializedItemIds.add(customFofoOrderItem.getItemId());

            }

        }

        Map<Integer, Set<InventoryItem>> serializedInventoryItemMap = new HashMap<>();

        Map<Integer, Set<InventoryItem>> nonSerializedInventoryItemMap = new HashMap<>();

        // Map<String, Float> serialNumberItemPrice = new HashMap<>();

        if (!serialNumbers.isEmpty()) {

            List<InventoryItem> serializedInventoryItems = inventoryItemRepository.selectByFofoIdSerialNumbers(fofoId, serialNumbers, false);

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

            for (InventoryItem inventoryItem : serializedInventoryItems) {

                if (inventoryItem.getGoodQuantity() == 1) {

                    if (serializedInventoryItemMap.containsKey(inventoryItem.getItemId())) {

                        serializedInventoryItemMap.get(inventoryItem.getItemId()).add(inventoryItem);

                    } else {

                        Set<InventoryItem> itemIdInventoryItems = new HashSet<>();

                        itemIdInventoryItems.add(inventoryItem);

                        serializedInventoryItemMap.put(inventoryItem.getItemId(), itemIdInventoryItems);

                    }

                }

            }

        }

        if (!nonSerializedItemIds.isEmpty()) {

            List<InventoryItem> nonSerializedInventoryItems = inventoryItemRepository.selectByFofoIdItemIds(fofoId, nonSerializedItemIds);

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

            for (InventoryItem it : nonSerializedInventoryItems) {

                if (it.getGoodQuantity() > 0) {

                    if (nonSerializedInventoryItemMap.containsKey(it.getItemId())) {

                        nonSerializedInventoryItemMap.get(it.getItemId()).add(it);

                    } else {

                        Set<InventoryItem> tmp = new HashSet<>();

                        tmp.add(it);

                        nonSerializedInventoryItemMap.put(it.getItemId(), tmp);

                    }

                }

            }

        }

        this.validateItemsSerializedNonSerialized(items, itemIdCustomFofoOrderItemMap);

        Map<Integer, Set<InventoryItem>> inventoryItemsToBill = new HashMap<>();

        Map<Integer, Integer> inventoryItemIdQuantityUsed = new HashMap<>(); // to keep track of inventoryitem quanity

        // used for scan records insertion

        LOGGER.info("itemMap keys {}", itemMap.keySet());

        // Fetch live demo serial numbers only for this order's serials (not entire table)

        List<String> orderSerials = serializedInventoryItemMap.values().stream()

                .flatMap(Set::stream)

                .map(InventoryItem::getSerialNumber)

                .collect(Collectors.toList());

        Map<String, LiveDemoSerialNumber> liveDemoSerialNumberMap = new HashMap<>();

        if (!orderSerials.isEmpty()) {

            liveDemoSerialNumberMap = liveDemoBillingRespository.selectBySerialNumbers(orderSerials).stream()

                    .collect(Collectors.toMap(LiveDemoSerialNumber::getSerialNumber, ld -> ld, (a, b) -> a));

        }

        // Lets reduce quantity and decide what inventory items to use.

        for (Item item : items) {

            if (item.getType().equals(ItemType.SERIALIZED)) {

                Set<InventoryItem> inventoryItemsSerializedserialized = serializedInventoryItemMap.get(item.getId());

                if (inventoryItemsSerializedserialized == null) {

                    List<String> invalidSerialNumbers = itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().stream().map(x -> x.getSerialNumber()).collect(Collectors.toList());

                    throw new ProfitMandiBusinessException("invalidSerialNumbers", invalidSerialNumbers, "FFORDR_1004");

                }

                if (itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().size() != inventoryItemsSerializedserialized.size()) {

                    LOGGER.info("InsuredModels: {}, and Serialized: {}", insuredModels.size(), itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().size());

                    if (itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().size() != insuredModels.size()) {

                        List<String> invalidSerialNumbers = itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().stream().map(x -> x.getSerialNumber()).collect(Collectors.toList());

                        throw new ProfitMandiBusinessException("invalidSerialNumbers", invalidSerialNumbers, "FFORDR_1004");

                    }

                }

                for (InventoryItem inventoryItem : inventoryItemsSerializedserialized) {

                    inventoryItem.setGoodQuantity(0);

                    inventoryItemIdQuantityUsed.put(inventoryItem.getId(), 1);

                    LiveDemoSerialNumber liveDemoSerialNumber = liveDemoSerialNumberMap.get(inventoryItem.getSerialNumber());

                    if (liveDemoSerialNumber != null) {

                        liveDemoBillingRespository.delete(liveDemoSerialNumber);

                    }

                }

                inventoryItemsToBill.put(item.getId(), inventoryItemsSerializedserialized);

            } else {

                Set<InventoryItem> inventoryItemsNonSerialized = nonSerializedInventoryItemMap.get(item.getId());

                int quantityToBill = itemIdCustomFofoOrderItemMap.get(item.getId()).getQuantity();

                int totalLeft = quantityToBill;

                Set<InventoryItem> inventoryItemsNonSerializedUsed = new HashSet<>();

                if (inventoryItemsNonSerialized != null) {

                    for (InventoryItem inventoryItem : inventoryItemsNonSerialized) {

                        if (totalLeft > 0) {

                            int toUse = Math.min(totalLeft, inventoryItem.getGoodQuantity());

                            inventoryItemIdQuantityUsed.put(inventoryItem.getId(), toUse);

                            inventoryItem.setGoodQuantity(inventoryItem.getGoodQuantity() - toUse);

                            totalLeft = totalLeft - toUse;

                            inventoryItemsNonSerializedUsed.add(inventoryItem);

                        }

                    }

                }

                if (totalLeft > 0) {

                    // not enough quanity for non-serialized

                    LOGGER.error("not enough quanity for non-serialized");

                    throw new ProfitMandiBusinessException("notEnoughQuantityForNonSerialized", totalLeft, "FFORDR_1005");

                }

                inventoryItemsToBill.put(item.getId(), inventoryItemsNonSerializedUsed);

            }

        }

        // DP/MOP price validation disabled as of 11 sep 2025 as per tarun sir

        String fofoStoreCode = this.getFofoStoreCode(fofoId);

        String documentNumber = null;

        if (noGST) {

            documentNumber = this.getSecurityDepositNumber(fofoId, fofoStoreCode);

        } else {

            documentNumber = this.getInvoiceNumber(fofoId, fofoStoreCode);

        }

        CustomerAddress customerAddress = null;

        if (customCustomer.getCustomerAddressId() != 0) {

            customerAddress = customer.getCustomerAddress().stream().filter(x -> x.getId() == customCustomer.getCustomerAddressId()).findFirst().get();

        }

        FofoOrder fofoOrder = this.createAndGetFofoOrder(customer.getId(), customCustomer.getGstNumber(), fofoId, documentNumber, totalAmount, customCustomer.getCustomerAddressId(), createOrderRequest.getPoId());

        this.createPaymentOptions(fofoOrder, createOrderRequest.getPaymentOptions());

        int retailerAddressId = retailerRegisteredAddressRepository.selectAddressIdByRetailerId(fofoId);

        Address retailerAddress = addressRepository.selectById(retailerAddressId);

        Integer stateId = null;

        if (customerAddress == null || customerAddress.getState() == null || customerAddress.getState().equals(retailerAddress.getState())) {

            try {

                State state = stateRepository.selectByName(retailerAddress.getState());

                stateId = Long.valueOf(state.getId()).intValue();

            } catch (Exception e) {

                LOGGER.error("Unable to get state rates for state: {}", retailerAddress.getState(), e);

            }

        }

        // N+1 fix: Pre-fetch tagListings and GST rates before the loop

        Map<Integer, TagListing> tagListingMap = tagListingRepository.selectByItemIds(itemIdCustomFofoOrderItemMap.keySet());

        Map<Integer, GstRate> gstRateMap = null;

        if (stateId != null) {

            gstRateMap = stateGstRateRepository.getStateTaxRate(new ArrayList<>(itemMap.keySet()), stateId);

        } else {

            gstRateMap = stateGstRateRepository.getIgstTaxRate(new ArrayList<>(itemMap.keySet()));

        }

        // N+1 fix: Collect created FofoOrderItems during the loop instead of re-querying

        List<FofoOrderItem> fofoItems = new ArrayList<>();

        for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {

            FofoOrderItem fofoOrderItem = this.createAndGetFofoOrderItem(customFofoOrderItem, fofoOrder.getId(), itemMap, inventoryItemsToBill.get(customFofoOrderItem.getItemId()), tagListingMap, gstRateMap);

            fofoItems.add(fofoOrderItem);

            Item item = itemMap.get(customFofoOrderItem.getItemId());

            if (item.getType().equals(ItemType.NON_SERIALIZED)) {

                if (customFofoOrderItem.getCustomSerialNumbers() != null && !customFofoOrderItem.getCustomSerialNumbers().isEmpty()) {

                    persistNonSerializedWithCustomSerialNumber(customFofoOrderItem, fofoOrderItem.getId());

                } else {

                    LOGGER.info("Custom serial numbers are empty. Not persisting data.");

                }

            }

            Set<InventoryItem> inventoryItems = inventoryItemsToBill.get(customFofoOrderItem.getItemId());

            this.createFofoLineItem(fofoOrderItem.getId(), inventoryItems, inventoryItemIdQuantityUsed);

            this.updateCurrentInventorySnapshot(currentInventorySnapshots, fofoId, customFofoOrderItem.getItemId(), customFofoOrderItem.getQuantity());

            this.updateInventoryItemsAndScanRecord(inventoryItems, fofoId, inventoryItemIdQuantityUsed, fofoOrder.getId());

        }

        // Use existing itemMap instead of querying DB per item (N+1 fix)

        boolean smartPhone = items.stream().anyMatch(Item::isSmartPhone);

        if (smartPhone) {

            LOGGER.info("Smartphone found in order items");

        } else {

            LOGGER.warn("No smartphones found in fofoItems.");

        }

        if (smartPhone) {

            this.createAndGetHygieneData(fofoOrder.getId(), fofoOrder.getFofoId());

        }

        // insurance calculation is insurance flag is enabled

        //

        if (insuredModels.size() > 0) {

            LOGGER.info("Processing insurane for serialNumbers");

            LOGGER.info("InsuranceModels {}", insuredModels);

            if (createOrderRequest.getCustomer() == null || createOrderRequest.getCustomer().getDateOfBirth() == null) {

                throw new ProfitMandiBusinessException("Order", "Customer Date of Birth", "Customer date of birth is required for insurance");

            }

            LocalDate customerDateOfBirth = LocalDate.from(createOrderRequest.getCustomer().getDateOfBirth());

            fofoOrder.setDateOfBirth(customerDateOfBirth);

            for (InsuranceModel insuranceModel : insuredModels) {

                LOGGER.info("G- {}", insuranceModel.getInsuranceId());

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

                insuranceService.createInsurance(fofoOrder, insuranceModel, false);

            }

        }

        schemeService.processSchemeOut(fofoOrder.getId(), fofoId);

        if (createOrderRequest.getPoId() != 0) {

            PendingOrder po = pendingOrderRepository.selectById(createOrderRequest.getPoId());

            po.setBilledAmount(po.getBilledAmount() + totalAmount);

            // N+1 fix: Batch fetch pending order items instead of querying per item

            List<Integer> poiIds = createOrderRequest.getFofoOrderItems().stream()

                    .map(CustomFofoOrderItem::getPoiId)

                    .filter(id -> id != 0)

                    .collect(Collectors.toList());

            if (!poiIds.isEmpty()) {

                List<PendingOrderItem> pendingOrderItems = pendingOrderItemRepository.selectByIds(poiIds);

                LocalDateTime now = LocalDateTime.now();

                for (PendingOrderItem poi : pendingOrderItems) {

                    poi.setStatus(OrderStatus.BILLED);

                    poi.setBilledTimestamp(now);

                }

            }

            po.setStatus(OrderStatus.BILLED);

        }

        //Process scratch (only if smartphone in order — processScratchOffer re-queries items)

        if (smartPhone) {

            this.processScratchOffer(fofoOrder);

        }

//        persist the data of upgrade offer table

        for (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {

            if (customFofoOrderItem.getCustomerOfferItemId().size() > 0) {

                for (Integer customerOfferItemId : customFofoOrderItem.getCustomerOfferItemId()) {

                    UpgradeOffer upgradeOffer = new UpgradeOffer();

                    upgradeOffer.setOrderId(fofoOrder.getId());

                    upgradeOffer.setCustomerOfferItemId(customerOfferItemId);

                    upgradeOffer.setItemId(customFofoOrderItem.getItemId());

                    Set<SerialNumberDetail> serialNumberDetails = customFofoOrderItem.getSerialNumberDetails();

                    if (!customFofoOrderItem.getSerialNumberDetails().isEmpty()) {

                        String serialNumber = serialNumberDetails.iterator().next().getSerialNumber();

                        upgradeOffer.setSerialNumber(serialNumber);

                        //                Set<String> serialNumbersSet = this.serialNumberDetailsToSerialNumbers(customFofoOrderItem.getSerialNumberDetails());

                        //                LOGGER.info("serialNumbersSet.toString() {}",serialNumbersSet.toString());

                        //                upgradeOffer.setSerialNumber(serialNumbersSet.toString());

                    } else {

                        upgradeOffer.setSerialNumber(null); // Handle case where there is no serial number detail

                    }

                    upgradeOffer.setCreatedTimestamp(LocalDateTime.now());

                    upgradeOffer.setPaymentStatus(UpgradeOfferPaymentStatus.PENDING);

                    upgradeOffer.setStatusDescription(UpgradeOfferPaymentStatus.PENDING.getValue());

                    upgradeOfferRepository.persist(upgradeOffer);

                }

            }

        }

//        enable it fo upsell call - N+1 fix: smartPhone already determined, no need to re-query items

        if (smartPhone && fofoOrder.getId() > 0) {

            List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

                    .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

            if (insurancePolicies.isEmpty()) {

                UpSaleOrder upSaleOrder = new UpSaleOrder();

                upSaleOrder.setCreatedTimestamp(LocalDateTime.now());

                upSaleOrder.setOrderId(fofoOrder.getId());

                upSaleOrder.setFofoId(fofoOrder.getFofoId());

                upSaleOrderRepository.persist(upSaleOrder);

            }

        }

        // Update Partner Opening Stock current qty - N+1 fix: use existing itemMap and batch update

        if (fofoOrder.getId() > 0) {

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

            for (FofoOrderItem fofoOrderItem : fofoItems) {

                itemIdQuantityMap.merge(fofoOrderItem.getItemId(), fofoOrderItem.getQuantity(), Integer::sum);

            }

            smartCartService.minusOpeningStockBatch(itemIdQuantityMap, fofoOrder.getFofoId());

        }

        return fofoOrder.getId();

    }

    @Override

    public void processScratchOffer(FofoOrder fofoOrder) throws ProfitMandiBusinessException {

        boolean isSmartPhonePurchased = false;

        float maxPurchaseValue = 0;

        List<FofoOrderItem> fofoOrderItems = fofoOrderItemRepository.selectByOrderId(fofoOrder.getId());

        // N+1 fix: batch fetch all items instead of querying per order item

        Set<Integer> itemIds = fofoOrderItems.stream()

                .map(FofoOrderItem::getItemId)

                .collect(Collectors.toSet());

        Map<Integer, Item> itemMap = itemRepository.selectByIds(itemIds).stream()

                .collect(Collectors.toMap(Item::getId, item -> item));

        for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

            Item item = itemMap.get(fofoOrderItem.getItemId());

            if (item != null && item.isSmartPhone()) {

                LOGGER.info("fofoItem {}", fofoOrderItem);

                isSmartPhonePurchased = true;

                maxPurchaseValue = Math.max(fofoOrderItem.getSellingPrice(), maxPurchaseValue);

            }

        }

        LocalDate startDate = ProfitMandiConstants.SCRATCH_OFFER_START_DATE;

        LocalDate endDate = ProfitMandiConstants.SCRATCH_OFFER_END_DATE;

        boolean specificPriceOffer = ProfitMandiConstants.SPECIFIC_PRICE_OFFER;

        boolean randomOffer = ProfitMandiConstants.RANDOM_OFFER;

        if (isSmartPhonePurchased) {

            if (LocalDateTime.now().isAfter(startDate.atStartOfDay()) && LocalDateTime.now().isBefore(endDate.atTime(Utils.MAX_TIME))) {

                Customer customer = customerRepository.selectById(fofoOrder.getCustomerId());

                try {

                    this.sendAppDownloadBillingOffer(customer.getMobileNumber());

                } catch (Exception e) {

                    LOGGER.error("Failed to send app download billing offer for customer {}", customer.getMobileNumber(), e);

                }

                if (specificPriceOffer) {

                    this.createSpecificPriceScratchOffer(fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId(), fofoOrder.getFofoId(), maxPurchaseValue);

                } else if (randomOffer) {

                    this.createRandomScratchOffer(fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId());

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

                } else {

                    this.createScratchOffer(fofoOrder.getFofoId(), fofoOrder.getInvoiceNumber(), fofoOrder.getCustomerId());

                }

            }

        }

    }

    @Override

    public ScratchedGift getSelectedGift(double purchaseAmount, int fofoId) throws ProfitMandiBusinessException {

        Map<ScratchedGift, Long> scratchOfferCountMap = scratchOfferRepository.countOffersByDateRange(

                ProfitMandiConstants.SCRATCH_OFFER_START_DATE, ProfitMandiConstants.SCRATCH_OFFER_END_DATE

        );

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

        LocalDateTime startDateTime = ProfitMandiConstants.SCRATCH_OFFER_START_DATE.atStartOfDay();

        LocalDateTime endDateTime = ProfitMandiConstants.SCRATCH_OFFER_START_DATE.atTime(LocalTime.MAX);

        LOGGER.info("start date {}", startDateTime);

        LOGGER.info("end date {}", endDateTime);

        RandomCollection<ScratchedGift> giftRandomCollection = createDynamicGiftSeries(scratchOfferCountMap, purchaseAmount, fofoId);

        if (giftRandomCollection.size() > 0) {

            ScratchedGift selectedGift = giftRandomCollection.next();

            // Ensure one LED for 175139615 and one Oven for 175139583

            if (selectedGift == ScratchedGift.LED || selectedGift == ScratchedGift.MICROWAVE_OVEN) {

                if (!PREMIUM_ELIGIBLE_PARTNERS.contains(fofoId)) {

                    LOGGER.info("Partner {} not eligible for {}", fofoId, selectedGift);

                    return ScratchedGift.ACCESSORIES_50_PERCENT_OFF; // Default alternate gift

                }

                // Restrict LED to Partner 175139615 and Oven to Partner 175139583

                if ((selectedGift == ScratchedGift.LED && fofoId != 175139615) ||

                        (selectedGift == ScratchedGift.MICROWAVE_OVEN && fofoId != 175139583)) {

                    LOGGER.info("Partner {} not eligible for {}", fofoId, selectedGift);

                    return ScratchedGift.ACCESSORIES_50_PERCENT_OFF;

                }

                // Ensure only one LED and one Microwave Oven per day

                long ledCount = scratchOfferCountMap.getOrDefault(ScratchedGift.LED, 0L);

                long ovenCount = scratchOfferCountMap.getOrDefault(ScratchedGift.MICROWAVE_OVEN, 0L);

                if ((selectedGift == ScratchedGift.LED || selectedGift == ScratchedGift.MICROWAVE_OVEN)

                        && (ledCount > 0 && ovenCount > 0)) {

                    LOGGER.info("Both LED and Microwave Oven already given today.");

                    return ScratchedGift.ACCESSORIES_50_PERCENT_OFF;

                }

                if ((selectedGift == ScratchedGift.LED && ledCount > 0)) {

                    LOGGER.info("LED already given today.");

                    return ScratchedGift.ACCESSORIES_50_PERCENT_OFF;

                }

                if ((selectedGift == ScratchedGift.LED)) {

                    LOGGER.info("LED already given today.");

                    return ScratchedGift.ACCESSORIES_50_PERCENT_OFF;

                }

                if ((selectedGift == ScratchedGift.MICROWAVE_OVEN && ovenCount > 0)) {

                    LOGGER.info("Oven already given today.");

                    return ScratchedGift.ACCESSORIES_50_PERCENT_OFF;

                }

            }

            //  Ensure only one Neckband per partner per day

            if (selectedGift == ScratchedGift.NECK_BAND) {

                List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoId(fofoId, startDateTime, endDateTime, 0, 0);

                List<String> invoiceNumbers = fofoOrders.stream().map(FofoOrder::getInvoiceNumber).collect(Collectors.toList());

                List<ScratchOffer> offers = scratchOfferRepository.selectByInvoiceNumbers(invoiceNumbers);

                LOGGER.info("offers for partner {}", offers);

                boolean neckbandGivenToday = offers.stream().anyMatch(offer -> offer.getOfferName().equals(ScratchedGift.NECK_BAND));

                if (neckbandGivenToday) {

                    LOGGER.info("Neckband already given today for partner {}", fofoId);

                    return ScratchedGift.ACCESSORIES_50_PERCENT_OFF;

                }

            }

            return selectedGift;

        }

        return ScratchedGift.ACCESSORIES_50_PERCENT_OFF;

    }