Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.cart;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.dao.entity.catalog.Item;
import com.spice.profitmandi.dao.entity.fofo.CurrentInventorySnapshot;
import com.spice.profitmandi.dao.entity.fofo.FofoOpeningStock;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
import com.spice.profitmandi.dao.model.PoAndGrnPendingPartnerStockModel;
import com.spice.profitmandi.dao.model.SoldAllCatalogitemQtyByPartnerModel;
import com.spice.profitmandi.dao.model.SoldFocusedItemPartnerWiseModel;
import com.spice.profitmandi.dao.repository.catalog.ItemRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.fofo.ActivatedImeiRepository;
import com.spice.profitmandi.dao.repository.fofo.CurrentInventorySnapshotRepository;
import com.spice.profitmandi.dao.repository.fofo.FofoOpeningStockRepository;
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
import com.spice.profitmandi.service.inventory.SaholicInventoryService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.persistence.TypedQuery;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.stream.Collectors;

@Component
public class SmartCartServiceImpl implements SmartCartService {

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

    private static final Logger logger = LogManager.getLogger(SmartCartServiceImpl.class);

    @Autowired
    SessionFactory sessionFactory;

    @Autowired
    ItemRepository itemRepository;

    @Autowired
    InventoryItemRepository inventoryItemRepository;


    @Autowired
    CurrentInventorySnapshotRepository currentInventorySnapshotRepository;

    @Autowired
    FofoOpeningStockRepository fofoOpeningStockRepository;


    @Autowired
    private FofoStoreRepository fofoStoreRepository;

    @Autowired
    private SaholicInventoryService saholicInventoryService;

    @Autowired
    private ActivatedImeiRepository activatedImeiRepository;


    @Override
    public List<SoldFocusedItemPartnerWiseModel> getAllSoldFocusModelByPartner(int fofoId, LocalDateTime orderDate){
        Session session = sessionFactory.getCurrentSession();
        final TypedQuery<SoldFocusedItemPartnerWiseModel> typedQuerySimilar = session.createNamedQuery("Focused.soldFocusItemByPartner", SoldFocusedItemPartnerWiseModel.class);

        typedQuerySimilar.setParameter("fofoId", fofoId);
        typedQuerySimilar.setParameter("orderDate", orderDate);

        return typedQuerySimilar.getResultList();
    }

    @Override
    public List<SoldAllCatalogitemQtyByPartnerModel> getAllSoldCatalogItemByPartner(int fofoId, LocalDateTime startOfday, LocalDateTime endOfDay){
        Session session = sessionFactory.getCurrentSession();
        final TypedQuery<SoldAllCatalogitemQtyByPartnerModel> typedQuerySimilar = session.createNamedQuery("FofoOrder.soldAllItemByToday", SoldAllCatalogitemQtyByPartnerModel.class);

        typedQuerySimilar.setParameter("fofoId", fofoId);
        typedQuerySimilar.setParameter("startOfDay", startOfday);
        typedQuerySimilar.setParameter("endOfDay", endOfDay);

        return typedQuerySimilar.getResultList();
    }

    @Override
    public List<PoAndGrnPendingPartnerStockModel> getAllGrnPendingAndPoPartnerStock(int fofoId){
        Session session = sessionFactory.getCurrentSession();
        final TypedQuery<PoAndGrnPendingPartnerStockModel> typedQuerySimilar = session.createNamedQuery("Order.partnerStockPoAndGrnPending", PoAndGrnPendingPartnerStockModel.class);

        typedQuerySimilar.setParameter("fofoId", fofoId);

        return typedQuerySimilar.getResultList();
    }

    @Override
    public void addOpeningStock(int itemId, int fofoId, int quantity) throws ProfitMandiBusinessException{
        int catalogId = itemRepository.selectById(itemId).getCatalogItemId();
        FofoOpeningStock fofoOpeningStock = fofoOpeningStockRepository.findByFofoIdAndCatalogId(fofoId,catalogId);
        if(fofoOpeningStock !=null){
            int updatedQty = fofoOpeningStock.getCurrentQty() + quantity;
            fofoOpeningStock.setCurrentQty(updatedQty);
        } else {
            FofoOpeningStock newOpeningStock = new FofoOpeningStock();
            newOpeningStock.setFofoId(fofoId);
            newOpeningStock.setCatalogId(catalogId);
            newOpeningStock.setOpeningDate(LocalDate.now());
            newOpeningStock.setOpeningQty(quantity);
            newOpeningStock.setCurrentQty(quantity);
            fofoOpeningStockRepository.persist(newOpeningStock);
        }

    }

    @Override
    public void minusOpeningStock(int itemId, int fofoId, int quantity) throws ProfitMandiBusinessException{
        int catalogId = itemRepository.selectById(itemId).getCatalogItemId();
        FofoOpeningStock fofoOpeningStock = fofoOpeningStockRepository.findByFofoIdAndCatalogId(fofoId,catalogId);
        if(fofoOpeningStock !=null){
            int updatedQty = Math.max(fofoOpeningStock.getCurrentQty() - quantity, 0);
            fofoOpeningStock.setCurrentQty(updatedQty);
        }
    }

    @Override
    public void minusOpeningStockBatch(Map<Integer, Integer> itemIdQuantityMap, int fofoId) throws ProfitMandiBusinessException {
        if (itemIdQuantityMap == null || itemIdQuantityMap.isEmpty()) {
            return;
        }

        // Batch fetch all items - 1 DB call instead of N
        List<Item> items = itemRepository.selectByIds(itemIdQuantityMap.keySet());

        // Build itemId -> catalogId map
        Map<Integer, Integer> itemToCatalogMap = items.stream()
                .collect(Collectors.toMap(Item::getId, Item::getCatalogItemId));

        // Get unique catalogIds and build catalogId -> quantity map
        Map<Integer, Integer> catalogQuantityMap = new HashMap<>();
        for (Map.Entry<Integer, Integer> entry : itemIdQuantityMap.entrySet()) {
            Integer catalogId = itemToCatalogMap.get(entry.getKey());
            if (catalogId != null) {
                catalogQuantityMap.merge(catalogId, entry.getValue(), Integer::sum);
            }
        }

        // Batch fetch all FofoOpeningStock records - 1 DB call instead of N
        List<FofoOpeningStock> openingStocks = fofoOpeningStockRepository.findByFofoIdAndCatalogIds(
                fofoId, catalogQuantityMap.keySet());

        // Update each opening stock
        for (FofoOpeningStock openingStock : openingStocks) {
            Integer quantityToSubtract = catalogQuantityMap.get(openingStock.getCatalogId());
            if (quantityToSubtract != null) {
                openingStock.setCurrentQty(Math.max(openingStock.getCurrentQty() - quantityToSubtract, 0));
            }
        }
    }

    @Override
    public Set<Integer> getAllItemIdsForSmartCartOfPartner(int fofoId) throws ProfitMandiBusinessException {
        LocalDateTime todayDate = LocalDate.now().atStartOfDay();
        LocalDateTime fortyFiveAgoDate = todayDate.minusDays(45).with(LocalTime.MAX);
        List<SoldAllCatalogitemQtyByPartnerModel> soldAllCatalogitemQtyByPartnerModels = this.getAllSoldCatalogItemByPartner(fofoId,fortyFiveAgoDate,todayDate);
        Set<Integer> soldCatalogsIn45Days = soldAllCatalogitemQtyByPartnerModels.stream().map(x->x.getCatalogId()).collect(Collectors.toSet());
        if(soldCatalogsIn45Days.size() == 0) {
            return new HashSet<>();
        }
        logger.info("soldCatalogsIn45Days {}",soldCatalogsIn45Days);
        List<Item> soldItems = itemRepository.selectAllByCatalogIds(soldCatalogsIn45Days);
        Set<Integer> soldItemIds = soldItems.stream().map(x->x.getId()).collect(Collectors.toSet());
        List<CurrentInventorySnapshot> currentInventorySnapshots =  currentInventorySnapshotRepository.selectByFofoItemIds(fofoId,soldItemIds);
        Set<Integer> instockItemIds = currentInventorySnapshots.stream().filter(x -> x.getAvailability() > 0).map(x->x.getItemId()).collect(Collectors.toSet());

        if(instockItemIds.size() > 0) {
                Set<Integer> filteredCatalogIds = itemRepository.selectByIds(instockItemIds).stream().map(x->x.getCatalogItemId()).collect(Collectors.toSet());
//            this logis has been stop as of now we are not checking that sold catalog is avaialable or not in our stock
            /*List<Item> soldItems = itemRepository.selectAllByCatalogIds(filteredCatalogIds);

            List<Integer> soldItemIds = soldItems.stream().map(x -> x.getId()).collect(Collectors.toList());

            FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);

            Map<Integer, List<WarehouseItemQtyModel>> itemQtyMap = saholicInventoryService.getSaholicStock(fofoStore.getWarehouseId(), soldItemIds);


            // Collect items where availability is greater than 0
            Set<Integer> saholicStockItemIds = itemQtyMap.entrySet().stream()
                    .filter(entry -> entry.getValue().stream().anyMatch(x -> x.getNetAvailability() > 0))
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toSet());

            if (saholicStockItemIds.size() > 0) {
                List<Item> items = itemRepository.selectByIds(saholicStockItemIds);

                Set<Integer> saholictStockCatalogIds = items.stream().map(x -> x.getCatalogItemId()).collect(Collectors.toSet());


                return saholictStockCatalogIds;
            } else {

                return new HashSet<>();
            }*/
            return  filteredCatalogIds;
          } else {
            return new HashSet<>();
         }
        }


    @Override
    public Map<Integer, Map<Integer, Integer>> activatedButNotBilledCatalogQtyMap() throws ProfitMandiBusinessException {
        List<FofoStore> fofoStores = fofoStoreRepository.selectAll();
        List<Integer> fofoIds = fofoStores.stream().map(x -> x.getId()).collect(Collectors.toList());
        Map<Integer, Map<Integer, Integer>> fofoCatalogQtyMap = new HashMap<>();
        for (Integer fofoId : fofoIds) {
            List<InventoryItem> inventoryItems = inventoryItemRepository.selectByActivatedNotSold(fofoId);
            Map<Integer, Integer> catalogIdQtyMap = new HashMap<>();
            for (InventoryItem inventoryitem : inventoryItems) {
                Item item = itemRepository.selectById(inventoryitem.getItemId());
                Integer catalogId = item.getCatalogItemId(); // Assuming this exists
                catalogIdQtyMap.put(catalogId, catalogIdQtyMap.getOrDefault(catalogId, 0) + 1);
            }
            fofoCatalogQtyMap.put(fofoId, catalogIdQtyMap);
        }
        //System.out.println("fofoCatalogQtyMap {}" + fofoCatalogQtyMap);
        return fofoCatalogQtyMap;

    }

}