Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.pricing;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.GrnPendingDataModel;
import com.spice.profitmandi.common.util.FormattingUtils;
import com.spice.profitmandi.dao.entity.fofo.InventoryItem;
import com.spice.profitmandi.dao.entity.transaction.PriceDrop;
import com.spice.profitmandi.dao.entity.transaction.PriceDropIMEI;
import com.spice.profitmandi.dao.enumuration.transaction.PriceDropImeiStatus;
import com.spice.profitmandi.dao.repository.fofo.InventoryItemRepository;
import com.spice.profitmandi.dao.repository.transaction.OrderRepository;
import com.spice.profitmandi.dao.repository.transaction.PriceDropIMEIRepository;
import com.spice.profitmandi.dao.repository.transaction.PriceDropRepository;
import com.spice.profitmandi.service.inventory.InventoryService;
import com.spice.profitmandi.service.scheme.SchemeService;
import com.spice.profitmandi.service.wallet.WalletService;
import in.shop2020.model.v1.order.WalletReferenceType;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.text.MessageFormat;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Shared unit of work for price-hike deduction. {@link #deductPartnerUnits} (no transaction of its own —
 * runs in the caller's) is used by both the GRN hook (inside the GRN transaction) and the on-demand
 * endpoint. The endpoint path additionally uses the REQUIRES_NEW methods here so each retailer is isolated.
 */
@Component
public class PriceHikeWorker {

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

    @Autowired
    private PriceDropRepository priceDropRepository;
    @Autowired
    private PriceDropIMEIRepository priceDropIMEIRepository;
    @Autowired
    private InventoryItemRepository inventoryItemRepository;
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private WalletService walletService;
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private SchemeService schemeService;

    /**
     * Idempotent, for one retailer's in-hand items against one hike. Runs in the caller's transaction.
     * Creates APPROVED rows, raises the item's price-drop accumulator so scheme margin follows the new
     * (hiked) price, debits the wallet, and — when {@code recomputeSchemes} is true — reverses and
     * reprocesses schemes as the price-drop flow does. Serials already recorded for this hike are skipped.
     *
     * @param recomputeSchemes false on the GRN path (the item has no SchemeInOut yet and the GRN flow's
     *                         own processSchemeIn runs right after, on the raised basis); true on the
     *                         endpoint path (the item is already GRN'd and has schemes to reprocess).
     */
    public void deductPartnerUnits(PriceDrop hike, int retailerId, List<InventoryItem> items, boolean recomputeSchemes)
            throws ProfitMandiBusinessException {
        if (items == null || items.isEmpty()) {
            return;
        }
        Set<String> existing = priceDropIMEIRepository.selectByPriceDropId(hike.getId()).stream()
                .filter(x -> x.getPartnerId() == retailerId)
                .map(PriceDropIMEI::getImei).collect(Collectors.toSet());
        List<InventoryItem> fresh = items.stream()
                .filter(ii -> ii.getSerialNumber() != null && !existing.contains(ii.getSerialNumber()))
                .collect(Collectors.toList());
        if (fresh.isEmpty()) {
            return;
        }
        LocalDateTime now = LocalDateTime.now();
        for (InventoryItem ii : fresh) {
            PriceDropIMEI row = new PriceDropIMEI();
            row.setPriceDropId(hike.getId());
            row.setPartnerId(retailerId);
            row.setImei(ii.getSerialNumber());
            row.setStatus(PriceDropImeiStatus.APPROVED);
            row.setInventoryItemId(ii.getId());
            row.setCreditTimestamp(now);
            row.setUpdateTimestamp(now);
            priceDropIMEIRepository.persist(row);
        }
        // Raise the item's cost basis (amount is negative), so scheme/offer margins track the new price.
        inventoryService.updatePriceDrop(fresh, hike.getAmount());
        if (recomputeSchemes) {
            String reversalReason = MessageFormat.format(
                    "Scheme reversal for Price Hike of Rs.{0} on {1}. Total {2} item(s)",
                    hike.getAmount(), FormattingUtils.formatDate(hike.getAffectedOn()), fresh.size());
            schemeService.reverseSchemes(fresh, hike.getId(), reversalReason);
            schemeService.processSchemeIn(fresh);
        }
        // amount is negative for a hike, so amount * count reduces the wallet balance (a debit).
        String reason = MessageFormat.format("Price Hike recovery of Rs.{0} per unit. Total {1} item(s)",
                FormattingUtils.formatDecimal(Math.abs(hike.getDropAmount())), fresh.size());
        walletService.addAmountToWallet(retailerId, hike.getId(), WalletReferenceType.PRICE_DROP, reason,
                hike.getAmount() * fresh.size(), hike.getAffectedOn());
        LOGGER.info("Price hike {} — debited retailer {} for {} unit(s), recomputeSchemes={}",
                hike.getId(), retailerId, fresh.size(), recomputeSchemes);
    }

    /** Endpoint path: eligible (gap-billed) serials for a hike, grouped by retailer. Own transaction. */
    @Transactional(propagation = Propagation.REQUIRES_NEW, readOnly = true)
    public Map<Integer, List<String>> loadEligibleUnits(int priceDropId) throws ProfitMandiBusinessException {
        PriceDrop pd = priceDropRepository.selectById(priceDropId);
        if (pd == null || pd.getAmount() >= 0) {
            return Collections.emptyMap();
        }
        List<GrnPendingDataModel> billed = orderRepository.selectAllOrdersByBilledDateCatalogId(
                pd.getCatalogItemId(), pd.getAffectedOn(), pd.getCreatedOn());
        return billed.stream()
                .filter(x -> x.getSerialNumber() != null && x.getRetailerId() > 0)
                .collect(Collectors.groupingBy(GrnPendingDataModel::getRetailerId,
                        Collectors.mapping(GrnPendingDataModel::getSerialNumber, Collectors.toList())));
    }

    /**
     * Endpoint path: one retailer, its own transaction. Processes only serials already GRN'd (present in
     * inventory) — full scheme reprocess applies to them; not-yet-GRN'd serials are left for the GRN hook.
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deductForRetailer(int priceDropId, int retailerId, List<String> serials)
            throws ProfitMandiBusinessException {
        PriceDrop hike = priceDropRepository.selectById(priceDropId);
        if (hike == null || hike.getAmount() >= 0) {
            return;
        }
        List<InventoryItem> items = inventoryItemRepository
                .selectByFofoIdSerialNumbers(retailerId, new HashSet<>(serials), false);
        deductPartnerUnits(hike, retailerId, items, true);
    }
}