Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;

import com.mongodb.DBObject;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import com.spice.profitmandi.common.model.*;

import com.spice.profitmandi.common.util.FileUtil;

import com.spice.profitmandi.common.util.FormattingUtils;

import com.spice.profitmandi.common.web.util.ResponseSender;

import com.spice.profitmandi.dao.entity.auth.AuthUser;

import com.spice.profitmandi.dao.entity.catalog.BrandCatalog;

import com.spice.profitmandi.dao.entity.fofo.PartnerDailyInvestment;

import com.spice.profitmandi.dao.entity.user.*;

import com.spice.profitmandi.dao.enumuration.cs.EscalationType;

import com.spice.profitmandi.dao.enumuration.dtr.CommunicationType;

import com.spice.profitmandi.dao.enumuration.dtr.LeadSource;

import com.spice.profitmandi.dao.enumuration.dtr.LeadStatus;

import com.spice.profitmandi.dao.model.*;

import com.spice.profitmandi.dao.repository.auth.AuthRepository;

import com.spice.profitmandi.dao.repository.auth.PartnerCollectionPlanRepository;

import com.spice.profitmandi.dao.repository.auth.PartnerCollectionRemarkRepository;

import com.spice.profitmandi.dao.repository.cs.CsService;

import com.spice.profitmandi.dao.repository.cs.PositionRepository;

import com.spice.profitmandi.dao.repository.dtr.*;

import com.spice.profitmandi.dao.repository.fofo.PartnerDailyInvestmentRepository;

import com.spice.profitmandi.dao.repository.fofo.RbmRatingRepository;

import com.spice.profitmandi.dao.repository.inventory.StateRepository;

import com.spice.profitmandi.dao.repository.transaction.UserWalletRepository;

import com.spice.profitmandi.service.AuthService;

import com.spice.profitmandi.service.PartnerCollectionService;

import com.spice.profitmandi.service.RbmTargetService;

import com.spice.profitmandi.service.catalog.BrandsService;

import com.spice.profitmandi.service.order.OrderService;

import com.spice.profitmandi.service.user.RetailerService;

import com.spice.profitmandi.web.model.LoginDetails;

import com.spice.profitmandi.web.util.CookiesProcessor;

import com.spice.profitmandi.web.util.MVCResponseSender;

import org.apache.commons.csv.CSVFormat;

import org.apache.commons.csv.CSVParser;

import org.apache.commons.csv.CSVRecord;

import org.apache.commons.io.output.ByteArrayOutputStream;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.core.io.InputStreamResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

import org.springframework.util.StringUtils;

import org.springframework.web.bind.annotation.*;

import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.ByteArrayInputStream;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.Reader;

import java.text.DecimalFormat;

import java.time.DayOfWeek;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.LocalTime;

import java.time.format.DateTimeFormatter;

import java.time.temporal.TemporalAdjusters;

import java.util.*;

import java.util.Map.Entry;

import java.util.stream.Collectors;

@Controller

@Transactional(rollbackFor = Throwable.class)

public class LeadController {

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

    /** Source / createdBy label for leads captured by the AI assistant (chat + voice). */

    private static final String AI_LEAD_SOURCE = "AI Assistant";

    @Value("${ai.lead.intake.token:}")

    private String aiLeadIntakeToken;

    /**

     * AI-assistant lead intake, hosted in the fofo app so it deploys via {@code fofo_deploy}. Mirrors the

     * profitmandi-web /add/lead contract: shared-secret {@code Auth-Token}, source stamped server-side,

     * idempotent by mobile+source, NOT NULL columns coalesced (so a minimal name+number lead never

     * crashes), stores {@code state} + {@code recordingUrl}, status = pending (Open/New). This path is

     * excluded from fofo's authentication/role/post interceptors in WebConfig.

     */

    @RequestMapping(value = ProfitMandiConstants.URL_AI_LEAD_INTAKE, method = RequestMethod.POST)

    @ResponseBody

    public ResponseEntity<?> aiLead(HttpServletRequest request,

                                    @RequestHeader(name = "Auth-Token", required = false) String authToken,

                                    @RequestBody AiLeadRequest aiLeadRequest) {

        LOGGER.info("AI lead intake request: {}", aiLeadRequest);

        if (aiLeadIntakeToken == null || aiLeadIntakeToken.trim().isEmpty()

                || authToken == null || !aiLeadIntakeToken.equals(authToken)) {

            LOGGER.warn("AI lead intake rejected: invalid or missing Auth-Token");

            return aiLeadResponse(HttpStatus.UNAUTHORIZED, "401", "UNAUTHORIZED", "FAILURE", null);

        }

        String rawMobile = aiLeadRequest.getMobile();

        String mobile = rawMobile == null ? "" : rawMobile.replaceAll("\\D", "");

        if (mobile.length() > 10) {

            mobile = mobile.substring(mobile.length() - 10);

        }

        if (mobile.length() != 10) {

            return aiLeadResponse(HttpStatus.BAD_REQUEST, "400", "Mobile number must contain 10 digits", "FAILURE", null);

        }

        String firstName = aiLeadRequest.getFirstName();

        if (firstName == null || firstName.trim().isEmpty()) {

            return aiLeadResponse(HttpStatus.BAD_REQUEST, "400", "First name is required", "FAILURE", null);

        }

        // Idempotency scoped to AI leads only (the AI side retries fire-and-forget posts).

        Lead existing = leadRepository.selectByMobileNumberAndSource(mobile, AI_LEAD_SOURCE);

        if (existing != null) {

            LOGGER.info("AI lead intake: AI lead already exists for mobile {} (id={}), skipping create", mobile, existing.getId());

            return aiLeadResponse(HttpStatus.OK, "200", "OK", "SUCCESS", existing.getId());

        }

        Lead lead = new Lead();

        lead.setLeadMobile(mobile);

        lead.setFirstName(firstName.trim());

        // last_name / city / address / state are NOT NULL in user.lead; coalesce nulls to "" so a minimal lead never crashes.

        lead.setLastName(aiLeadRequest.getLastName() == null ? "" : aiLeadRequest.getLastName().trim());

        String city = aiLeadRequest.getCity() == null ? "" : aiLeadRequest.getCity().trim();

        lead.setCity(city);

        lead.setOutLetName(aiLeadRequest.getOutletName());

        // AI does not collect a separate address; mirror web capture and fall back to city.

        lead.setAddress(city);

        String state = aiLeadRequest.getState();

        lead.setState(state == null ? "" : state.trim());

        // Source stamped server-side; caller cannot override it.

        lead.setSource(AI_LEAD_SOURCE);

        lead.setCreatedBy(AI_LEAD_SOURCE);

        lead.setStatus(LeadStatus.pending);

        lead.setColor("yellow");

        // Optional call-recording URL (voice leads only); store null when absent.

        String recordingUrl = aiLeadRequest.getRecordingUrl();

        if (recordingUrl != null && !recordingUrl.trim().isEmpty()) {

            lead.setRecordingUrl(recordingUrl.trim());

        }

        lead.setAssignTo(53);

        lead.setAuthId(lead.getAssignTo());

        lead.setCreatedTimestamp(LocalDateTime.now());

        lead.setUpdatedTimestamp(LocalDateTime.now());

        leadRepository.persist(lead);

        LOGGER.info("AI lead intake: created lead id={} for mobile {}", lead.getId(), mobile);

        return aiLeadResponse(HttpStatus.OK, "200", "OK", "SUCCESS", lead.getId());

    }

    private ResponseEntity<Map<String, Object>> aiLeadResponse(HttpStatus status, String statusCode,

                                                               String statusMessage, String responseStatus, Object response) {

        Map<String, Object> body = new HashMap<>();

        body.put("statusCode", statusCode);

        body.put("statusMessage", statusMessage);

        body.put("response", response);

        body.put("responseStatus", responseStatus);

        return ResponseEntity.status(status).body(body);

    }

    @Autowired

    private LeadRepository leadRepository;

    @Autowired

    private LeadActivityRepository leadActivityRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.LeadVisitRequestRepository leadVisitRequestRepository;

    @Autowired

    private StateRepository stateRepository;

    @Autowired

    private AuthService authService;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private Gson gson;

    @Autowired

    private CookiesProcessor cookiesProcessor;

    @Autowired

    PositionRepository positionRepository;

    @Autowired

    private MVCResponseSender mvcResponseSender;

    @Autowired

    private PartnerCollectionPlanRepository partnerCollectionPlanRepository;

    @Autowired

    private CsService csService;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private PartnerCollectionService partnerCollectionService;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private PartnerCollectionRemarkRepository partnerCollectionRemarkRepository;

    @Autowired

    private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    @Autowired

    private UserWalletRepository userWalletRepository;

    @Autowired

    private FranchiseeVisitRepository franchiseeVisitRepository;

    @Autowired

    private FranchiseeActivityRepository franchiseeActivityRepository;

    @Autowired

    private VisitRequestRepository visitRequestRepository;

    @Autowired

    private LeadBrandRepository leadBrandRepository;

    @Autowired

    private LeadDetailRepository leadDetailRepository;

    @Autowired

    private LeadLiveLocationRepository leadLiveLocationRepository;

    @Autowired

    private BeatRouteRepository beatRouteRepository;

    @Autowired

    private LeadRouteRepository leadRouteRepository;

    @Autowired

    private BeatRepository beatRepository;

    @Autowired

    private org.springframework.mail.javamail.JavaMailSender gmailRelaySender;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private ResponseSender<?> responseSender;

    @Autowired

    private BrandsService brandsService;

    @Autowired

    OrderService orderService;

    @Autowired

    private RbmRatingRepository rbmRatingRepository;

    List<LeadStatus> status = Arrays.asList(LeadStatus.notInterested, LeadStatus.finalized);

    @RequestMapping(value = "/getOpenLead", method = RequestMethod.GET)

    public String getOpenLead(HttpServletRequest request, @RequestParam(name = "leadStatus", required = false, defaultValue = "All") List<LeadStatus> leadStatus, @RequestParam(name = "color", required = false, defaultValue = "All") List<String> color, @RequestParam(name = "startDate", required = false) LocalDate startDate, @RequestParam(name = "endDate", required = false) LocalDate endDate, Model model) throws Exception {

        LocalDateTime startDateTime = startDate != null ? startDate.atStartOfDay() : null;

        LocalDateTime endDateTime = endDate != null ? endDate.atTime(23, 59, 59) : null;

        LOGGER.info("startDateTime: " + startDateTime + ", endDateTime: " + endDateTime);

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        String emailId = loginDetails.getEmailId();

        AuthUser authUser = authRepository.selectByEmailOrMobile(emailId);

        boolean isPositionSales = positionRepository.hasCategory(authUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_SALES);

        if (leadStatus.contains(LeadStatus.All)) {

            leadStatus.add(LeadStatus.pending);

            leadStatus.add(LeadStatus.notInterested);

            leadStatus.add(LeadStatus.finalized);

        }

        if (color.contains("All")) {

            color.add("yellow");

            color.add("green");

        }

        List<Lead> leads = new ArrayList<>();

        model.addAttribute("colors", color);

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

        List<Integer> authUserIds = null;

        LOGGER.info("color111" + color);

        List<Lead> leadFollowUp = new ArrayList<>();

        if (isPositionSales) {

            authUserIds = authService.getAllReportees(authUser.getId());

            authUserIds.add(authUser.getId());

            LOGGER.info("authIds" + authUserIds);

            LOGGER.info("leadStatus" + leadStatus);

            if (startDateTime == null) {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndUpdatedTimestampAndAuthIds(leadStatus, authUserIds, color, LocalDateTime.now().minusMonths(1));

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectByAssignAuthIdsAndStatus(authUserIds, LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            } else {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndBetweenCreatedDateAndAuthIds(leadStatus, authUserIds, color, startDateTime, endDateTime);

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectByAssignAuthIdsAndStatus(authUserIds, LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            }

        } else {

            if (startDateTime == null) {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndUpdatedTimestamp(leadStatus, color, LocalDateTime.now().minusMonths(1));

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

                LOGGER.info("leadlocalDateTime1" + leads);

            } else {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndBetweenCreatedDate(leadStatus, color, startDateTime, endDateTime);

                }

                if (leadStatus.contains(LeadStatus.followUp)) {

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

                LOGGER.info("leadlocalDateTime2" + leads);

            }

        }

        if (isPositionSales && authUserIds.size() > 0) {

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

            leadCreators.add("daily-sync");

            leadCreators.addAll(csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_SALES, Arrays.asList(EscalationType.L1, EscalationType.L2)).stream().map(x -> x.getFullName()).collect(Collectors.toList()));

            leadCreators.addAll(csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_BGC, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3)).stream().map(x -> x.getFullName()).collect(Collectors.toList()));

            model.addAttribute("leadCreators", leadCreators);

        }

        List<Lead> weekLast = new ArrayList<>();

        List<Lead> weekThird = new ArrayList<>();

        List<Lead> weekSecond = new ArrayList<>();

        List<Lead> weekFirst = new ArrayList<>();

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

        List<LeadWeakWiseModel> lwDays = new ArrayList<>();

        for (int i = 7; i >= 1; i--) {

            LocalDateTime startOfDay = curDate.minusDays(i);

            LeadWeakWiseModel lm = new LeadWeakWiseModel();

            lm.setMonth(startOfDay.toLocalDate());

            lwDays.add(lm);

        }

        if (!leads.isEmpty()) {

            weekLast.addAll(

                    leads.stream().filter(x -> x.getCreatedTimestamp().isAfter(curDate.minusDays(28)) && x.getCreatedTimestamp().isBefore(curDate.minusDays(21))).collect(Collectors.toList()));

            weekThird.addAll(leads.stream().filter(x -> x.getCreatedTimestamp().isAfter(curDate.minusDays(21)) && x.getCreatedTimestamp().isBefore(curDate.minusDays(14))).collect(Collectors.toList()));

            weekSecond.addAll(leads.stream().filter(x -> x.getCreatedTimestamp().isAfter(curDate.minusDays(14)) && x.getCreatedTimestamp().isBefore(curDate.minusDays(7))).collect(Collectors.toList()));

            weekFirst.addAll(leads.stream().filter(x -> x.getCreatedTimestamp().isAfter(curDate.minusDays(7))).collect(Collectors.toList()));

        }

        LOGGER.info("weekLast" + weekLast);

        LOGGER.info("weekThird" + weekThird);

        LOGGER.info("weekSecond" + weekSecond);

        Map<String, Long> leadLasts = weekLast.stream().collect(Collectors.groupingBy(x -> x.getCreatedBy(), Collectors.counting()));

        Map<String, Long> leadThirds = weekThird.stream().collect(Collectors.groupingBy(x -> x.getCreatedBy(), Collectors.counting()));

        Map<String, Long> leadSeconds = weekSecond.stream().collect(Collectors.groupingBy(x -> x.getCreatedBy(), Collectors.mapping(Lead::getCreatedBy, Collectors.counting())));

        Map<String, Map<LocalDate, Long>> leadFirsts = weekFirst.stream().collect(Collectors.groupingBy(x -> x.getCreatedBy(), Collectors.groupingBy(x -> x.getCreatedTimestamp().toLocalDate(), Collectors.counting())));

        LOGGER.info("leadFirsts" + leadFirsts);

        List<Integer> authIds = new ArrayList<>();

        if (!leads.isEmpty()) {

            authIds.addAll(leads.stream().map(x -> x.getAssignTo()).collect(Collectors.toList()));

            leadActivityMap = leadActivityRepository.selectAllByleadIds(leads.stream().map(x -> x.getId()).collect(Collectors.toList())).stream().collect(Collectors.groupingBy(LeadActivity::getLeadId, Collectors.toList()));

            Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

            model.addAttribute("leadActivityMap", leadActivityMap);

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

            // Pending visit requests per lead — drives the "Visit request pending"

            // badge on the row template. Best-effort: never blocks the list render.

            try {

                List<Integer> leadIds = leads.stream().map(Lead::getId).collect(Collectors.toList());

                List<com.spice.profitmandi.dao.entity.user.LeadVisitRequest> pending =

                        leadVisitRequestRepository.selectByLeadIdsAndStatus(leadIds, "PENDING");

                Set<Integer> pendingSet = pending.stream()

                        .map(com.spice.profitmandi.dao.entity.user.LeadVisitRequest::getLeadId)

                        .collect(Collectors.toSet());

                model.addAttribute("pendingVisitRequestLeadIds", pendingSet);

            } catch (Exception e) {

                LOGGER.warn("pending visit-request lookup failed: {}", e.getMessage());

                model.addAttribute("pendingVisitRequestLeadIds", new HashSet<Integer>());

            }

        }

        ChartLeadModel cm = this.getLeadChart(leads);

        model.addAttribute("chartLead", gson.toJson(cm));

        LOGGER.info("ChartLeadModel" + gson.toJson(cm));

        LOGGER.info("lwDays" + lwDays);

        LOGGER.info("leads" + leads);

        List<String> stateNames = stateRepository.selectAll().stream().map(x -> x.getName()).collect(Collectors.toList());

//        List<AuthUser> authUsers = authRepository.selectAllActiveUser();

        List<AuthUser> authUsers = new ArrayList<>();

        List<AuthUser> salesUsers = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_SALES, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3));

        List<AuthUser> abmUsers = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_ABM, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3));

        List<AuthUser> bgcUsers = csService.getAuthUserIds(ProfitMandiConstants.TICKET_CATEGORY_BGC, Arrays.asList(EscalationType.L1, EscalationType.L2, EscalationType.L3));

        authUsers.addAll(salesUsers);

        authUsers.addAll(abmUsers);

        authUsers.addAll(bgcUsers);

        LocalDate lastDate = curDate.minusDays(1).toLocalDate();

        List<LocalDate> weekDates = new ArrayList<>();

        weekDates.add(curDate.minusDays(28).toLocalDate());

        weekDates.add(curDate.minusDays(22).toLocalDate());

        weekDates.add(curDate.minusDays(21).toLocalDate());

        weekDates.add(curDate.minusDays(15).toLocalDate());

        weekDates.add(curDate.minusDays(14).toLocalDate());

        weekDates.add(curDate.minusDays(8).toLocalDate());

        weekDates.add(curDate.minusDays(7).toLocalDate());

        LOGGER.info("lastDate" + lastDate);

        model.addAttribute("weekDates", weekDates);

        model.addAttribute("startDate", startDate);

        model.addAttribute("endDate", endDate);

        model.addAttribute("lastDate", lastDate);

        model.addAttribute("stateNames", stateNames);

        model.addAttribute("communicationTypes", CommunicationType.values());

        model.addAttribute("authUsers", authUsers);

        model.addAttribute("leads", leads);

        model.addAttribute("leadStatus", LeadStatus.values());

        model.addAttribute("leadLasts", leadLasts);

        model.addAttribute("leadThirds", leadThirds);

        model.addAttribute("leadSeconds", leadSeconds);

        model.addAttribute("leadFirsts", leadFirsts);

        model.addAttribute("lwDays", lwDays);

        model.addAttribute("selectedLeadStatus", leadStatus.get(0));

        boolean showBulkUploader =

                "sm@smartdukaan.com".equalsIgnoreCase(emailId);

        model.addAttribute("showBulkUploader", showBulkUploader);

        List<BrandCatalog> brandsDisplays = brandsService.getBrandsToDisplay(3);

        brandsDisplays.addAll(brandsService.getBrandsToDisplay(6));

        model.addAttribute("brandsDisplays", brandsDisplays.stream().distinct().collect(Collectors.toList()));

        LOGGER.info("brandsDisplays" + brandsDisplays);

        // Geo location status map for all leads

        if (!leads.isEmpty()) {

            List<Integer> allLeadIds = leads.stream().map(Lead::getId).collect(Collectors.toList());

            Map<Integer, LeadLiveLocation> geoLocationMap = leadLiveLocationRepository.selectByLeadIds(allLeadIds).stream()

                    .collect(Collectors.toMap(LeadLiveLocation::getLeadId, x -> x, (a, b) -> a));

            model.addAttribute("geoLocationMap", geoLocationMap);

        } else {

            model.addAttribute("geoLocationMap", new HashMap<>());

        }

        model.addAttribute("salesUsers", salesUsers);

        model.addAttribute("bgcUsers", bgcUsers);

        return "lead";

    }

    public ChartLeadModel getLeadChart(List<Lead> leads) throws ProfitMandiBusinessException {

        Map<LeadStatus, Long> leadStatusMap = leads.stream().collect(

                Collectors.groupingBy(x -> x.getStatus(), Collectors.mapping(Lead::getStatus, Collectors.counting())));

        Map<String, Long> hotLeadsMap = leads.stream().collect(

                Collectors.groupingBy(x -> x.getColor(), Collectors.mapping(Lead::getColor, Collectors.counting())));

        LOGGER.info("hotLeadsMap" + hotLeadsMap);

        ChartLeadModel cm = new ChartLeadModel();

        HashSet<LeadStatus> labels = new HashSet<LeadStatus>();

        labels.addAll(leadStatusMap.keySet());

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

        hotLeads.addAll(leadStatusMap.keySet().stream().map(x -> x.toString()).collect(Collectors.toSet()));

        hotLeads.add("HotLead");

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

        hotLeadKeys.add("HotLead");

        List<String> hotLeadGreen = new ArrayList<>(hotLeadKeys);

        LOGGER.info("hotLeads" + hotLeads);

        List<LeadStatus> labelList = new ArrayList<>(labels);

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

        LOGGER.info("hotLeadKeys" + hotLeadKeys);

        List<Long> values = new ArrayList<>();

        for (String hotLead : hotLeads) {

            if (hotLead.equals("pending")) {

                backgroundColor.add("pink");

                values.add(leadStatusMap.get(LeadStatus.pending));

            }

            if (hotLead.equals("notInterested")) {

                backgroundColor.add("red");

                values.add(leadStatusMap.get(LeadStatus.notInterested));

            }

            if (hotLead.equals("followUp")) {

                backgroundColor.add("#9ACD32");

                values.add(leadStatusMap.get(LeadStatus.followUp));

            }

            if (hotLead.equals("finalized")) {

                backgroundColor.add("blue");

                values.add(leadStatusMap.get(LeadStatus.finalized));

            }

            if (hotLead.equals("HotLead")) {

                backgroundColor.add("green");

                values.add(hotLeadsMap.get("Green"));

            }

        }

        LOGGER.info("labelList" + labelList);

        LOGGER.info("backgroundColor" + backgroundColor);

        LOGGER.info("labelsChartLead" + labels);

        LeadStatusData data = new LeadStatusData();

        data.setData(values);

        data.setBackgroundColor(backgroundColor);

        data.setLabel("DataSet 1");

        PieLables label = new PieLables();

        label.setFontColor("black");

        label.setFontSize(15);

        Legend legend = new Legend();

        legend.setLabels(label);

        legend.setPosition("left");

        List<LeadStatusData> dataList = new ArrayList<>();

        dataList.add(data);

        DataLeadModel datasets = new DataLeadModel();

        datasets.setDatasets(dataList);

        datasets.setLabels(hotLeads);

        OptionModel om = new OptionModel();

        om.setLegend(legend);

        cm.setType("pie");

        cm.setData(datasets);

        cm.setOptions(om);

        return cm;

    }

    @RequestMapping(value = "/downloadDateWiseLead", method = RequestMethod.GET)

    public ResponseEntity<?> getdownloadLeadDataByDate(HttpServletRequest request,

                                                       @RequestParam(name = "leadStatus", required = false, defaultValue = "All") List<LeadStatus> leadStatus,

                                                       @RequestParam(name = "color", required = false, defaultValue = "All") List<String> color,

                                                       @RequestParam(name = "startDate", required = false) LocalDate startDate,

                                                       @RequestParam(name = "endDate", required = false) LocalDate endDate) throws Exception {

        LoginDetails fofoDetails = cookiesProcessor.getCookiesObject(request);

        String emailId = fofoDetails.getEmailId();

        LocalDateTime startDateTime = startDate != null ? startDate.atStartOfDay() : null;

        LocalDateTime endDateTime = endDate != null ? endDate.atTime(23, 59, 59) : null;

        List<Lead> leads = new ArrayList<>();

        AuthUser authUser = authRepository.selectByEmailOrMobile(emailId);

        if (leadStatus.contains(LeadStatus.All)) {

            leadStatus.add(LeadStatus.pending);

            leadStatus.add(LeadStatus.notInterested);

            leadStatus.add(LeadStatus.finalized);

            // NOTE: do NOT add followUp here. Follow-ups are pulled separately (undated) below,

            // mirroring the on-screen view. Adding it here made the date query get skipped so the

            // download collapsed to follow-ups only (original bug).

        }

        if (color.contains("All")) {

            color.add("yellow");

            color.add("green");

        }

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

        boolean authPositon = positionRepository.hasCategory(authUser.getId(), ProfitMandiConstants.TICKET_CATEGORY_SALES);

        List<Integer> authUserIds = null;

        List<Lead> leadFollowUp = new ArrayList<>();

        if (authPositon) {

            authUserIds = authService.getAllReportees(authUser.getId());

            authUserIds.add(authUser.getId());

            if (startDateTime == null) {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndUpdatedTimestampAndAuthIds(leadStatus, authUserIds, color, LocalDateTime.now().minusMonths(1));

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectByAssignAuthIdsAndStatus(authUserIds, LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            } else {

                // Date range: non-follow-up statuses created within [start, end], PLUS all follow-ups

                // (undated) — mirrors the on-screen view so the CSV matches what the user sees.

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndBetweenCreatedDateAndAuthIds(leadStatus, authUserIds, color, startDateTime, endDateTime);

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectByAssignAuthIdsAndStatus(authUserIds, LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            }

        } else {

            if (startDateTime == null) {

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndUpdatedTimestamp(leadStatus, color, LocalDateTime.now().minusMonths(1));

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            } else {

                // Date range: non-follow-up statuses created within [start, end], PLUS all follow-ups

                // (undated) — mirrors the on-screen view.

                if (!leadStatus.contains(LeadStatus.followUp)) {

                    leads = leadRepository.selectAllByColorStatusAndBetweenCreatedDate(leadStatus, color, startDateTime, endDateTime);

                }

                if (leadStatus.contains(LeadStatus.followUp) || leadStatus.contains(LeadStatus.All)) {

                    leadFollowUp = leadRepository.selectAllByStatus(LeadStatus.followUp);

                    leads.addAll(leadFollowUp);

                }

            }

        }

        // Build activity map and auth map (SAME AS VIEW ENDPOINT)

        // Guard both lookups on a non-empty result: an empty list would generate an invalid

        // "IN ()" and 500 (e.g. a date range with no leads), so an empty range yields an empty CSV.

        Map<Integer, AuthUser> authIdAndAuthUserMap = new HashMap<>();

        if (!leads.isEmpty()) {

            List<Integer> leadIds = leads.stream().map(Lead::getId).collect(Collectors.toList());

            leadActivityMap = leadActivityRepository.selectAllByleadIds(leadIds).stream()

                    .collect(Collectors.groupingBy(LeadActivity::getLeadId));

            List<Integer> authIds = leads.stream().map(Lead::getAssignTo).collect(Collectors.toList());

            authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream()

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

        }

        // Build CSV rows (USE DIRECT LEAD PROPERTIES - NO ACTIVITY FALLBACK)

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

        for (Lead lead : leads) {

            List<LeadActivity> activities = leadActivityMap.get(lead.getId());

            // Use FIRST activity's schedule timestamp if exists

            String scheduleTimestamp = (activities != null && !activities.isEmpty())

                    ? FormattingUtils.format(activities.get(0).getSchelduleTimestamp())

                    : "";

            // DIRECTLY use Lead properties (NO fallback to activity)

            Double potential = lead.getPotential();

            String outLetName = lead.getOutLetName() != null ? lead.getOutLetName() : "";

            // Assignee name (blank if missing)

            String assignTo = "";

            if (authIdAndAuthUserMap.containsKey(lead.getAssignTo())) {

                AuthUser user = authIdAndAuthUserMap.get(lead.getAssignTo());

                assignTo = (user.getFirstName() + " " + user.getLastName()).trim();

            }

            rows.add(Arrays.asList(

                    lead.getId(),

                    lead.getSource(),

                    lead.getFullName(),

                    outLetName,

                    potential,

                    lead.getLeadMobile(),

                    lead.getAddress() != null ? lead.getAddress() : "",

                    lead.getCity() != null ? lead.getCity() : "",

                    lead.getState() != null ? lead.getState() : "",

                    lead.getCreatedBy() != null ? lead.getCreatedBy() : "",

                    lead.getStatus().toString(),

                    FormattingUtils.format(lead.getCreatedTimestamp()),

                    FormattingUtils.format(lead.getUpdatedTimestamp()),

                    scheduleTimestamp,

                    lead.getClosureTimestamp() != null

                            ? FormattingUtils.format(lead.getClosureTimestamp())

                            : "",  // Handle null closure

                    assignTo,

                    lead.getColor() != null ? lead.getColor() : ""

            ));

        }

        // Generate CSV response

        ByteArrayOutputStream baos = FileUtil.getCSVByteStream(

                Arrays.asList("Id", "Source", "Partner Name", "Outlet Name", "Potential", "Mobile", "Address", "City", "State",

                        "Created By", "Status", "Created On", "Updated On", "Scheduled Timestamp",

                        "Closure Timestamp", "Assign To", "Color"),

                rows

        );

        return orderService.downloadReportInCsv(baos, rows, "LeadDetails_");

    }

    @RequestMapping(value = "/getClosedLead", method = RequestMethod.GET)

    public String getClosedLead(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model) throws Exception {

        List<AuthUser> authUsers = authRepository.selectAllActiveUser();

        List<Lead> leads = null;

        long size = 0;

        leads = leadRepository.selectAllByStatus(status, offset, limit);

        size = leadRepository.selectCountByStatus(status);

        if (!leads.isEmpty()) {

            List<Integer> authIds = new ArrayList<>();

            for (Lead lead : leads) {

                authIds.add(lead.getAssignTo());

            }

            Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

            model.addAttribute("leads", leads);

            model.addAttribute("start", offset + 1);

            model.addAttribute("size", size);

            model.addAttribute("searchTerm", searchTerm);

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

            model.addAttribute("url", "/getPaginatedClosedLeads");

            if (leads.size() < limit) {

                model.addAttribute("end", offset + leads.size());

            } else {

                model.addAttribute("end", offset + limit);

            }

        } else {

            model.addAttribute("lead", leads);

            model.addAttribute("size", size);

        }

        model.addAttribute("authUsers", authUsers);

        return "lead-close";

    }

    @RequestMapping(value = "/getPaginatedClosedLeads", method = RequestMethod.GET)

    public String getPaginatedClosedLeads(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, Model model) throws ProfitMandiBusinessException {

        List<Lead> leads = null;

        leads = leadRepository.selectAllByStatus(status, offset, limit);

        if (!leads.isEmpty()) {

            List<Integer> authIds = new ArrayList<>();

            for (Lead lead : leads) {

                authIds.add(lead.getAssignTo());

            }

            Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

            model.addAttribute("leads", leads);

            model.addAttribute("url", "/getPaginatedClosedLeads");

        } else {

            model.addAttribute("leads", leads);

        }

        return "lead-close-paginated";

    }

    @RequestMapping(value = "/searchLeads")

    public String getClosedLeads(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model) throws ProfitMandiBusinessException {

        List<AuthUser> authUsers = authRepository.selectAllActiveUser();

        List<Lead> leads = null;

        long size = 0;

        if (!(searchTerm.equals(""))) {

            leads = leadRepository.selectBySearchTerm(status, searchTerm, offset, limit);

            size = leadRepository.selectCountByStatus(status);

            Map<Integer, AuthUser> authIdAndAuthUserMap = new HashMap<>();

            List<Integer> authIds = new ArrayList<>();

            if (!(leads.size() == 0)) {

                for (Lead lead : leads) {

                    authIds.add(lead.getAssignTo());

                }

                authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                if (leads.size() < limit) {

                    model.addAttribute("end", offset + leads.size());

                } else {

                    model.addAttribute("end", offset + limit);

                }

            } else {

                model.addAttribute("end", offset + limit);

            }

            model.addAttribute("leads", leads);

            model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

            model.addAttribute("start", offset + 1);

            model.addAttribute("size", size);

            model.addAttribute("searchTerm", searchTerm);

        } else {

            leads = leadRepository.selectAllByStatus(status, offset, limit);

            size = leadRepository.selectCountByStatus(status);

            if (!leads.isEmpty()) {

                List<Integer> authIds = new ArrayList<>();

                for (Lead lead : leads) {

                    authIds.add(lead.getAssignTo());

                }

                Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                model.addAttribute("leads", leads);

                model.addAttribute("start", offset + 1);

                model.addAttribute("size", size);

                model.addAttribute("searchTerm", searchTerm);

                model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

                if (leads.size() < limit) {

                    model.addAttribute("end", offset + leads.size());

                } else {

                    model.addAttribute("end", offset + limit);

                }

            }

        }

        model.addAttribute("authUsers", authUsers);

        return "lead-close";

    }

    @RequestMapping(value = "/searchLeadPaginated")

    public String searchLeadPaginated(HttpServletRequest request, @RequestParam(name = "offset", defaultValue = "0") int offset, @RequestParam(name = "limit", defaultValue = "10") int limit, @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm, Model model) throws ProfitMandiBusinessException {

        LOGGER.info("In search Item....");

        List<Lead> leads = null;

        if (!searchTerm.equals("")) {

            leads = leadRepository.selectBySearchTerm(status, searchTerm, offset, limit);

            if (!(leads.size() == 0)) {

                List<Integer> authIds = new ArrayList<>();

                for (Lead lead : leads) {

                    authIds.add(lead.getAssignTo());

                }

                Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream().collect(Collectors.toMap(x -> x.getId(), x -> x));

                model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

                model.addAttribute("leads", leads);

            }

        }

        return "lead-close-paginated";

    }

    // Global lead search box: find ANY lead by name / mobile / outlet / city, no date filter needed.

    @RequestMapping(value = "/globalLeadSearch")

    public String globalLeadSearch(HttpServletRequest request,

                                   @RequestParam(name = "searchTerm", required = false, defaultValue = "") String searchTerm,

                                   Model model) {

        List<Lead> leads = new ArrayList<>();

        if (!searchTerm.trim().isEmpty()) {

            leads = leadRepository.selectByGlobalSearch(searchTerm.trim(), 200);

            if (!leads.isEmpty()) {

                List<Integer> authIds = leads.stream().map(Lead::getAssignTo).collect(Collectors.toList());

                Map<Integer, AuthUser> authIdAndAuthUserMap = authRepository.selectByIds(authIds).stream()

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

                model.addAttribute("authIdAndAuthUserMap", authIdAndAuthUserMap);

            }

        }

        model.addAttribute("leads", leads);

        model.addAttribute("searchTerm", searchTerm);

        return "lead-close-paginated";

    }

    @RequestMapping(value = "/getLeadActivity", method = RequestMethod.GET)

    public String getLeadActivity(HttpServletRequest request, @RequestParam int leadId, Model model) throws Exception {

        List<LeadActivity> leadActivity = leadActivityRepository.selectBYLeadId(leadId);

        LOGGER.info("leadActivity" + leadActivity);

        model.addAttribute("leadActivity", leadActivity);

        model.addAttribute("authUserMap", authRepository.selectAllActiveUser().stream().collect(Collectors.toMap(x -> x.getId(), x -> x)));

        return "lead_activity_modal";

    }

    @RequestMapping(value = "/getLead", method = RequestMethod.GET)

    public ResponseEntity<?> getLead(HttpServletRequest request, @RequestParam int leadId) throws Exception {

        Lead lead = leadRepository.selectById(leadId);

        LeadDetail leadDetail = leadDetailRepository.selectByLeadId(lead.getId());

        if (leadDetail != null) {

            lead.setOutLetName(leadDetail.getOutletName());

        }

        return responseSender.ok(lead);

    }

    @RequestMapping(value = "/createLead", method = RequestMethod.POST)

    public String CreateLead(HttpServletRequest request, @RequestBody CreateRefferalRequest createRefferalRequest, Model model) throws Exception {

        LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);

        Lead leadDetails = leadRepository.selectByMobileNumber(createRefferalRequest.getMobile());

        LOGGER.info("Lead Details {}", leadDetails);

        if (leadDetails != null && leadDetails.getStatus() != LeadStatus.notInterested) {

            AuthUser authUser1 = authRepository.selectById(leadDetails.getAssignTo());

            model.addAttribute("response1", "Lead already exists, created by " + leadDetails.getCreatedBy() +

                    " on " + FormattingUtils.format(leadDetails.getCreatedTimestamp()) +

                    ", assigned to " + authUser1.getFullName());

            return "response";

        }