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

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

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

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

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

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

        }

    }

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

    static {

        GIFT_QUANTITIES.put(ScratchedGift.CASSROLE, 120);

        GIFT_QUANTITIES.put(ScratchedGift.NECK_BAND, 920);

        GIFT_QUANTITIES.put(ScratchedGift.JUICE_JUG, 160);

        GIFT_QUANTITIES.put(ScratchedGift.INSULATED_FLASK, 140);

        GIFT_QUANTITIES.put(ScratchedGift.ACCESSORIES_50_PERCENT_OFF, 500);

        GIFT_QUANTITIES.put(ScratchedGift.EW, 1500);

    }

    static {

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

        GIFT_SERIES.put(12001.0, Arrays.asList(ScratchedGift.CASSROLE, ScratchedGift.NECK_BAND, ScratchedGift.JUICE_JUG, ScratchedGift.INSULATED_FLASK));

        GIFT_SERIES.put(35001.0, Arrays.asList(ScratchedGift.CASSROLE, ScratchedGift.NECK_BAND, ScratchedGift.JUICE_JUG, ScratchedGift.INSULATED_FLASK));

    }

    @Override

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

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

        CustomCustomer customCustomer = createOrderRequest.getCustomer();

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

        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;

        int changedTotalBillAmount = 0;

        for (CustomPaymentOption cpo : createOrderRequest.getPaymentOptions()) {

            changedTotalBillAmount += cpo.getAmount();

        }

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

            if (customFofoOrderItem.getPoiId() > 0) {

                PendingOrderItem pendingOrderItem = pendingOrderItemRepository.selectById(customFofoOrderItem.getPoiId());

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

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

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

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

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

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

            noGST = item.getHsnCode().equals("NOGST");

            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.setInsuranceId(serialNumberDetail.getInsurance());

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

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

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

                            LOGGER.info("SerialNumber Detqail InsuranceId - {}", serialNumberDetail.getInsurance());

                            LOGGER.info("product description - {}", mobileInsurancePlan);

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

                                imFree.setInsuranceId(freePlan.getProductId());

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

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

        for (Item item : items) {

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

                // TODO:handle null

                if (serializedInventoryItemMap.get(item.getId()) == null || itemIdCustomFofoOrderItemMap.get(item.getId()).getSerialNumberDetails().size() != serializedInventoryItemMap.get(item.getId()).size()) {

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

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

                }

                List<String> serialNumberList = liveDemoBillingRespository.selectAllSerialNumber();

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

                for (InventoryItem inventoryItem : inventoryItemsSerializedserialized) {

                    inventoryItem.setGoodQuantity(0);

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

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

                        LiveDemoSerialNumber liveDemoSerialNumber = liveDemoBillingRespository.selectBySerialNumber(inventoryItem.getSerialNumber());

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

            }

        }

        Map<Integer, PriceModel> itemIdMopPriceMap = pricingService.getPurchasePriceMopPriceNotFound(itemIdCustomFofoOrderItemMap.keySet(), fofoId);

        LOGGER.info("itemIdMopMap {}", itemIdMopPriceMap);

        if (accessoriesDeals) {

            this.validateDpPrice(fofoId, itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);

        } else {

            this.validateMopPrice(fofoId, itemIdMopPriceMap, itemIdCustomFofoOrderItemMap);

        }

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

        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 (CustomFofoOrderItem customFofoOrderItem : createOrderRequest.getFofoOrderItems()) {

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

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

        }

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

        boolean smartPhone = false;

        for (FofoOrderItem fofoOrderItem : fofoItems) {

            Item item = itemRepository.selectById(fofoOrderItem.getItemId());

            if (item.isSmartPhone()) {

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

                smartPhone = true;

            }

        }

        if (!smartPhone) {

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

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

            fofoOrder.setDateOfBirth(customerDateOfBirth);

            for (InsuranceModel insuranceModel : insuredModels) {

                LOGGER.info("Creating insurance for {}", insuranceModel.getInsuranceId());

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

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

                PendingOrderItem poi = pendingOrderItemRepository.selectById(cfoi.getPoiId());

                poi.setStatus(OrderStatus.BILLED);

                poi.setBilledTimestamp(LocalDateTime.now());

            }

            po.setStatus(OrderStatus.BILLED);

        }

        //Process scratch

        this.processScratchOffer(fofoOrder);

//        persist the data of upgrade offer table

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

            if (customFofoOrderItem.getCustomerOfferItemId() > 0) {

                UpgradeOffer upgradeOffer = new UpgradeOffer();

                upgradeOffer.setOrderId(fofoOrder.getId());

                upgradeOffer.setCustomerOfferItemId(customFofoOrderItem.getCustomerOfferItemId());

                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

        if (smartPhone) {

            if (fofoOrder.getId() > 0) {

                List<InsurancePolicy> insurancePolicies = insurancePolicyRepository

                        .selectByRetailerIdInvoiceNumber(fofoOrder.getInvoiceNumber());

                if (insurancePolicies.isEmpty()) {

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

                    for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

                        Item item = itemRepository.selectById(fofoOrderItem.getItemId());

                        if (item.isSmartPhone()) {

                            UpSaleOrder upSaleOrder = new UpSaleOrder();

                            upSaleOrder.setCreatedTimestamp(LocalDateTime.now());

                            upSaleOrder.setOrderId(fofoOrder.getId());

                            upSaleOrder.setFofoId(fofoOrder.getFofoId());

                            upSaleOrderRepository.persist(upSaleOrder);

                            break; // Exit the loop after persisting the UpSaleOrder for the first smartphone

                        }

                    }

                }

            }

        }

        // Update Partner Opening Stock current qty

        if (fofoOrder.getId() > 0) {

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

            for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

                Item item = itemRepository.selectById(fofoOrderItem.getItemId());

                smartCartService.minusOpeningStock(item.getId(), fofoOrder.getFofoId(), fofoOrderItem.getQuantity());

            }

        }

        return fofoOrder.getId();

    }

    @Override

    public void processScratchOffer(FofoOrder fofoOrder) throws ProfitMandiBusinessException {

        boolean isSmartPhonePurchased = false;

        float maxPurchaseValue = 0;

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

        for (FofoOrderItem fofoOrderItem : fofoOrderItems) {

            Item item = itemRepository.selectById(fofoOrderItem.getItemId());

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

                    // TODO Auto-generated catch block

                    e.printStackTrace();

                }

                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 {

        //Iterating map in reverse order of values

        Map<ScratchedGift, Long> scratchOfferCountMap = scratchOfferRepository.countOffersByDateRange(ProfitMandiConstants.SCRATCH_OFFER_START_DATE, ProfitMandiConstants.SCRATCH_OFFER_END_DATE);

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

        if (giftRandomCollection.size() > 0) {

            return giftRandomCollection.next();

        } else if (purchaseAmount < 35000) {

            // Default gift if no match found

            return ScratchedGift.EW;

        } else {

            return ScratchedGift.ACCESSORIES_50_PERCENT_OFF;

        }

    }

    public RandomCollection<ScratchedGift> createDynamicGiftSeries(Map<ScratchedGift, Long> soldGiftContMap, Double sellingPrice, int fofoId) throws ProfitMandiBusinessException {

        int index = 0;

        RandomCollection<ScratchedGift> randomCollection = new RandomCollection<>();

        PartnerType partnerType = partnerTypeChangeService.getTypeOnDate(fofoId, LocalDate.now());

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

        if (partnerType.equals(PartnerType.BRONZE)) {

            LOGGER.info("partnerType if- {}", partnerType);

            sellingPrice = 0.0;

        }

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

            Double price = PRICE_RANGE.get(i);

            Double nextPrice = Double.MAX_VALUE;

            if (i != PRICE_RANGE.size() - 1) {

                nextPrice = PRICE_RANGE.get(i + 1);

            }

            if (sellingPrice >= price && sellingPrice < nextPrice) {

                int divisor = PRICE_RANGE.size() - index;

                LOGGER.info("Processing price range: {}, sellingPrice: {}", price, sellingPrice);

                for (ScratchedGift gift : GIFT_SERIES.get(price)) {

                    int remainingQty = GIFT_QUANTITIES.get(gift) - soldGiftContMap.getOrDefault(gift, 0L).intValue();

                    LOGGER.info("Checking gift: {}, remainingQty: {}", gift, remainingQty);

                    if (remainingQty > 0) {

                        int weight = (remainingQty > divisor) ? remainingQty / divisor : remainingQty;

                        randomCollection.add(weight, gift);

                        LOGGER.info("Added gift: {}, weight: {}", gift, weight);

                    }

                }

                break; // Exit the loop once the correct price range is processed

            }

            index++;

        }

        // If no gifts were added, log and handle potential issues here

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

            LOGGER.info("No gifts added for sellingPrice: {} in createDynamicGiftSeries", sellingPrice);

        }

        LOGGER.info("randomCollectionSize {}, partnerType {}, sellingPrice {}", randomCollection.size(), partnerType, sellingPrice);

        return randomCollection;

    }

    /*static {

        RandomCollection<ScratchedGift> map1 = new RandomCollection<ScratchedGift>().

                add(100d, ScratchedGift.GIFT_BOWL);

        GIFT_SERIES.put(0.0, map1);

        //Map<ScratchedGift, Double> map2 = new HashMap<>();

        RandomCollection<ScratchedGift> map2 = new RandomCollection<ScratchedGift>()

                .add(40d, ScratchedGift.GIFT_BOWL)

                .add(20d, ScratchedGift.NECK_BAND)

                .add(30d, ScratchedGift.FLASKNMUG)

                .add(10d, ScratchedGift.ELECTRIC_KETTLE);

        GIFT_SERIES.put(10001.0, map2);

        RandomCollection<ScratchedGift> map3 = new RandomCollection<ScratchedGift>()

                .add(25d, ScratchedGift.GIFT_BOWL)

                .add(30d, ScratchedGift.NECK_BAND)

                .add(10d, ScratchedGift.SPEAKER)

                .add(25d, ScratchedGift.FLASKNMUG)

                .add(10d, ScratchedGift.ELECTRIC_KETTLE);

        GIFT_SERIES.put(18001.0, map3);

        RandomCollection<ScratchedGift> map4 = new RandomCollection<ScratchedGift>()

                .add(30d, ScratchedGift.NECK_BAND)

                .add(20d, ScratchedGift.SPEAKER)

                .add(20d, ScratchedGift.FLASKNMUG)

                .add(30d, ScratchedGift.ELECTRIC_KETTLE);

        GIFT_SERIES.put(25001.0, map4);

        RandomCollection<ScratchedGift> map5 = new RandomCollection<ScratchedGift>()

                .add(40d, ScratchedGift.SPEAKER)

                .add(60d, ScratchedGift.SMART_WATCH);

        GIFT_SERIES.put(50001.0, map5);

    }*/

    private void createSpecificPriceScratchOffer(String invoiceNumber, int customerId, int fofoId, float purchaseAmount) throws ProfitMandiBusinessException {

        ScratchedGift selectedGift = getSelectedGift(purchaseAmount, fofoId);

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

            so2.setCustomerId(customerId);

            so2.setUnlockedAt(LocalDateTime.now());

            scratchOfferRepository.persist(so2);

        }

    }

    private void createRandomScratchOffer(String invoiceNumber, int customerId) {

        ScratchedGift selectedGift = getScratchedGiftRandomAccordingQuantity(customerId);

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

            so2.setCustomerId(customerId);

            so2.setUnlockedAt(LocalDateTime.now());

            scratchOfferRepository.persist(so2);

        }

    }

    private ScratchedGift getScratchedGiftRandom(int fofoId, int customerId) throws ProfitMandiBusinessException {

        Map<Integer, ScratchedGift> giftSeries = new HashMap<>();

        giftSeries.put(1, ScratchedGift.MINI_CHOPPER);

        giftSeries.put(2, ScratchedGift.FRUIT_JUICER);

        giftSeries.put(3, ScratchedGift.STEAM_IRON);

        List<FofoOrder> fofoOrders = fofoOrderRepository.selectByFofoIdBetweenCreatedTimeStamp(fofoId, ProfitMandiConstants.SCRATCH_OFFER_START_DATE.atStartOfDay(),

                ProfitMandiConstants.SCRATCH_OFFER_END_DATE.atTime(Utils.MAX_TIME));

        ScratchedGift gift = ScratchedGift.BLNT;

        Random random = new Random();

        int rand;

        while (true) {

            rand = random.nextInt(4);

            if (rand != 0) break;

        }

        if (fofoOrders.isEmpty()) {

            gift = giftSeries.get(rand);

        } else {

            List<String> invoiceNumbers = fofoOrders.stream().filter(x -> x.getCancelledTimestamp() == null).map(x -> x.getInvoiceNumber()).collect(Collectors.toList());

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

            if (scratchOffers.isEmpty()) {

                gift = giftSeries.get(rand);

            } else {

                List<ScratchOffer> bigGifts = scratchOffers.stream().filter(x -> !x.getOfferName().equals(ScratchedGift.BLNT) && !x.getOfferName().equals(ScratchedGift.EW)).collect(Collectors.toList());