Subversion Repositories SmartDukaan

package com.spice.profitmandi.service;

import com.spice.profitmandi.common.enumuration.ActivationType;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.entity.fofo.PartnerDailyInvestment;
import com.spice.profitmandi.dao.enumuration.dtr.AgendaType;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.hibernate.SessionFactory;
import org.hibernate.query.NativeQuery;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class AgendaAutoRuleServiceImpl implements AgendaAutoRuleService {

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

    @Autowired
    FofoStoreRepository fofoStoreRepository;

    @Autowired
    PartnerInvestmentService partnerInvestmentService;

    @Autowired
    AgendaConfigService agendaConfigService;

    @Autowired
    AgendaAutoRuleApplier agendaAutoRuleApplier;

    @Autowired
    SessionFactory sessionFactory;

    @Override
    @Transactional
    public AgendaSyncResult syncAllPartners() {
        AgendaSyncResult result = new AgendaSyncResult();
        try {
            // Global-default params. Sales window params (baselineDays/windowDays)
            // are honored globally only — the batched SQL below cannot vary the
            // time window per partner. flagPct/clearPct etc. resolve per partner.
            Map<String, Double> salesDefaults = agendaConfigService.getParams(AgendaType.LOW_SALES.name(), 0);
            int windowDays = (int) doubleOr(salesDefaults.get("windowDays"), 30);
            int baselineDays = (int) doubleOr(salesDefaults.get("baselineDays"), 90);
            int lookbackDays = windowDays + baselineDays;

            List<FofoStore> candidates = fofoStoreRepository.selectAllFranchiseStores();
            candidates.removeIf(s -> !s.isActive() || s.isInternal() || s.isClosed());

            Map<Integer, double[]> salesByFofo = gatherSales(windowDays, lookbackDays);
            Map<Integer, Integer> billGapByFofo = gatherPurchaseGaps();
            Map<Integer, double[]> loanByFofo = gatherLoanAges();

            LocalDateTime activationCutoff = LocalDateTime.now().minusDays(lookbackDays);

            for (FofoStore store : candidates) {
                int fofoId = store.getId();
                result.setScanned(result.getScanned() + 1);
                try {
                    AgendaRuleDecider.Inputs in = new AgendaRuleDecider.Inputs();
                    in.fofoId = fofoId;
                    in.revival = store.getActivationType() == ActivationType.REVIVAL;
                    in.storeActivatedRecently = store.getActiveTimeStamp() != null
                            && store.getActiveTimeStamp().isAfter(activationCutoff);
                    in.minInvestment = store.getMinimumInvestment();

                    if (in.minInvestment > 0) {
                        try {
                            PartnerDailyInvestment inv = partnerInvestmentService.getInvestment(fofoId, 0);
                            in.shortPercentage = (double) inv.getShortPercentage();
                        } catch (Exception e) {
                            in.shortPercentage = null; // decider LEAVEs LOW_INVESTMENT
                            LOGGER.warn("Investment eval failed for fofoId={}: {}", fofoId, e.getMessage());
                        }
                    }

                    double[] sales = salesByFofo.get(fofoId);
                    in.baselineAmt = sales != null ? sales[0] : 0;
                    in.currentAmt = sales != null ? sales[1] : 0;
                    in.lastBillDaysAgo = billGapByFofo.get(fofoId);
                    double[] loan = loanByFofo.get(fofoId);
                    in.oldestLoanAgeDays = loan != null ? (int) loan[0] : null;
                    in.pendingLoanAmt = loan != null ? loan[1] : 0;

                    // Per-partner params, EXCEPT the sales time windows: those were
                    // baked into the batched SQL above, so the global values must
                    // win here even if a partner row overrides them.
                    Map<String, Double> salesParams = new HashMap<>(
                            agendaConfigService.getParams(AgendaType.LOW_SALES.name(), fofoId));
                    salesParams.put("windowDays", (double) windowDays);
                    salesParams.put("baselineDays", (double) baselineDays);

                    Map<AgendaType, AgendaRuleDecider.Decision> decisions = AgendaRuleDecider.decide(in,
                            agendaConfigService.getParams(AgendaType.LOW_INVESTMENT.name(), fofoId),
                            salesParams,
                            agendaConfigService.getParams(AgendaType.LOW_PURCHASE.name(), fofoId),
                            agendaConfigService.getParams(AgendaType.CREDIT_DUES.name(), fofoId));

                    int[] counts = agendaAutoRuleApplier.applyForStore(fofoId, decisions);
                    result.addOpened(counts[0]);
                    result.addClosed(counts[1]);
                } catch (Exception e) {
                    result.addError("fofoId " + fofoId + ": " + e.getMessage());
                    LOGGER.error("Agenda sync failed for fofoId={}", fofoId, e);
                }
            }
        } catch (Exception e) {
            result.addError("sync aborted: " + e.getMessage());
            LOGGER.error("Agenda sync aborted", e);
        }
        LOGGER.info("PJP agenda sync done: {}", result);
        return result;
    }

    // fofo_id -> [baselineAmt, currentAmt]
    private Map<Integer, double[]> gatherSales(int windowDays, int lookbackDays) {
        String sql = "SELECT fofo_id, " +
                " SUM(CASE WHEN create_timestamp <  DATE_SUB(NOW(), INTERVAL :windowDays DAY) THEN total_amount ELSE 0 END), " +
                " SUM(CASE WHEN create_timestamp >= DATE_SUB(NOW(), INTERVAL :windowDays DAY) THEN total_amount ELSE 0 END) " +
                "FROM fofo.fofo_order " +
                "WHERE cancelled_timestamp IS NULL " +
                "  AND create_timestamp >= DATE_SUB(NOW(), INTERVAL :lookbackDays DAY) " +
                "GROUP BY fofo_id";
        NativeQuery<?> q = sessionFactory.getCurrentSession().createNativeQuery(sql);
        q.setParameter("windowDays", windowDays);
        q.setParameter("lookbackDays", lookbackDays);
        Map<Integer, double[]> out = new HashMap<>();
        for (Object rowObj : q.getResultList()) {
            Object[] r = (Object[]) rowObj;
            out.put(asInt(r[0]), new double[]{asDouble(r[1]), asDouble(r[2])});
        }
        return out;
    }

    // fofo_id -> days since last billed purchase (absent = never billed)
    private Map<Integer, Integer> gatherPurchaseGaps() {
        String sql = "SELECT t.customer_id, DATEDIFF(NOW(), MAX(o.billing_timestamp)) " +
                "FROM transaction.`order` o " +
                "JOIN transaction.transaction t ON t.id = o.transaction_id " +
                "WHERE o.billing_timestamp IS NOT NULL " +
                "GROUP BY t.customer_id";
        NativeQuery<?> q = sessionFactory.getCurrentSession().createNativeQuery(sql);
        Map<Integer, Integer> out = new HashMap<>();
        for (Object rowObj : q.getResultList()) {
            Object[] r = (Object[]) rowObj;
            out.put(asInt(r[0]), asInt(r[1]));
        }
        return out;
    }

    // fofo_id -> [oldest open-loan age in days from created_on, total pending]
    private Map<Integer, double[]> gatherLoanAges() {
        String sql = "SELECT l.fofo_id, MAX(DATEDIFF(NOW(), l.created_on)), SUM(l.pending_amount) " +
                "FROM transaction.loan l " +
                "WHERE l.settled_on IS NULL AND l.pending_amount > 1 " +
                "GROUP BY l.fofo_id";
        NativeQuery<?> q = sessionFactory.getCurrentSession().createNativeQuery(sql);
        Map<Integer, double[]> out = new HashMap<>();
        for (Object rowObj : q.getResultList()) {
            Object[] r = (Object[]) rowObj;
            out.put(asInt(r[0]), new double[]{asDouble(r[1]), asDouble(r[2])});
        }
        return out;
    }

    private static int asInt(Object o) {
        return o == null ? 0 : ((Number) o).intValue();
    }

    private static double asDouble(Object o) {
        return o == null ? 0 : ((Number) o).doubleValue();
    }

    private static double doubleOr(Double v, double fallback) {
        return v != null ? v : fallback;
    }
}