Subversion Repositories SmartDukaan

    @Override

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

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

        // Get all L1 RBM positions

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

        // Get partner assignments

        Map<String, Set<Integer>> storeGuyMap = csService.getAuthUserPartnerIdMapping();

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

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

        for (int rbmAuthId : l1AuthIds) {

            AuthUser au = authUserMap.get(rbmAuthId);

            if (au != null && storeGuyMap.containsKey(au.getEmailId())) {

                List<Integer> fofoIds = new ArrayList<>(storeGuyMap.get(au.getEmailId()));

                allFofoIds.addAll(fofoIds);

                rbmToFofoIdsMap.put(rbmAuthId, fofoIds);

            }

        }

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

        }

        // Get positions for L1 check

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

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

        // Track processed fofoIds to avoid duplicates (a party assigned to L1 RBM

        // should not appear again under another RBM who also has it via L2 position)

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

        // Process each L1 RBM

        for (int rbmAuthId : l1AuthIds) {

            AuthUser authUser = authUserMap.get(rbmAuthId);

            if (authUser == null || !storeGuyMap.containsKey(authUser.getEmailId())) {

                continue;

            }

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

            // 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 row (skip if already processed under another RBM)

            for (Integer fofoId : validFofoIds) {

                if (processedFofoIds.contains(fofoId)) {

                    continue; // Already added under another L1 RBM

                }

                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

                }

                processedFofoIds.add(fofoId);

                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;

    }