Subversion Repositories SmartDukaan

package com.spice.profitmandi.service.user;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.ProfitMandiConstants;
import com.spice.profitmandi.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.cs.Position;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.entity.fofo.StoreRevival;
import com.spice.profitmandi.dao.entity.fofo.StoreStatusLog;
import com.spice.profitmandi.dao.entity.transaction.Loan;
import com.spice.profitmandi.dao.entity.transaction.UserWallet;
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
import com.spice.profitmandi.dao.enumuration.fofo.StoreRevivalType;
import com.spice.profitmandi.dao.enumuration.fofo.StoreStatus;
import com.spice.profitmandi.dao.enumuration.fofo.StoreStatusAction;
import com.spice.profitmandi.dao.enumuration.fofo.StoreStatusSource;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.dao.repository.cs.CsService;
import com.spice.profitmandi.dao.repository.cs.PositionRepository;
import com.spice.profitmandi.dao.repository.dtr.FofoStoreRepository;
import com.spice.profitmandi.dao.repository.fofo.StoreRevivalRepository;
import com.spice.profitmandi.dao.repository.fofo.StoreStatusLogRepository;
import com.spice.profitmandi.dao.repository.transaction.LoanRepository;
import com.spice.profitmandi.dao.repository.transaction.UserWalletHistoryRepository;
import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;
import com.spice.profitmandi.service.mail.MailOutboxService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * The only writer of a partner store's status (fofo_store.store_status, plus the legacy active / closed columns).
 * Every change checks the allowed transitions, who may make it and the mandatory reason, then writes a
 * fofo.store_status_log row. Pause, un-pause and suspend mail Tarun, Kamini and the partner's Sales L5 and above.
 */
@Service
public class StoreStatusService {

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

        static final String TARUN = "tarun.verma@smartdukaan.com";
        static final String KAMINI = "kamini.sharma@smartdukaan.com";
        static final String NEERAJ = "neeraj.gupta@smartdukaan.com";
        private static final List<String> NAMED = Collections.unmodifiableList(Arrays.asList(TARUN, KAMINI));

        public static final String ALLOWED_NAMED = "NAMED";
        public static final String ALLOWED_SALES_L5 = "SALES_L5+";
        public static final String ALLOWED_ACCOUNTS_L3 = "ACCOUNTS_L3+";
        public static final String ALLOWED_ACCOUNTS_L4 = "ACCOUNTS_L4+";
        public static final String ALLOWED_SYSTEM = "SYSTEM";
        public static final String ALLOWED_LOI = "LOI_APPROVAL";

        private static final int MAX_REASON = 1000;
        private static final int CLOSURE_REMINDER_DAYS = 7;
        private static final DateTimeFormatter TIME_FORMAT = DateTimeFormatter.ofPattern("dd-MMM-yyyy hh:mm a");
        private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("dd-MMM-yyyy");

        @Autowired
        private FofoStoreRepository fofoStoreRepository;

        @Autowired
        private StoreStatusLogRepository storeStatusLogRepository;

        @Autowired
        private StoreRevivalRepository storeRevivalRepository;

        @Autowired
        private AuthRepository authRepository;

        @Autowired
        private PositionRepository positionRepository;

        @Autowired
        private CsService csService;

        @Autowired
        private UserWalletRepository userWalletRepository;

        @Autowired
        private UserWalletHistoryRepository userWalletHistoryRepository;

        @Autowired
        private LoanRepository loanRepository;

        @Autowired
        private MailOutboxService mailOutboxService;

        // ── Status changes ────────────────────────────────────────────────────────────────────────────────────────

        /** ACTIVE → PAUSED (Tarun, Kamini, Sales L5+ for the partner) or SUSPENDED → PAUSED (activation rights). */
        public void pause(int fofoId, String reason, String changedBy, StoreStatusSource source) throws ProfitMandiBusinessException {
                FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
                String allowedAs = fofoStore.getStoreStatus() == StoreStatus.ACTIVE
                                ? allowedToPause(fofoId, changedBy) : allowedToChange(changedBy);
                changeStatus(fofoStore, StoreStatus.PAUSED, StoreStatusAction.PAUSE, reason, changedBy, allowedAs, source, null, null);
                sendStatusChangeMail(fofoStore, StoreStatusAction.PAUSE, reason, changedBy);
        }

        /** PAUSED → ACTIVE. */
        public void unpause(int fofoId, String reason, String changedBy, StoreStatusSource source) throws ProfitMandiBusinessException {
                FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
                requireStatus(fofoStore, StoreStatus.PAUSED, "un-pause");
                String allowedAs = allowedToChange(changedBy);
                changeStatus(fofoStore, StoreStatus.ACTIVE, StoreStatusAction.UNPAUSE, reason, changedBy, allowedAs, source, null, null);
                sendStatusChangeMail(fofoStore, StoreStatusAction.UNPAUSE, reason, changedBy);
        }

        /** ACTIVE or PAUSED → SUSPENDED (nearing closure, logged out). */
        public void suspend(int fofoId, String reason, String changedBy, StoreStatusSource source) throws ProfitMandiBusinessException {
                FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
                String allowedAs = allowedToChange(changedBy);
                changeStatus(fofoStore, StoreStatus.SUSPENDED, StoreStatusAction.SUSPEND, reason, changedBy, allowedAs, source, null, null);
                sendStatusChangeMail(fofoStore, StoreStatusAction.SUSPEND, reason, changedBy);
        }

        /** SUSPENDED → ACTIVE for good (a PAUSED store is un-paused instead). Ends any temporary activation. */
        public void activate(int fofoId, String changedBy, StoreStatusSource source) throws ProfitMandiBusinessException {
                FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
                String allowedAs = allowedToChange(changedBy);
                if (fofoStore.getStoreStatus() == StoreStatus.ACTIVE && fofoStore.getActiveTimeStamp() != null) {
                        // Temporarily active: make it permanent.
                        StoreStatus previous = fofoStore.getStoreStatus();
                        fofoStore.setActiveTimeStamp(null);
                        writeLog(fofoStore, previous, StoreStatusAction.ACTIVATE, null, changedBy, allowedAs, source, null, null);
                        return;
                }
                requireStatus(fofoStore, StoreStatus.SUSPENDED, "activate");
                changeStatus(fofoStore, StoreStatus.ACTIVE, StoreStatusAction.ACTIVATE, null, changedBy, allowedAs, source, null, null);
        }

        /**
         * PAUSED or SUSPENDED → ACTIVE until the start of today + {@code days}. The early-morning job then returns the
         * store to the status it had before.
         */
        public void activateTemporarily(int fofoId, int days, String changedBy, StoreStatusSource source) throws ProfitMandiBusinessException {
                if (days <= 0) {
                        throw new ProfitMandiBusinessException("Temporary Activation", "Invalid Days", "Please enter a number of days above zero");
                }
                FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
                StoreStatus current = fofoStore.getStoreStatus();
                if (current != StoreStatus.PAUSED && current != StoreStatus.SUSPENDED) {
                        throw new ProfitMandiBusinessException("Temporary Activation", "Not Allowed",
                                        "Only a paused or suspended store can be activated temporarily; this store is " + current);
                }
                String allowedAs = allowedToChange(changedBy);
                LocalDateTime activeUntil = LocalDate.now().atStartOfDay().plusDays(days);
                changeStatus(fofoStore, StoreStatus.ACTIVE, StoreStatusAction.TEMP_ACTIVATE, null, changedBy, allowedAs, source, activeUntil, null);
                fofoStore.setActiveTimeStamp(activeUntil);
        }

        /** Cron: every temporarily active store whose period has ended goes back to the status it had before. */
        public int expireTemporaryActivations() throws ProfitMandiBusinessException {
                LocalDateTime now = LocalDateTime.now();
                int expired = 0;
                for (FofoStore fofoStore : fofoStoreRepository.selectByStoreStatus(StoreStatus.ACTIVE)) {
                        if (fofoStore.getActiveTimeStamp() == null || fofoStore.getActiveTimeStamp().isAfter(now)) {
                                continue;
                        }
                        StoreStatusLog tempLog = storeStatusLogRepository.selectLatest(fofoStore.getId(), StoreStatusAction.TEMP_ACTIVATE);
                        StoreStatus previous = tempLog != null && tempLog.getFromStatus() != null ? tempLog.getFromStatus() : StoreStatus.SUSPENDED;
                        changeStatus(fofoStore, previous, StoreStatusAction.TEMP_EXPIRED, null, "checkPartnerActiveStore",
                                        ALLOWED_SYSTEM, StoreStatusSource.CRON, null, null);
                        expired++;
                }
                LOGGER.info("Temporary activations expired: {}", expired);
                return expired;
        }

        // ── Closure ───────────────────────────────────────────────────────────────────────────────────────────────

        /**
         * Conditions not met for closing this store, empty when it can be closed: SUSPENDED, wallet at ₹0 and no unsettled
         * loan (limit blocks included). Who is closing is checked separately by {@link #allowedToClose(String)}.
         */
        public List<String> closeBlockers(FofoStore fofoStore) throws ProfitMandiBusinessException {
                List<String> blockers = new ArrayList<>();
                if (fofoStore.getStoreStatus() != StoreStatus.SUSPENDED) {
                        blockers.add("Store must be suspended first (it is " + fofoStore.getStoreStatus() + ")");
                }
                long wallet = walletBalance(fofoStore.getId());
                if (wallet != 0) {
                        blockers.add("Wallet balance must be ₹0 (it is ₹" + wallet + ")");
                }
                List<Loan> loans = loanRepository.selectAllOpenLoanIncludingLimitBlock(fofoStore.getId());
                if (!loans.isEmpty()) {
                        blockers.add("All loans must be settled (" + loans.size() + " open, ₹" + pendingTotal(loans) + " pending)");
                }
                return blockers;
        }

        /** Throws unless the store can be closed by {@code closedBy}; returns the role that allows it. */
        public String assertCanClose(FofoStore fofoStore, String closedBy) throws ProfitMandiBusinessException {
                String allowedAs = allowedToClose(closedBy);
                if (fofoStore.isClosed()) {
                        throw new ProfitMandiBusinessException("Store Closed", "Store Already Closed", "This store is already permanently closed");
                }
                List<String> blockers = closeBlockers(fofoStore);
                if (!blockers.isEmpty()) {
                        throw new ProfitMandiBusinessException("Store Closure", "Closure Not Allowed", String.join("; ", blockers));
                }
                return allowedAs;
        }

        /** SUSPENDED → CLOSED. Called by StoreClosureService once the closure record exists. */
        void markClosed(FofoStore fofoStore, String remark, String closedBy, String allowedAs, StoreStatusSource source,
                                        int storeClosureId) throws ProfitMandiBusinessException {
                changeStatus(fofoStore, StoreStatus.CLOSED, StoreStatusAction.CLOSE, remark, closedBy, allowedAs, source, null, storeClosureId);
                fofoStore.setClosedTimestamp(LocalDateTime.now());
        }

        // ── Revival ───────────────────────────────────────────────────────────────────────────────────────────────

        /** Only SUSPENDED (same store) and CLOSED (new store) partners can be revived. */
        public void assertRevivable(FofoStore fofoStore) throws ProfitMandiBusinessException {
                StoreStatus status = fofoStore.getStoreStatus();
                if (status != StoreStatus.SUSPENDED && status != StoreStatus.CLOSED) {
                        throw new ProfitMandiBusinessException("Revival", "Not Allowed", "Store " + fofoStore.getCode() + " is " + status
                                        + ". Only suspended or closed stores can be revived; reactivate or un-pause it instead.");
                }
        }

        /** SUSPENDED → ACTIVE with the same code, once the revival payment is approved. */
        public void reviveSameStore(int fofoId, Integer loiId, String revivedBy) throws ProfitMandiBusinessException {
                FofoStore fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
                requireStatus(fofoStore, StoreStatus.SUSPENDED, "revive in place");
                changeStatus(fofoStore, StoreStatus.ACTIVE, StoreStatusAction.REVIVAL, null, revivedBy, ALLOWED_LOI,
                                StoreStatusSource.LOI_REVIVAL, null, null);
                persistRevival(fofoId, fofoId, StoreRevivalType.SAME_STORE, loiId, revivedBy);
        }

        /** A CLOSED partner was given a new store (new code); the old one stays CLOSED. Bookkeeping only. */
        public void recordNewStoreRevival(int oldFofoId, int newFofoId, Integer loiId, String revivedBy) throws ProfitMandiBusinessException {
                FofoStore oldStore = fofoStoreRepository.selectByRetailerId(oldFofoId);
                requireStatus(oldStore, StoreStatus.CLOSED, "revive as a new store");
                FofoStore newStore = fofoStoreRepository.selectByRetailerId(newFofoId);
                writeLog(newStore, null, StoreStatusAction.REVIVAL, "New store for closed " + oldStore.getCode(), revivedBy,
                                ALLOWED_LOI, StoreStatusSource.LOI_REVIVAL, null, null);
                persistRevival(oldFofoId, newFofoId, StoreRevivalType.NEW_STORE, loiId, revivedBy);
        }

        // ── Wallet ────────────────────────────────────────────────────────────────────────────────────────────────

        /** Call at partner-initiated spends only; system, admin and cron debits must not call this. */
        public void assertCanSpendWallet(int fofoId) throws ProfitMandiBusinessException {
                FofoStore fofoStore;
                try {
                        fofoStore = fofoStoreRepository.selectByRetailerId(fofoId);
                } catch (ProfitMandiBusinessException e) {
                        return; // a retailer without a partner store
                }
                StoreStatus status = fofoStore.getStoreStatus();
                if (!status.canSpendWallet()) {
                        throw new ProfitMandiBusinessException("Wallet", "Wallet Blocked", status == StoreStatus.PAUSED
                                        ? "Your store is paused, so wallet payments are not allowed. Please contact your sales manager."
                                        : "Your store is " + status.name().toLowerCase() + ", so wallet payments are not allowed.");
                }
        }

        // ── History and permissions for the UI ────────────────────────────────────────────────────────────────────

        public List<StoreStatusLog> history(int fofoId) {
                return storeStatusLogRepository.selectByFofoId(fofoId);
        }

        /** Actions {@code emailId} may take on this store right now (FSM and permission; closure conditions excluded). */
        public Set<StoreStatusAction> allowedActions(FofoStore fofoStore, String emailId) {
                Set<StoreStatusAction> actions = EnumSet.noneOf(StoreStatusAction.class);
                StoreStatus status = fofoStore.getStoreStatus();
                boolean change = isAllowed(() -> allowedToChange(emailId));
                if (status == StoreStatus.ACTIVE && isAllowed(() -> allowedToPause(fofoStore.getId(), emailId))
                                || status == StoreStatus.SUSPENDED && change) {
                        actions.add(StoreStatusAction.PAUSE);
                }
                if (change) {
                        if (status == StoreStatus.PAUSED) {
                                actions.add(StoreStatusAction.UNPAUSE);
                        }
                        if (status == StoreStatus.ACTIVE || status == StoreStatus.PAUSED) {
                                actions.add(StoreStatusAction.SUSPEND);
                        }
                        if (status == StoreStatus.SUSPENDED || status == StoreStatus.ACTIVE && fofoStore.getActiveTimeStamp() != null) {
                                actions.add(StoreStatusAction.ACTIVATE);
                        }
                        if (status == StoreStatus.PAUSED || status == StoreStatus.SUSPENDED) {
                                actions.add(StoreStatusAction.TEMP_ACTIVATE);
                        }
                }
                if (status == StoreStatus.SUSPENDED && isAllowed(() -> allowedToClose(emailId))) {
                        actions.add(StoreStatusAction.CLOSE);
                }
                return actions;
        }

        /**
         * Which buttons a store list may show to {@code emailId}: keys pause, change and close. Pause is only a hint here
         * (Sales L5+ anywhere); each action re-checks the partner coverage itself.
         */
        public Map<String, Boolean> listPermissions(String emailId) throws ProfitMandiBusinessException {
                String email = normalise(emailId);
                Map<String, Boolean> permissions = new HashMap<>();
                permissions.put("pause", NAMED.contains(email)
                                || holdsLevel(email, ProfitMandiConstants.TICKET_CATEGORY_SALES, EscalationType.L5));
                permissions.put("change", isAllowed(() -> allowedToChange(email)));
                permissions.put("close", isAllowed(() -> allowedToClose(email)));
                return permissions;
        }

        /** Pause: Tarun, Kamini, or Sales L5 and above who cover this partner. */
        public String allowedToPause(int fofoId, String emailId) throws ProfitMandiBusinessException {
                String email = normalise(emailId);
                if (NAMED.contains(email)) {
                        return ALLOWED_NAMED;
                }
                boolean coversPartner = csService.getAuthUsersByPartnerIdAndCategory(fofoId, ProfitMandiConstants.TICKET_CATEGORY_SALES,
                                levelsFrom(EscalationType.L5)).stream().map(AuthUser::getEmailId).filter(Objects::nonNull)
                                .anyMatch(x -> x.equalsIgnoreCase(email));
                if (coversPartner) {
                        return ALLOWED_SALES_L5;
                }
                throw denied("pause this store");
        }

        /** Suspend, activate, un-pause, temporary activate: Tarun, Kamini, Neeraj, or Accounts L4 and above. */
        public String allowedToChange(String emailId) throws ProfitMandiBusinessException {
                String email = normalise(emailId);
                if (NAMED.contains(email) || NEERAJ.equals(email)) {
                        return ALLOWED_NAMED;
                }
                if (holdsAccountsLevel(email, EscalationType.L4)) {
                        return ALLOWED_ACCOUNTS_L4;
                }
                throw denied("change this store's status");
        }

        /** Close: Tarun, Kamini, or Accounts L3 and above. */
        public String allowedToClose(String emailId) throws ProfitMandiBusinessException {
                String email = normalise(emailId);
                if (NAMED.contains(email)) {
                        return ALLOWED_NAMED;
                }
                if (holdsAccountsLevel(email, EscalationType.L3)) {
                        return ALLOWED_ACCOUNTS_L3;
                }
                throw denied("close store");
        }

        // ── Weekly closure reminder ───────────────────────────────────────────────────────────────────────────────

        /**
         * Monday digest of stores SUSPENDED for more than 7 days, To Neeraj with the other closers in CC. Stores whose
         * only entry is the migration baseline were already inactive before the log existed, so they are always listed.
         */
        public int sendClosureReminder() throws ProfitMandiBusinessException {
                List<FofoStore> suspended = fofoStoreRepository.selectByStoreStatus(StoreStatus.SUSPENDED);
                Map<Integer, StoreStatusLog> entries = storeStatusLogRepository.selectLatestEntries(
                                suspended.stream().map(FofoStore::getId).collect(Collectors.toList()), StoreStatus.SUSPENDED);
                LocalDateTime cutoff = LocalDateTime.now().minusDays(CLOSURE_REMINDER_DAYS);

                StringBuilder rows = new StringBuilder();
                int listed = 0;
                int closable = 0;
                for (FofoStore fofoStore : suspended) {
                        StoreStatusLog entry = entries.get(fofoStore.getId());
                        boolean baseline = entry == null || entry.getAction() == StoreStatusAction.BASELINE;
                        if (!baseline && entry.getCreateTimestamp().isAfter(cutoff)) {
                                continue;
                        }
                        long wallet = walletBalance(fofoStore.getId());
                        List<Loan> loans = loanRepository.selectAllOpenLoanIncludingLimitBlock(fofoStore.getId());
                        boolean canClose = wallet == 0 && loans.isEmpty();
                        String since = baseline
                                        ? "before " + (entry == null ? "-" : entry.getCreateTimestamp().format(DATE_FORMAT))
                                        : entry.getCreateTimestamp().format(DATE_FORMAT) + " ("
                                        + ChronoUnit.DAYS.between(entry.getCreateTimestamp().toLocalDate(), LocalDate.now()) + " days)";
                        rows.append("<tr><td>").append(fofoStore.getCode()).append("</td><td>")
                                        .append(escape(Optional.ofNullable(fofoStore.getOutletName()).orElse("-"))).append("</td><td>")
                                        .append(since).append("</td><td align=\"right\">").append(wallet).append("</td><td align=\"right\">")
                                        .append(loans.isEmpty() ? "-" : loans.size() + " / ₹" + pendingTotal(loans)).append("</td><td>")
                                        .append(canClose ? "<b>Yes</b>" : "No").append("</td></tr>");
                        listed++;
                        if (canClose) {
                                closable++;
                        }
                }
                if (listed == 0) {
                        LOGGER.info("Closure reminder: no store suspended for more than {} days", CLOSURE_REMINDER_DAYS);
                        return 0;
                }
                Set<String> cc = new LinkedHashSet<>(NAMED);
                cc.addAll(accountsEmailsFrom(EscalationType.L3));
                cc.remove(NEERAJ);
                String subject = "Suspended stores pending closure - " + listed + " stores, " + closable + " closable now";
                String body = "<p>Dear Neeraj,</p><p>These stores have been suspended for more than " + CLOSURE_REMINDER_DAYS
                                + " days. A store can be closed once its wallet is at ₹0 and every loan, including limit blocks, is settled.</p>"
                                + "<table border=\"1\" cellpadding=\"4\" cellspacing=\"0\" style=\"border-collapse:collapse\">"
                                + "<tr><th>Store</th><th>Name</th><th>Suspended since</th><th>Wallet ₹</th><th>Open loans</th><th>Closable now</th></tr>"
                                + rows + "</table><p>Regards,<br>SmartDukaan</p>";
                mailOutboxService.queueMail(new String[]{NEERAJ}, cc.toArray(new String[0]), null, subject, body, true,
                                "StoreStatusService.sendClosureReminder");
                LOGGER.info("Closure reminder queued: {} stores, {} closable", listed, closable);
                return listed;
        }

        // ── Internals ─────────────────────────────────────────────────────────────────────────────────────────────

        private void changeStatus(FofoStore fofoStore, StoreStatus target, StoreStatusAction action, String reason,
                                                          String changedBy, String allowedAs, StoreStatusSource source, LocalDateTime activeUntil,
                                                          Integer storeClosureId) throws ProfitMandiBusinessException {
                StoreStatus from = fofoStore.getStoreStatus();
                if (!from.canMoveTo(target)) {
                        throw new ProfitMandiBusinessException("Store Status", "Not Allowed",
                                        "Store " + fofoStore.getCode() + " cannot move from " + from + " to " + target);
                }
                String cleanReason = reason == null ? null : reason.trim();
                if (action.needsReason() && (cleanReason == null || cleanReason.isEmpty())) {
                        throw new ProfitMandiBusinessException("Store Status", "Reason Missing",
                                        "Please give a reason to " + action.getLabel().toLowerCase() + " this store");
                }
                if (cleanReason != null && cleanReason.length() > MAX_REASON) {
                        throw new ProfitMandiBusinessException("Store Status", "Reason Too Long",
                                        "Please keep the reason within " + MAX_REASON + " characters");
                }
                fofoStore.setStoreStatus(target);
                if (action != StoreStatusAction.TEMP_ACTIVATE) {
                        fofoStore.setActiveTimeStamp(null);
                }
                writeLog(fofoStore, from, action, cleanReason, changedBy, allowedAs, source, activeUntil, storeClosureId);
                LOGGER.info("Store {} {} -> {} ({}) by {} as {}", fofoStore.getCode(), from, target, action, changedBy, allowedAs);
        }

        private void writeLog(FofoStore fofoStore, StoreStatus from, StoreStatusAction action, String reason, String changedBy,
                                                  String allowedAs, StoreStatusSource source, LocalDateTime activeUntil, Integer storeClosureId) {
                StoreStatusLog log = new StoreStatusLog();
                log.setFofoId(fofoStore.getId());
                log.setFromStatus(from);
                log.setToStatus(fofoStore.getStoreStatus());
                log.setAction(action);
                log.setReason(reason);
                log.setSource(source);
                log.setChangedBy(changedBy);
                log.setAllowedAs(allowedAs);
                log.setActiveUntil(activeUntil);
                log.setStoreClosureId(storeClosureId);
                log.setCreateTimestamp(LocalDateTime.now());
                storeStatusLogRepository.persist(log);
        }

        private void persistRevival(int oldFofoId, int newFofoId, StoreRevivalType type, Integer loiId, String revivedBy) {
                StoreRevival revival = new StoreRevival();
                revival.setOldFofoId(oldFofoId);
                revival.setNewFofoId(newFofoId);
                revival.setRevivalType(type);
                revival.setLoiId(loiId);
                revival.setRevivedBy(revivedBy);
                revival.setCreateTimestamp(LocalDateTime.now());
                storeRevivalRepository.persist(revival);
                LOGGER.info("Store revival recorded: {}", revival);
        }

        private void sendStatusChangeMail(FofoStore fofoStore, StoreStatusAction action, String reason, String changedBy)
                        throws ProfitMandiBusinessException {
                Set<String> to = new LinkedHashSet<>(NAMED);
                csService.getAuthUsersByPartnerIdAndCategory(fofoStore.getId(), ProfitMandiConstants.TICKET_CATEGORY_SALES,
                                levelsFrom(EscalationType.L5)).stream().map(AuthUser::getEmailId).filter(Objects::nonNull)
                                .map(String::toLowerCase).forEach(to::add);
                StoreStatusLog log = storeStatusLogRepository.selectLatest(fofoStore.getId(), action);
                List<Loan> loans = loanRepository.selectAllOpenLoanIncludingLimitBlock(fofoStore.getId());
                String name = Optional.ofNullable(fofoStore.getOutletName()).orElse("-");

                String subject = "Store " + action.getLabel() + " - " + fofoStore.getCode() + " - " + name;
                StringBuilder body = new StringBuilder();
                body.append("Dear Team,\n\nA partner store's status has changed.\n\n");
                body.append("Partner       : ").append(name).append(" (Partner Id ").append(fofoStore.getId()).append(")\n");
                body.append("Store Code    : ").append(fofoStore.getCode()).append("\n");
                body.append("Status        : ").append(log == null ? "-" : log.getFromStatus()).append(" -> ")
                                .append(fofoStore.getStoreStatus()).append("\n");
                body.append("Reason        : ").append(reason.trim()).append("\n");
                body.append("Changed By    : ").append(changedBy).append("\n");
                body.append("Changed On    : ").append(LocalDateTime.now().format(TIME_FORMAT)).append("\n");
                body.append("Wallet        : ₹").append(walletBalance(fofoStore.getId())).append("\n");
                body.append("Open Loans    : ").append(loans.isEmpty() ? "None" : loans.size() + " (₹" + pendingTotal(loans) + " pending)")
                                .append("\n\nRegards,\nSmartDukaan");
                mailOutboxService.queueMail(to.toArray(new String[0]), null, subject, body.toString(),
                                "StoreStatusService.sendStatusChangeMail");
        }

        private void requireStatus(FofoStore fofoStore, StoreStatus required, String verb) throws ProfitMandiBusinessException {
                if (fofoStore.getStoreStatus() != required) {
                        throw new ProfitMandiBusinessException("Store Status", "Not Allowed", "Cannot " + verb + " store "
                                        + fofoStore.getCode() + ": it is " + fofoStore.getStoreStatus() + ", not " + required);
                }
        }

        /** Rounded to the rupee; read without creating a wallet row. */
        private long walletBalance(int fofoId) throws ProfitMandiBusinessException {
                UserWallet wallet = userWalletRepository.selectByRetailerId(fofoId);
                return wallet == null ? 0 : Math.round(userWalletHistoryRepository.selectSumByWallet(wallet.getId()));
        }

        private static long pendingTotal(List<Loan> loans) {
                return loans.stream().map(Loan::getPendingAmount).filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add)
                                .setScale(0, BigDecimal.ROUND_HALF_UP).longValue();
        }

        private boolean holdsAccountsLevel(String email, EscalationType minimum) throws ProfitMandiBusinessException {
                return holdsLevel(email, ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS, minimum);
        }

        private boolean holdsLevel(String email, int categoryId, EscalationType minimum) throws ProfitMandiBusinessException {
                AuthUser authUser;
                try {
                        authUser = authRepository.selectByEmailOrMobile(email);
                } catch (ProfitMandiBusinessException e) {
                        return false;
                }
                if (!Boolean.TRUE.equals(authUser.getActive())) {
                        return false;
                }
                return positionRepository.selectPositionByAuthId(authUser.getId()).stream()
                                .anyMatch(x -> x.getCategoryId() == categoryId
                                                && x.getEscalationType() != null && x.getEscalationType().compareTo(minimum) >= 0);
        }

        private Set<String> accountsEmailsFrom(EscalationType minimum) {
                List<Integer> authIds = positionRepository.selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_ACCOUNTS)
                                .stream().filter(x -> x.getAuthUserId() > 0 && x.getEscalationType() != null
                                                && x.getEscalationType().compareTo(minimum) >= 0)
                                .map(Position::getAuthUserId).distinct().collect(Collectors.toList());
                if (authIds.isEmpty()) {
                        return new LinkedHashSet<>();
                }
                return authRepository.selectByIds(authIds).stream().filter(x -> Boolean.TRUE.equals(x.getActive()))
                                .map(AuthUser::getEmailId).filter(Objects::nonNull).map(String::toLowerCase)
                                .collect(Collectors.toCollection(LinkedHashSet::new));
        }

        private static EscalationType[] levelsFrom(EscalationType minimum) {
                return Arrays.stream(EscalationType.values()).filter(x -> x.compareTo(minimum) >= 0).toArray(EscalationType[]::new);
        }

        private static String normalise(String emailId) {
                return emailId == null ? "" : emailId.trim().toLowerCase();
        }

        private static ProfitMandiBusinessException denied(String action) {
                return new ProfitMandiBusinessException("Access Denied", "Unauthorised Access", "You are not authorise to " + action);
        }

        private static String escape(String text) {
                return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
        }

        private interface PermissionCheck {
                String check() throws ProfitMandiBusinessException;
        }

        private static boolean isAllowed(PermissionCheck check) {
                try {
                        check.check();
                        return true;
                } catch (ProfitMandiBusinessException e) {
                        return false;
                }
        }
}