Subversion Repositories SmartDukaan

        LocalDateTime startDate = today.atStartOfDay();

        LocalDate firstOfMonth = today.withDayOfMonth(1);

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

        // Get auth user

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

        if (authUsers.isEmpty()) {

            return Collections.emptyList();

        }

        AuthUser authUser = authUsers.get(0);

        // Check if L1 or 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()));

        List<Integer> fofoIdList;

        if (isL2) {

            // L2: get fofo IDs from escalated tickets (all escalated tickets are target)

            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());

            // For L2, all escalated tickets are target

            Set<Integer> targetFofoIds = new HashSet<>(fofoIdList);

            // Get today's remarks

            // Filter to only target partners and deduplicate

            Map<Integer, PartnerCollectionRemark> uniqueRemarksByFofoId = new LinkedHashMap<>();

            for (PartnerCollectionRemark remark : todayRemarks) {

                if (targetFofoIds.contains(remark.getFofoId())) {

                    uniqueRemarksByFofoId.putIfAbsent(remark.getFofoId(), remark);

                }

            }

            return buildCalledPartnerResult(uniqueRemarksByFofoId);

        }

        // L1 Logic

        Map<String, Set<Integer>> storeGuyMap;

        try {

            storeGuyMap = csService.getAuthUserPartnerIdMapping();

        } catch (ProfitMandiBusinessException e) {

            LOGGER.error("Error fetching store guy map", e);

            return Collections.emptyList();

        }

        if (!storeGuyMap.containsKey(authUser.getEmailId())) {

            return Collections.emptyList();

        }

        fofoIdList = new ArrayList<>(storeGuyMap.get(authUser.getEmailId()));

        if (fofoIdList.isEmpty()) {

            return Collections.emptyList();

        }

        // Get fofo stores for filtering

        Map<Integer, FofoStore> fofoStoresMap;

        try {

            fofoStoresMap = fofoStoreRepository.selectByRetailerIds(fofoIdList).stream()

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

        } catch (ProfitMandiBusinessException e) {

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

            return Collections.emptyList();

        }

        // Filter escalated partners for L1

        List<Integer> allRemarkIds = partnerCollectionRemarkRepository.selectMaxRemarkId(fofoIdList);

        if (!allRemarkIds.isEmpty()) {

            Map<Integer, PartnerCollectionRemark> partnerCollectionRemarks = partnerCollectionRemarkRepository.selectByIds(allRemarkIds).stream()

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

            fofoIdList = partnerCollectionRemarks.entrySet().stream()

                    .filter(entry -> {

                        PartnerCollectionRemark pcrMap = entry.getValue();

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

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

                    })

                    .map(Map.Entry::getKey)

                    .collect(Collectors.toList());

        }

        // Filter to only external, ACTIVE stores

        List<Integer> validFofoIds = fofoIdList.stream()

                .filter(fofoId -> {

                    FofoStore store = fofoStoresMap.get(fofoId);

                    if (store == null || store.isInternal()) {

                        return false;

                    }

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

                })

                .collect(Collectors.toList());

        // Get collection rank map

        Map<Integer, Integer> collectionRankMap;

        try {

            collectionRankMap = partnerCollectionService.getCollectionRankMap(validFofoIds, startDate);

        } catch (ProfitMandiBusinessException e) {

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

            collectionRankMap = new HashMap<>();

        }

        // Get MTD billing data for zero billing check

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

        Set<Integer> mtdBilledFofoIds = mtdBillingData.stream()

                .filter(RbmWeeklyBillingModel::isMtdBilled)

                .map(RbmWeeklyBillingModel::getFofoId)

                .collect(Collectors.toSet());

        // Build target partner set (PlanToday + CarryForward + ZeroBilling + Untouched)

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

        for (Integer fofoId : validFofoIds) {

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

            boolean hasZeroBilling = !mtdBilledFofoIds.contains(fofoId);

            // Same priority logic as in getRbmCallTargetModels

            if (rank == 1 || rank == 2 || hasZeroBilling || rank == 3) {

                targetFofoIds.add(fofoId);

            }

            // rank 4 (FuturePlan) and rank 5 (Normal) are NOT in target

        }

        // Get today's remarks

        List<PartnerCollectionRemark> todayRemarks = partnerCollectionRemarkRepository

                .selectAllByAuthIdsOnDate(Collections.singletonList(authId), today);

            if (targetFofoIds.contains(remark.getFofoId())) {

            }

        }

        return buildCalledPartnerResult(uniqueRemarksByFofoId);

    }

    private List<CalledPartnerDetailModel> buildCalledPartnerResult(Map<Integer, PartnerCollectionRemark> uniqueRemarksByFofoId) {

        if (uniqueRemarksByFofoId.isEmpty()) {

            return Collections.emptyList();