Subversion Repositories SmartDukaan

    // Matches "No Answer", "NO_ANSWER", "no-answer", "noanswer", etc.

    private static boolean isNoAnswerStatus(String status) {

        if (status == null) return false;

        String s = status.trim().toLowerCase().replace('_', ' ').replace('-', ' ').replaceAll("\\s+", " ");

        return s.equals("no answer") || s.equals("noanswer");

    }

    @Override

    public List<OutOfSequenceDetailModel> getOutOfSequenceDetails(int authId) {

        LocalDate today = LocalDate.now();

        LocalDateTime start = today.atStartOfDay();

        LocalDateTime end = today.plusDays(1).atStartOfDay();

        List<RbmCallSequenceLog> logs =

                rbmCallSequenceLogRepository.selectByAuthIdAndDateRange(authId, start, end);

        Map<Integer, RbmCallSequenceLog> uniqueOosLogsByFofoId = new LinkedHashMap<>();

        for (RbmCallSequenceLog log : logs) {

            if (log.isOutOfSequence()) {

                // Keep only the first occurrence per fofoId (latest entry since ordered by id DESC)

                uniqueOosLogsByFofoId.putIfAbsent(log.getFofoId(), log);

            }

        }

        if (uniqueOosLogsByFofoId.isEmpty()) {

            return Collections.emptyList();

        }

        Set<Integer> fofoIds = uniqueOosLogsByFofoId.keySet();

        Map<Integer, CustomRetailer> retailerMap = Collections.emptyMap();

        try {

            retailerMap = retailerService.getFofoRetailers(new ArrayList<>(fofoIds));

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Error fetching fofo stores", e);

        }

        DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("hh:mm a");

        List<OutOfSequenceDetailModel> result = new ArrayList<>();

        for (RbmCallSequenceLog log : uniqueOosLogsByFofoId.values()) {

            CustomRetailer retailer = retailerMap.get(log.getFofoId());

            String partyName = retailer != null

                    ? retailer.getBusinessName()

                    : "Unknown (" + log.getFofoId() + ")";

            String code = retailer != null

                    ? retailer.getCode()

                    : "-";

            String time = log.getCreateTimestamp() != null

                    ? log.getCreateTimestamp().format(timeFormatter)

                    : "-";

            result.add(new OutOfSequenceDetailModel(partyName, code, time));

        }

        return result;

    }

    @Override

    public List<CalledPartnerDetailModel> getCalledPartnerDetails(int authId) throws ProfitMandiBusinessException {

        return getCalledPartnerDetails(authId, LocalDate.now());

    }

    @Override

    public List<CalledPartnerDetailModel> getCalledPartnerDetails(int authId, LocalDate date) throws ProfitMandiBusinessException {

        // Get all call logs for this auth user on this date

        LOGGER.info("getCalledPartnerDetails: authId={}, date={}", authId, date);

        List<AgentCallLog> callLogs = agentCallLogRepository.findByAuthIdAndDate(authId, date);

        LOGGER.info("Found {} call logs for authId={} on date={}", callLogs.size(), authId, date);

        if (callLogs.isEmpty()) {

            return Collections.emptyList();

        }

        // Build a map of normalized customer number -> fofoId

        Map<String, Integer> customerToFofoIdMap = new HashMap<>();

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

        for (AgentCallLog callLog : callLogs) {

            String customerNumber = callLog.getCustomerNumber();

            if (customerNumber != null) {

                String normalized = customerNumber.startsWith("+91") ? customerNumber.substring(3) : customerNumber;

                normalizedNumbers.add(normalized);

            }

        }

        // For each normalized number, find fofoId from retailer_contact first, then address

        for (String mobile : normalizedNumbers) {

            Integer fofoId = findFofoIdByMobile(mobile);

            if (fofoId != null) {

                customerToFofoIdMap.put(mobile, fofoId);

            }

        }

        // Get unique fofoIds for retailer lookup

        Set<Integer> fofoIds = new HashSet<>(customerToFofoIdMap.values());

        Map<Integer, CustomRetailer> retailerMap = Collections.emptyMap();

        if (!fofoIds.isEmpty()) {

            try {

                retailerMap = retailerService.getFofoRetailers(new ArrayList<>(fofoIds));

            } catch (ProfitMandiBusinessException e) {

                LOGGER.error("Error fetching fofo stores", e);

            }

        }

        // Get today's remarks for these fofoIds

        Map<Integer, List<PartnerCollectionRemark>> fofoRemarkMap = new HashMap<>();

        if (!fofoIds.isEmpty()) {

            List<PartnerCollectionRemark> todayRemarks = partnerCollectionRemarkRepository

                    .selectAllByFofoIdsOnDate(new ArrayList<>(fofoIds), date);

            for (PartnerCollectionRemark remark : todayRemarks) {

                fofoRemarkMap.computeIfAbsent(remark.getFofoId(), k -> new ArrayList<>()).add(remark);

            }

        }

        DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("hh:mm a");

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd-MM-yyyy hh:mm a");

        List<CalledPartnerDetailModel> result = new ArrayList<>();

        for (com.spice.profitmandi.dao.entity.cs.AgentCallLog callLog : callLogs) {

            String customerNumber = callLog.getCustomerNumber();

            if (customerNumber == null) {

                continue;

            }

            String normalized = customerNumber.startsWith("+91") ? customerNumber.substring(3) : customerNumber;

            Integer fofoId = customerToFofoIdMap.get(normalized);

            String partyName = "Unknown";

            String code = "-";

            if (fofoId != null) {

                CustomRetailer retailer = retailerMap.get(fofoId);

                if (retailer != null) {

                    partyName = retailer.getBusinessName();

                    code = retailer.getCode();

                } else {

                    partyName = "Unknown (" + fofoId + ")";

                }

            } else {

                partyName = "Unknown (" + normalized + ")";

            }

            // Get remark if available

            String remarkValue = "-";

            String messageValue = "-";

            String remarkTime = "-";

            if (fofoId != null && fofoRemarkMap.containsKey(fofoId)) {

                List<PartnerCollectionRemark> remarks = fofoRemarkMap.get(fofoId);

                if (!remarks.isEmpty()) {

                    PartnerCollectionRemark remark = remarks.get(0);

                    remarkValue = remark.getRemark() != null ? remark.getRemark().getValue() : "-";

                    messageValue = remark.getMessage() != null ? remark.getMessage() : "-";

                    remarkTime = remark.getCreateTimestamp() != null ? remark.getCreateTimestamp().format(timeFormatter) : "-";

                }

            }

            // Build call log data

            String recordingUrl = callLog.getRecordingUrl();

            String callStatus = callLog.getCallStatus();

            String callDuration = callLog.getCallDuration();

            String callDateTime = null;

            if (callLog.getCallDate() != null && callLog.getCallTime() != null) {

                LocalDateTime callDateTimeObj = LocalDateTime.of(callLog.getCallDate(), callLog.getCallTime());

                callDateTime = callDateTimeObj.format(dateTimeFormatter);

            }

            result.add(new CalledPartnerDetailModel(partyName, code, remarkValue, messageValue, remarkTime,

                    recordingUrl, callStatus, callDuration, callDateTime));

        }

        return result;

    }

    private Integer findFofoIdByMobile(String mobile) {

        // First check retailer_contact

        List<RetailerContact> contacts = retailerContactRepository.selectByMobile(mobile);

        if (contacts != null && !contacts.isEmpty()) {

            return contacts.get(0).getFofoId();

        }

        // Fallback to user.address

        List<Address> addresses = addressRepository.selectAllByPhoneNumber(mobile);

        if (addresses != null && !addresses.isEmpty()) {

            return addresses.get(0).getRetaierId();

        }

        return null;

    }

    private List<CalledPartnerDetailModel> buildCalledPartnerResult(List<PartnerCollectionRemark> allRemarks) {

        if (allRemarks.isEmpty()) {

            return Collections.emptyList();

        }

        // Get unique fofoIds for retailer lookup

        Set<Integer> fofoIds = allRemarks.stream()

                .map(PartnerCollectionRemark::getFofoId)

                .collect(Collectors.toSet());

        Map<Integer, CustomRetailer> retailerMap = Collections.emptyMap();

        try {

            retailerMap = retailerService.getFofoRetailers(new ArrayList<>(fofoIds));

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Error fetching fofo stores", e);

        }

        // Fetch call logs for remarks that have agentCallLogId

        Map<Long, com.spice.profitmandi.dao.entity.cs.AgentCallLog> callLogMap = new HashMap<>();

        try {

            List<Long> callLogIds = allRemarks.stream()

                    .filter(r -> r.getAgentCallLogId() > 0)

                    .map(PartnerCollectionRemark::getAgentCallLogId)

                    .collect(Collectors.toList());

            if (!callLogIds.isEmpty()) {

                List<com.spice.profitmandi.dao.entity.cs.AgentCallLog> callLogs = agentCallLogRepository.findByIds(callLogIds);

                if (callLogs != null) {

                    callLogMap = callLogs.stream()

                            .collect(Collectors.toMap(com.spice.profitmandi.dao.entity.cs.AgentCallLog::getId, c -> c, (a, b) -> a));

                }

            }

        } catch (Exception e) {

            LOGGER.error("Error fetching call logs by ids", e);

        }

        DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("hh:mm a");

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("dd-MM-yyyy hh:mm a");

        List<CalledPartnerDetailModel> result = new ArrayList<>();

        for (PartnerCollectionRemark remark : allRemarks) {

            CustomRetailer retailer = retailerMap.get(remark.getFofoId());

            String partyName = retailer != null

                    ? retailer.getBusinessName()

                    : "Unknown (" + remark.getFofoId() + ")";

            String code = retailer != null

                    ? retailer.getCode()

                    : "-";

            String remarkValue = remark.getRemark() != null

                    ? remark.getRemark().getValue()

                    : "-";

            String messageValue = remark.getMessage() != null

                    ? remark.getMessage()

                    : "-";

            String time = remark.getCreateTimestamp() != null

                    ? remark.getCreateTimestamp().format(timeFormatter)

                    : "-";

            // Get call log data if available

            String recordingUrl = null;

            String callStatus = null;

            String callDuration = null;

            String callDateTime = null;

            try {

                if (remark.getAgentCallLogId() > 0 && callLogMap.containsKey(remark.getAgentCallLogId())) {

                    com.spice.profitmandi.dao.entity.cs.AgentCallLog callLog = callLogMap.get(remark.getAgentCallLogId());

                    recordingUrl = callLog.getRecordingUrl();

                    callStatus = callLog.getCallStatus();

                    callDuration = callLog.getCallDuration();

                    if (callLog.getCallDate() != null && callLog.getCallTime() != null) {

                        LocalDateTime callDateTimeObj = LocalDateTime.of(callLog.getCallDate(), callLog.getCallTime());

                        callDateTime = callDateTimeObj.format(dateTimeFormatter);

                    }

                }

            } catch (Exception e) {

                LOGGER.error("Error processing call log for remark id: {}", remark.getId(), e);

            }

            result.add(new CalledPartnerDetailModel(partyName, code, remarkValue, messageValue, time,

                    recordingUrl, callStatus, callDuration, callDateTime));

        }

        return result;

    }

    @Override

    public List<List<String>> getRbmCallTargetRawDataByAuthId(int authId) throws Exception {

        List<List<String>> rows = new ArrayList<>();

        // Get auth user

        List<AuthUser> authUsers = authRepository.selectByIds(Collections.singletonList(authId));

        if (authUsers.isEmpty()) {

            return rows;

        }

        AuthUser authUser = authUsers.get(0);

        // Get positions to determine if L2

        List<Position> positions = positionRepository.selectPositionByAuthIds(Collections.singletonList(authId));

        boolean isL2 = positions.stream()

                .anyMatch(p -> ProfitMandiConstants.TICKET_CATEGORY_RBM == p.getCategoryId()

                        && EscalationType.L2.equals(p.getEscalationType()));

        LocalDateTime startDate = LocalDate.now().atStartOfDay();

        LocalDate firstOfMonth = LocalDate.now().withDayOfMonth(1);

        LocalDate endOfMonth = LocalDate.now().withDayOfMonth(LocalDate.now().lengthOfMonth()).plusDays(1);

        // Get fofo IDs from mtdBillingData (same source as Partner Count in getRbmCallTargetModels)

        List<RbmWeeklyBillingModel> mtdBillingData = getWeeklyBillingDataForMonth(firstOfMonth, endOfMonth);

        List<Integer> fofoIdList;

        if (isL2) {

            // L2: get fofo IDs from escalated tickets (same as getRbmCallTargetModels)

            List<Ticket> escalatedTickets = ticketRepository.selectOpenEscalatedTicketsByAuthIds(Collections.singletonList(authId));

            fofoIdList = escalatedTickets.stream()

                    .filter(t -> t.getL2AuthUser() == authId

                            || t.getL3AuthUser() == authId

                            || t.getL4AuthUser() == authId

                            || t.getL5AuthUser() == authId)

                    .map(Ticket::getFofoId)

                    .distinct()

                    .collect(Collectors.toList());

        } else {

            // L1: get fofo IDs from mtdBillingData with isTargetedPartner (same as Partner Count)

            fofoIdList = mtdBillingData.stream()

                    .filter(RbmWeeklyBillingModel::isTargetedPartner)

                    .filter(m -> m.getAuthId() == authId)

                    .map(RbmWeeklyBillingModel::getFofoId)

                    .distinct()

                    .collect(Collectors.toList());

        }

        if (fofoIdList.isEmpty()) {

            return rows;

        }

        // MTD billed fofoIds for zero billing check

        Set<Integer> mtdBilledFofoIds = mtdBillingData.stream()

                .filter(RbmWeeklyBillingModel::isMtdBilled)

                .map(RbmWeeklyBillingModel::getFofoId)

                .collect(Collectors.toSet());

        // Collection rank map for status calculation

        Map<Integer, Integer> collectionRankMap = new HashMap<>();

        try {

            collectionRankMap = partnerCollectionService.getCollectionRankMap(fofoIdList, startDate);

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Error fetching collection rank map", e);

        }

        // Resolve partner names/codes

        Map<Integer, CustomRetailer> retailerMap = Collections.emptyMap();

        if (!fofoIdList.isEmpty()) {

            try {

                retailerMap = retailerService.getFofoRetailers(fofoIdList);

            } catch (ProfitMandiBusinessException e) {

                LOGGER.error("Error fetching fofo retailers for raw data", e);

            }

        }

        String rbmName = authUser.getFullName() + (isL2 ? " (L2)" : "");

        // Build rows for ALL partners (same count as Partner Count)

        for (Integer fofoId : fofoIdList) {

            // Default to rank 5 (Normal) for partners without collection plan

            int rank = collectionRankMap.getOrDefault(fofoId, 5);

            boolean hasZeroBilling = !mtdBilledFofoIds.contains(fofoId);

            // Status assignment with same priority as getRbmCallTargetModels

            String status;

            if (rank == 1) {

                status = "Plan Today";

            } else if (rank == 2) {

                status = "Carry Forward";

            } else if (hasZeroBilling) {

                status = "Zero Billing";

            } else if (rank == 3) {

                status = "Untouched";

            } else if (rank == 4) {

                status = "Future Plan";

            } else {

                status = "Normal";

            }

            CustomRetailer retailer = retailerMap.get(fofoId);

            String partnerName = retailer != null ? retailer.getBusinessName() : "Unknown (" + fofoId + ")";

            String partnerCode = retailer != null ? retailer.getCode() : "-";

            rows.add(Arrays.asList(partnerName, partnerCode, status, rbmName));

        }

        return rows;

    }

    @Override

    public List<List<String>> getAllRbmCallTargetRawData() throws Exception {

        List<List<String>> rows = new ArrayList<>();

        // Get all L1 RBM positions (rows are emitted per L1 RBM).

        // Call-log lookup happens against ALL callers via findAllByDate — so an L2/L3 or admin call

        // still counts as "tried" for the partner.

        List<Position> allRbmPositions = positionRepository

                .selectPositionByCategoryId(ProfitMandiConstants.TICKET_CATEGORY_RBM).stream()

                .filter(x -> EscalationType.L1.equals(x.getEscalationType()))

                .collect(Collectors.toList());

        List<Integer> l1AuthIds = allRbmPositions.stream()

                .map(Position::getAuthUserId).distinct().collect(Collectors.toList());

        if (l1AuthIds.isEmpty()) {

            return rows;

        }

        // Get auth user map

        Map<Integer, AuthUser> authUserMap = authRepository.selectByIds(l1AuthIds).stream()

                .collect(Collectors.toMap(AuthUser::getId, au -> au));

        // Positions per auth user (needed early to build L1 partner assignments below)

        Map<Integer, List<Position>> positionsByAuthId = positionRepository.selectPositionByAuthIds(l1AuthIds).stream()

                .collect(Collectors.groupingBy(Position::getAuthUserId));

        // Build L1 partner assignments from partner_position — SAME source the UI summary uses for

        // Calling Target. storeGuyMap (email-based CS mapping) was returning smaller/different lists

        // for users who are also L2, causing summary=43 but download=3 for Ebadullah.

        Map<Integer, Integer> l1PositionIdToAuthId = new HashMap<>();

        for (int rbmAuthId : l1AuthIds) {

            List<Position> positions = positionsByAuthId.getOrDefault(rbmAuthId, Collections.emptyList());

            for (Position p : positions) {

                if (ProfitMandiConstants.TICKET_CATEGORY_RBM == p.getCategoryId()

                        && EscalationType.L1.equals(p.getEscalationType())) {

                    l1PositionIdToAuthId.put(p.getId(), rbmAuthId);

                }

            }

        }

        Map<Integer, List<Integer>> rbmToFofoIdsMap = new HashMap<>();

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

        if (!l1PositionIdToAuthId.isEmpty()) {

            List<com.spice.profitmandi.dao.entity.cs.PartnerPosition> allL1PPs =

                    partnerPositionRepository.selectByPositionIds(new ArrayList<>(l1PositionIdToAuthId.keySet()));

            // Group by owning RBM; keep partners distinct within each RBM.

            Map<Integer, Set<Integer>> perRbmSets = new HashMap<>();

            for (com.spice.profitmandi.dao.entity.cs.PartnerPosition pp : allL1PPs) {

                Integer ownerAuthId = l1PositionIdToAuthId.get(pp.getPositionId());

                if (ownerAuthId == null) continue;

                perRbmSets.computeIfAbsent(ownerAuthId, k -> new HashSet<>()).add(pp.getFofoId());

                allFofoIds.add(pp.getFofoId());

            }

            for (Map.Entry<Integer, Set<Integer>> e : perRbmSets.entrySet()) {

                rbmToFofoIdsMap.put(e.getKey(), new ArrayList<>(e.getValue()));

            }

        }

        if (allFofoIds.isEmpty()) {

            return rows;

        }

        // Get fofo stores for filtering and name resolution

        Map<Integer, FofoStore> fofoStoresMap = new HashMap<>();

        try {

            fofoStoresMap = fofoStoreRepository.selectByRetailerIds(new ArrayList<>(allFofoIds)).stream()

                    .collect(Collectors.toMap(FofoStore::getId, x -> x, (a, b) -> a));

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Error fetching fofo stores for all raw data", e);

        }

        // Batch fetch collection rank map

        LocalDateTime startDate = LocalDate.now().atStartOfDay();

        Map<Integer, Integer> allCollectionRankMap = new HashMap<>();

        try {

            allCollectionRankMap = partnerCollectionService.getCollectionRankMap(new ArrayList<>(allFofoIds), startDate);

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Error fetching collection rank map for all raw data", e);

        }

        // MTD billing data

        LocalDate firstOfMonth = LocalDate.now().withDayOfMonth(1);

        LocalDate endOfMonth = LocalDate.now().withDayOfMonth(LocalDate.now().lengthOfMonth()).plusDays(1);

        List<RbmWeeklyBillingModel> mtdBillingData = getWeeklyBillingDataForMonth(firstOfMonth, endOfMonth);

        Set<Integer> allMtdBilledFofoIds = mtdBillingData.stream()

                .filter(RbmWeeklyBillingModel::isMtdBilled)

                .map(RbmWeeklyBillingModel::getFofoId)

                .collect(Collectors.toSet());

        // Batch fetch partner collection remarks for escalation filtering

        Map<Integer, PartnerCollectionRemark> allPartnerCollectionRemarks = new HashMap<>();

        if (!allFofoIds.isEmpty()) {

            List<Integer> allRemarkIds = partnerCollectionRemarkRepository.selectMaxRemarkId(new ArrayList<>(allFofoIds));

            if (!allRemarkIds.isEmpty()) {

                allPartnerCollectionRemarks = partnerCollectionRemarkRepository.selectByIds(allRemarkIds).stream()

                        .collect(Collectors.toMap(PartnerCollectionRemark::getFofoId, x -> x, (a, b) -> a));

            }

        }

        // Resolve partner names/codes in batch

        Map<Integer, CustomRetailer> retailerMap = Collections.emptyMap();

        try {

            retailerMap = retailerService.getFofoRetailers(new ArrayList<>(allFofoIds));

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Error fetching fofo retailers for all raw data", e);

        }

        // Batch-fetch EVERY call log for today (across all callers, not just RBMs) and build a

        // fofoId -> latest AgentCallLog map. We use findAllByDate here so that calls placed by

        // admins, escalation agents, or anyone whose authId isn't in the RBM position table are

        // still surfaced. Downstream we only read this map for fofoIds we actually emit, so

        // extra entries are harmless.

        Map<Integer, AgentCallLog> latestCallByFofo = new HashMap<>();

        try {

            List<AgentCallLog> todayCallLogs = agentCallLogRepository.findAllByDate(LocalDate.now());

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

            for (AgentCallLog log : todayCallLogs) {

                if (log.getCustomerNumber() != null) {

                    String n = log.getCustomerNumber();

                    normalizedMobiles.add(n.startsWith("+91") ? n.substring(3) : n);

                }

            }

            Map<String, Integer> mobileToFofoIdMap = buildMobileToFofoIdMap(normalizedMobiles);

            for (AgentCallLog log : todayCallLogs) {

                if (log.getCustomerNumber() == null) continue;

                String n = log.getCustomerNumber();

                String normalized = n.startsWith("+91") ? n.substring(3) : n;

                Integer fofoId = mobileToFofoIdMap.get(normalized);

                if (fofoId == null) continue;

                AgentCallLog existing = latestCallByFofo.get(fofoId);

                if (existing == null || (log.getId() != null && existing.getId() != null && log.getId() > existing.getId())) {

                    latestCallByFofo.put(fofoId, log);

                }

            }

        } catch (Exception e) {

            LOGGER.error("Error building latest call status map for all raw data", e);

        }

        // Process each L1 RBM

        // Note: no cross-RBM dedup — a partner assigned to multiple RBMs appears once per RBM,

        // matching the UI summary counts so row totals per RBM equal that RBM's "Calling Target".

        for (int rbmAuthId : l1AuthIds) {

            AuthUser authUser = authUserMap.get(rbmAuthId);

            if (authUser == null) {

                continue;

            }

            List<Integer> fofoIdList = rbmToFofoIdsMap.getOrDefault(rbmAuthId, Collections.emptyList());

            if (fofoIdList.isEmpty()) {

                continue; // No L1 partner assignments for this RBM

            }

            // Filter escalated partners for L1 RBMs

            List<Position> positions = positionsByAuthId.getOrDefault(rbmAuthId, Collections.emptyList());

            boolean isRBMAndL1 = positions.stream()

                    .anyMatch(position ->

                            ProfitMandiConstants.TICKET_CATEGORY_RBM == position.getCategoryId()

                                    && EscalationType.L1.equals(position.getEscalationType()));

            List<Integer> fofoIds = fofoIdList;

            if (isRBMAndL1) {

                Map<Integer, PartnerCollectionRemark> partnerRemarks = new HashMap<>();

                for (Integer fofoId : fofoIdList) {

                    if (allPartnerCollectionRemarks.containsKey(fofoId)) {

                        partnerRemarks.put(fofoId, allPartnerCollectionRemarks.get(fofoId));

                    }

                }

                Map<Integer, PartnerCollectionRemark> finalPartnerRemarks = partnerRemarks;

                fofoIds = fofoIdList.stream()

                        .filter(fofoId -> {

                            if (!finalPartnerRemarks.containsKey(fofoId)) return true;

                            PartnerCollectionRemark pcr = finalPartnerRemarks.get(fofoId);

                            return !(CollectionRemark.RBM_L2_ESCALATION.equals(pcr.getRemark())

                                    || CollectionRemark.SALES_ESCALATION.equals(pcr.getRemark()));

                        })

                        .collect(Collectors.toList());

            }

            // Filter to only external, ACTIVE or REVIVAL stores

            Map<Integer, FofoStore> finalFofoStoresMap = fofoStoresMap;

            List<Integer> validFofoIds = fofoIds.stream()

                    .filter(fofoId -> {

                        FofoStore store = finalFofoStoresMap.get(fofoId);

                        if (store == null || store.isInternal()) return false;

                        return ActivationType.ACTIVE.equals(store.getActivationType())

                                || ActivationType.REVIVAL.equals(store.getActivationType());

                    })

                    .collect(Collectors.toList());

            String rbmName = authUser.getFullName();

            // Categorize each partner and add a row per RBM assignment.

            for (Integer fofoId : validFofoIds) {

                int rank = allCollectionRankMap.getOrDefault(fofoId, 5);

                boolean hasZeroBilling = !allMtdBilledFofoIds.contains(fofoId);

                String status;

                if (rank == 1) {

                    status = "Plan Today";

                } else if (rank == 2) {

                    status = "Carry Forward";

                } else if (hasZeroBilling) {

                    status = "Zero Billing";

                } else if (rank == 3) {

                    status = "Untouched";

                } else {

                    continue; // Skip Future Plan and Normal — only include calling target parties

                }

                CustomRetailer retailer = retailerMap.get(fofoId);

                String partnerName = retailer != null ? retailer.getBusinessName() : "Unknown (" + fofoId + ")";

                String partnerCode = retailer != null ? retailer.getCode() : "-";

                // "Did Not Try" means the PARTNER has no call log today from anyone — not tied to this RBM.

                // If any caller reached this partner, show the actual status.

                String latestCallStatus = "Did Not Try";

                AgentCallLog latestLog = latestCallByFofo.get(fofoId);

                if (latestLog != null && latestLog.getCallStatus() != null && !latestLog.getCallStatus().isEmpty()) {

                    latestCallStatus = latestLog.getCallStatus();

                }

                rows.add(Arrays.asList(partnerName, partnerCode, status, rbmName, latestCallStatus));

            }

        }

        return rows;

    }

    /**

     * Get count of distinct partners called today based on call logs.

     * Maps customerNumber from call log to fofoId using retailer_contact and address.

     * If same fofoId is called multiple times, counts only once.

     * Numbers without fofoId mapping are also counted (by distinct customer number).

     *

     * @param authId the RBM auth ID

     * @return count of distinct partners/numbers called today

     */

    public long getCalledCountFromCallLogs(long authId) {

        return getCalledCountFromCallLogs(authId, LocalDate.now());

    }

    public long getCalledCountFromCallLogs(long authId, LocalDate date) {

        return getCallStats(authId, date)[0];

    }

    /**

     * Batch-builds a mobile (normalized, +91 stripped) -> fofoId mapping for all the given mobiles

     * in just two queries (retailer_contact, then address fallback for unmapped numbers).

     * Replaces the previous per-call-log findFofoIdByMobile() N+1 lookups.

     */

    private Map<String, Integer> buildMobileToFofoIdMap(Set<String> normalizedMobiles) {

        Map<String, Integer> result = new HashMap<>();

        if (normalizedMobiles == null || normalizedMobiles.isEmpty()) {

            return result;

        }

        List<String> mobilesList = new ArrayList<>(normalizedMobiles);

        // First pass: retailer_contact

        List<RetailerContact> contacts = retailerContactRepository.selectByMobiles(mobilesList);

        for (RetailerContact rc : contacts) {

            // Keep the first fofoId we see per mobile (matches old single-mobile behavior of get(0))

            result.putIfAbsent(rc.getMobile(), rc.getFofoId());

        }

        // Second pass: address fallback for mobiles not yet mapped

        List<String> unmapped = mobilesList.stream()

                .filter(m -> !result.containsKey(m))

                .collect(Collectors.toList());

        if (!unmapped.isEmpty()) {

            List<Address> addresses = addressRepository.selectAllByPhoneNumbers(unmapped);

            for (Address addr : addresses) {

                result.putIfAbsent(addr.getPhoneNumber(), addr.getRetaierId());

            }

        }

        return result;

    }

    /**

     * In-memory variant of getCallStats() that uses pre-fetched call logs and mobile→fofoId mapping.

     * Used by the batch-fetched RBM Call Target loop to avoid N+1 query patterns.

     */

    private long[] getCallStatsFromLogs(List<AgentCallLog> callLogs, Map<String, Integer> mobileToFofoIdMap) {

        if (callLogs == null || callLogs.isEmpty()) {

            return new long[]{0, 0, 0};

        }

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

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

        long totalRecordingCalls = 0;

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

        for (AgentCallLog callLog : callLogs) {

            String customerNumber = callLog.getCustomerNumber();

            if (customerNumber != null) {

                String normalized = customerNumber.startsWith("+91") ? customerNumber.substring(3) : customerNumber;

                Integer fofoId = mobileToFofoIdMap.get(normalized);

                if (fofoId != null) {

                    calledFofoIds.add(fofoId);

                } else {

                    calledNumbersWithoutFofoId.add(normalized);

                }

                if (callLog.getRecordingUrl() != null && !callLog.getRecordingUrl().isEmpty()

                        && !"None".equalsIgnoreCase(callLog.getRecordingUrl())) {

                    totalRecordingCalls++;

                    uniqueRecordingNumbers.add(normalized);

                }

            }

        }

        long calledCount = calledFofoIds.size() + calledNumbersWithoutFofoId.size();

        return new long[]{calledCount, totalRecordingCalls, uniqueRecordingNumbers.size()};

    }

            List<AgentCallLog> l1Logs = callLogsByAuthId.get((long) rbmAuthId);

            targetModel.setTriedUniqueCalls(computeUniqueTriedCount(l1Logs));

            List<AgentCallLog> l2Logs = callLogsByAuthId.get((long) l2AuthId);

            l2Model.setTriedUniqueCalls(computeUniqueTriedCount(l2Logs));

            List<AgentCallLog> l3Logs = callLogsByAuthId.get((long) l3AuthId);

            l3Model.setTriedUniqueCalls(computeUniqueTriedCount(l3Logs));