Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.mongodb.DBObject;

import com.spice.profitmandi.common.enumuration.ActivationType;

import com.spice.profitmandi.common.enumuration.MessageType;

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.entity.cs.Activity;

import com.spice.profitmandi.dao.entity.cs.Position;

import com.spice.profitmandi.dao.entity.cs.Ticket;

import com.spice.profitmandi.dao.entity.dtr.User;

import com.spice.profitmandi.dao.entity.dtr.UserAccount;

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

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

import com.spice.profitmandi.dao.enumuration.auth.CollectionRemark;

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.spice.profitmandi.dao.repository.user.AddressRepository;

import com.spice.profitmandi.service.AuthService;

import com.spice.profitmandi.service.NotificationService;

import com.spice.profitmandi.service.PartnerCollectionService;

import com.spice.profitmandi.service.integrations.kommuno.RecordingService;

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

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

import com.spice.profitmandi.web.req.CreateFranchiseeRequest;

import com.spice.profitmandi.web.req.RbmSalesRatingRequest;

import com.spice.profitmandi.web.res.Partner;

import io.swagger.annotations.ApiImplicitParam;

import io.swagger.annotations.ApiImplicitParams;

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.format.annotation.DateTimeFormat;

import org.springframework.http.HttpHeaders;

import org.springframework.http.HttpStatus;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.mail.javamail.JavaMailSender;

import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.Model;

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

import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;

import java.io.IOException;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.YearMonth;

import java.time.format.DateTimeFormatter;

import java.time.temporal.TemporalAdjusters;

import java.util.*;

import java.util.HashSet;

import java.util.Map.Entry;

import java.util.concurrent.ThreadLocalRandom;

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. */

    private static final String AI_LEAD_SOURCE = "AI Assistant";

    /**

     * Assignee used for AI leads only when no active BGC L1 can be resolved from cs.position.

     * Same auth id the web capture has always routed to, so intake never fails on an empty pool.

     */

    private static final int AI_LEAD_FALLBACK_ASSIGNEE = 53;

    @Autowired

    private ResponseSender<?> responseSender;

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

    private String aiLeadIntakeToken;

    @Autowired

    private AuthRepository authRepository;

    @Autowired

    private LeadRepository leadRepository;

    @Autowired

    private com.spice.profitmandi.dao.service.lead.LeadCreationService leadCreationService;

    @Autowired

    DocumentRepository documentRepository;

    @Autowired

    PositionRepository positionRepository;

    @Autowired

    private ActivityAttachmentRepository activityAttachmentRepository;

    @Autowired

    private CsService csService;

    @Autowired

    private DemoPartnerAccessService demoPartnerAccessService;

    @Autowired

    private UserRepository userRepository;

    @Autowired

    private AddressRepository addressRepository;

    @Autowired

    private UserRoleRepository userRoleRepository;

    @Autowired

    private UserAccountRepository userAccountRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.user.UserRepository userUserRepository;

    @Autowired

    private RetailerService retailerService;

    @Autowired

    private LeadActivityRepository leadActivityRepository;

    @Autowired

    private FranchiseeVisitRepository franchiseeVisitRepository;

    @Autowired

    private FranchiseeActivityRepository franchiseeActivityRepository;

    @Autowired

    private PartnerOnBoardingPanelRepository partnerOnBoardingPanelRepository;

    @Autowired

    private FofoStoreRepository fofoStoreRepository;

    @Autowired

    private StoreTimelineTatService storeTimelineTatService;

    @Autowired

    private PartnerCollectionService partnerCollectionService;

    @Autowired

    private TicketRepository ticketRepository;

    @Autowired

    private ActivityRepository activityRepository;

    @Autowired

    private TicketCategoryRepository ticketCategoryRepository;

    @Autowired

    private TicketSubCategoryRepository ticketSubCategoryRepository;

    @Autowired

    private PartnerCollectionRemarkRepository partnerCollectionRemarkRepository;

    @Autowired

    private Mongo mongoClient;

    @Autowired

    private OrderRepository orderRepository;

    @Autowired

    private PartnerCollectionPlanRepository partnerCollectionPlanRepository;

    @Autowired

    private PartnerSecondaryPlanRepository partnerSecondaryPlanRepository;

    @Autowired

    private PartnerDailyInvestmentRepository partnerDailyInvestmentRepository;

    @Autowired

    private VisitRequestRepository visitRequestRepository;

    @Autowired

    private AuthService authService;

    @Autowired

    private NotificationService notificationService;

    @Autowired

    JavaMailSender gmailRelaySender;

    @Autowired

    private TicketAssignedRepository ticketAssignedRepository;

    @Autowired

    LeadDetailRepository leadDetailRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.BeatRepository beatRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.BeatScheduleRepository beatScheduleRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.BeatRouteRepository beatRouteRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.LeadRouteRepository leadRouteRepository;

    @Autowired

    private com.spice.profitmandi.dao.repository.dtr.LeadLiveLocationRepository leadLiveLocationRepository;

    @Autowired

    PurchaseRepository purchaseRepository;

    @Autowired

    private LoanRepository loanRepository;

    @Autowired

    private RecordingService recordingService;

    // Field-staff creates a lead from the planner — they're physically at the lead's

    // location, so we mark the geo APPROVED immediately (no link-and-approve cycle).

    @RequestMapping(value = "/lead-geo/self-approve", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({

            @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> selfApproveLeadGeo(javax.servlet.http.HttpServletRequest request,

                                                @RequestBody Map<String, Object> req) throws Exception {

        Integer leadId = req.get("leadId") instanceof Number ? ((Number) req.get("leadId")).intValue() : null;

        if (leadId == null || leadId <= 0) return responseSender.badRequest("leadId required");

        Object latObj = req.get("latitude"), lngObj = req.get("longitude");

        if (!(latObj instanceof Number) || !(lngObj instanceof Number)) return responseSender.badRequest("latitude/longitude required");

        double latitude = ((Number) latObj).doubleValue();

        double longitude = ((Number) lngObj).doubleValue();

        Lead lead = leadRepository.selectById(leadId);

        if (lead == null) return responseSender.badRequest("Lead not found");

        // Resolve approver from session, fall back to request body.

        int approverAuthId = 0;

        com.spice.profitmandi.common.model.UserInfo userInfo =

                (com.spice.profitmandi.common.model.UserInfo) request.getAttribute("userInfo");

        if (userInfo != null && userInfo.getEmail() != null) {

            AuthUser sessionAuth = authRepository.selectByGmailId(userInfo.getEmail());

            if (sessionAuth != null) approverAuthId = sessionAuth.getId();

        }

        if (approverAuthId == 0 && req.get("authUserId") instanceof Number) {

            approverAuthId = ((Number) req.get("authUserId")).intValue();

        }

        int imageDocumentId = 0;

        if (req.get("imageDocumentId") instanceof Number) {

            imageDocumentId = ((Number) req.get("imageDocumentId")).intValue();

        }

        LocalDateTime now = LocalDateTime.now();

        com.spice.profitmandi.dao.entity.user.LeadLiveLocation existing = leadLiveLocationRepository.selectByLeadId(leadId);

        if (existing != null) {

            existing.setLatitude(latitude);

            existing.setLongitude(longitude);

            existing.setStatus(com.spice.profitmandi.dao.enumuration.dtr.GeoLocationStatus.APPROVED);

            existing.setReviewedBy(approverAuthId);

            existing.setReviewedTimestamp(now);

            existing.setSubmissionCount(existing.getSubmissionCount() + 1);

            existing.setMobileNumber(lead.getLeadMobile());

            if (imageDocumentId > 0) existing.setImageDocumentId(imageDocumentId);

            existing.setUpdatedTimestamp(now);

            existing.setRemark("Self-approved by field creator");

        } else {

            com.spice.profitmandi.dao.entity.user.LeadLiveLocation loc = new com.spice.profitmandi.dao.entity.user.LeadLiveLocation();

            loc.setLeadId(leadId);

            loc.setLatitude(latitude);

            loc.setLongitude(longitude);

            loc.setMobileNumber(lead.getLeadMobile());

            loc.setImageDocumentId(imageDocumentId);

            loc.setStatus(com.spice.profitmandi.dao.enumuration.dtr.GeoLocationStatus.APPROVED);

            loc.setReviewedBy(approverAuthId);

            loc.setReviewedTimestamp(now);

            loc.setSubmissionCount(1);

            loc.setRemark("Self-approved by field creator");

            loc.setCreatedTimestamp(now);

            loc.setUpdatedTimestamp(now);

            leadLiveLocationRepository.persist(loc);

        }

        LeadActivity activity = new LeadActivity();

        activity.setLeadId(leadId);

        activity.setRemark("Geolocation self-approved by field creator");

        activity.setAuthId(approverAuthId);

        activity.setCreatedTimestamp(now);

        leadActivityRepository.persist(activity);

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

        result.put("status", "approved");

        result.put("leadId", leadId);

        return responseSender.ok(result);

    }

    // Returns the field-staff person's upcoming beat-day chips (today + next N days) so

    // the partner app can present "Schedule on today vs future" right after a self-create.

    // The auth user is resolved from the session — matches the existing

    // BeatTrackingController.listBeats pattern (the client `userId` is unreliable).

    public ResponseEntity<?> upcomingBeatsForUser(javax.servlet.http.HttpServletRequest request, int days) throws Exception {

        com.spice.profitmandi.common.model.UserInfo userInfo =

                (com.spice.profitmandi.common.model.UserInfo) request.getAttribute("userInfo");

        if (userInfo == null || userInfo.getEmail() == null) {

            return responseSender.badRequest("Auth session not found");

        }

        AuthUser authUser = authRepository.selectByGmailId(userInfo.getEmail());

        if (authUser == null) return responseSender.badRequest("Auth user not found");

        int authUserId = authUser.getId();

        LOGGER.info("upcomingBeatsForUser resolved authUserId={} from session email={}", authUserId, userInfo.getEmail());

        LocalDate today = LocalDate.now();

        LocalDate end = today.plusDays(days);

        List<com.spice.profitmandi.dao.entity.user.Beat> beats = beatRepository.selectActiveByAuthUserId(authUserId);

        List<Map<String, Object>> out = new ArrayList<>();

        for (com.spice.profitmandi.dao.entity.user.Beat b : beats) {

            List<com.spice.profitmandi.dao.entity.user.BeatSchedule> schedules =

                    beatScheduleRepository.selectByBeatIdAndDateRange(b.getId(), today, end);

            for (com.spice.profitmandi.dao.entity.user.BeatSchedule s : schedules) {

                if (s.getStartDate() == null || s.getStartDate().getYear() == 9999) continue;

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

                row.put("beatId", b.getId());

                row.put("beatName", b.getName());

                row.put("beatColor", b.getBeatColor());

                row.put("scheduleDate", s.getStartDate().toString());

                row.put("dayNumber", s.getDayNumber());

                row.put("isToday", today.equals(s.getStartDate()));

                out.add(row);

            }

        }

        out.sort(Comparator.comparing(r -> (String) r.get("scheduleDate")));

        return responseSender.ok(out);

    }

    // Attaches a (just-created, self-approved) lead to a sales user's beat on a given

    // date. Inserts a LeadRoute row with status=APPROVED; idempotent on re-call.

    // The auth user is resolved from the session token, not the request body.

    public ResponseEntity<?> scheduleLeadOnBeat(javax.servlet.http.HttpServletRequest request,

                                                Map<String, Object> req) throws Exception {

        com.spice.profitmandi.common.model.UserInfo userInfo =

                (com.spice.profitmandi.common.model.UserInfo) request.getAttribute("userInfo");

        if (userInfo == null || userInfo.getEmail() == null) {

            return responseSender.badRequest("Auth session not found");

        }

        AuthUser sessionAuth = authRepository.selectByGmailId(userInfo.getEmail());

        if (sessionAuth == null) return responseSender.badRequest("Auth user not found");

        int authUserId = sessionAuth.getId();

        Integer leadId = req.get("leadId") instanceof Number ? ((Number) req.get("leadId")).intValue() : null;

        Integer beatId = req.get("beatId") instanceof Number ? ((Number) req.get("beatId")).intValue() : null;

        Object dateObj = req.get("scheduleDate");

        if (leadId == null || beatId == null || dateObj == null) {

            return responseSender.badRequest("leadId, beatId and scheduleDate are required");

        }

        LocalDate scheduleDate;

        try {

            scheduleDate = LocalDate.parse(dateObj.toString());

        } catch (Exception e) {

            return responseSender.badRequest("scheduleDate must be yyyy-MM-dd");

        }

        Lead lead = leadRepository.selectById(leadId);

        if (lead == null) return responseSender.badRequest("Lead not found");

        // Beat must actually run on the chosen date — same guard as the panel-side flow.

        List<com.spice.profitmandi.dao.entity.user.BeatSchedule> match =

                beatScheduleRepository.selectByBeatIdAndDateRange(beatId, scheduleDate, scheduleDate);

        if (match.isEmpty()) return responseSender.badRequest("Beat is not scheduled on " + scheduleDate);

        // Idempotency: skip if the same lead is already pinned to this beat-day.

        boolean exists = leadRouteRepository.selectByBeatId(beatId).stream()

                .anyMatch(lr -> lr.getLeadId() == leadId

                        && scheduleDate.equals(lr.getScheduleDate())

                        && !"CANCELLED".equals(lr.getStatus()));

        if (exists) {

            return responseSender.ok(Collections.singletonMap("status", "already_scheduled"));

        }

        // Append at the end of the day's existing stops.

        int seq = beatRouteRepository.selectByBeatId(beatId).size() + 1;

        com.spice.profitmandi.dao.entity.user.LeadRoute lr = new com.spice.profitmandi.dao.entity.user.LeadRoute();

        lr.setBeatId(beatId);

        lr.setLeadId(leadId);

        lr.setScheduleDate(scheduleDate);

        lr.setSequenceOrder(seq);

        lr.setStatus("APPROVED");

        lr.setRequestedBy(authUserId);

        lr.setApprovedBy(authUserId);

        LocalDateTime now = LocalDateTime.now();

        lr.setApprovedTimestamp(now);

        lr.setCreatedTimestamp(now);

        lr.setUpdatedTimestamp(now);

        leadRouteRepository.persist(lr);

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

        result.put("status", "scheduled");

        result.put("scheduleDate", scheduleDate.toString());

        return responseSender.ok(result);

    }

    @RequestMapping(value = "/lead", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({

            @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> LeadUser(@RequestBody CreateRefferalRequest createRefferalRequest) throws Exception {

        LOGGER.info("CreateReferralRequest - " + createRefferalRequest);

        if (createRefferalRequest.getOutletName() == null || createRefferalRequest.getPotential() == 0) {

            throw new Exception("Outlet should not be empty and potential should be greater > 0");

        }

        Lead lead;

        AuthUser authUser = authRepository.selectByGmailId(createRefferalRequest.getReffereeEmail());

        if (createRefferalRequest.getId() > 0) {

            lead = leadRepository.selectById(createRefferalRequest.getId());

            lead.setAssignTo(authUser.getId());

        } else {

            lead = new Lead();

            lead.setFirstName(createRefferalRequest.getFirstName());

            lead.setLastName(createRefferalRequest.getLastName());

            lead.setLeadMobile(createRefferalRequest.getMobile());

            lead.setState(createRefferalRequest.getState());

            lead.setCity(createRefferalRequest.getCity());

            lead.setAddress(createRefferalRequest.getAddress());

            lead.setCreatedTimestamp(LocalDateTime.now());

            lead.setOutLetName(createRefferalRequest.getOutletName());

            lead.setUpdatedTimestamp(LocalDateTime.now());

            lead.setStatus(createRefferalRequest.getStatus());

            lead.setSource(createRefferalRequest.getSource());

            lead.setNotinterestedReason(createRefferalRequest.getReason());

            lead.setPotential(createRefferalRequest.getPotential());

            if (createRefferalRequest.getColorCheck() == true) {

                lead.setColor("Green");

            } else {

                lead.setColor("Yellow");

            }

            String authUserName = authUser.getFullName();

            lead.setAuthId(authUser.getId());

            lead.setAssignTo(authUser.getId());

            lead.setCreatedBy(authUserName);

            // One workable lead per number -- see LeadCreationService.

            leadCreationService.create(lead, authUser.getId(), createRefferalRequest.isOverrideDuplicate());

        }

        LeadActivity leadActivity = new LeadActivity();

        leadActivity.setLeadId(lead.getId());

        leadActivity.setRemark((createRefferalRequest.getId() > 0 ? "Self Assigned." : "") + createRefferalRequest.getRemark());

        leadActivity.setAuthId(authUser.getId());

        if (createRefferalRequest.getStatus().equals(LeadStatus.followUp)) {

            leadActivity.setSchelduleTimestamp(createRefferalRequest.getSchelduleTimestamp());

            leadActivity.setCommunicationType(createRefferalRequest.getCommunicationType());

            if (leadActivity.getCommunicationType().equals(CommunicationType.VISIT)) {

                visitRequestRepository.createVisitRequest(lead.getId(), "lead", lead.getAssignTo(),

                        createRefferalRequest.getSchelduleTimestamp());

            }

            //

            leadActivity.setClosureTimestamp(createRefferalRequest.getClosureTimestamp());

            lead.setClosureTimestamp(createRefferalRequest.getClosureTimestamp());

        } else {

            leadActivity.setSchelduleTimestamp(null);

            leadActivity.setClosureTimestamp(null);

            lead.setClosureTimestamp(null);

        }

        leadActivity.setCreatedTimestamp(LocalDateTime.now());

        leadActivityRepository.persist(leadActivity);

        // Return the new lead's id alongside the legacy `success: true` flag so callers

        // that need to chain follow-up actions (e.g., the partner app's self-create →

        // self-approve geo → schedule on beat flow) can do so without an extra lookup.

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

        body.put("success", true);

        body.put("leadId", lead.getId());

        return responseSender.ok(body);

    }

    @RequestMapping(value = "/lead-description", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({

            @ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> leadDescription(HttpServletRequest request, @RequestParam(name = "gmailId") String

                                                     gmailId,

                                             @RequestParam(name = "status") LeadStatus status) throws ProfitMandiBusinessException {

        AuthUser authUser = authRepository.selectByGmailId(gmailId);

        List<Lead> leads = null;

        LOGGER.info("emails" + status);

        List<VisitRequest> visitRequests = visitRequestRepository.selectByAuthIdAndDate(authUser.getId(),

                LocalDate.now());

        Map<Integer, List<VisitRequest>> visitRequestMap = null;

        if (!visitRequests.isEmpty()) {

            visitRequestMap = visitRequests.stream().collect(Collectors.groupingBy(x -> x.getVisitId()));

        }

        // Hierarchy expansion (Sales only):

        //   L1 → just self

        //   L2 → self + every L1 reportee

        //   L3 → self + L1 + L2 reportees

        //   L4 → self + L1 + L2 + L3 reportees

        // Non-Sales callers stay at "just self" — same as today.

        List<Integer> visibleAuthIds = visibleAuthIdsForLeads(authUser.getId());

        if (status.equals(LeadStatus.followUp)) {

            // Show every lead assigned to the caller (or downline for Sales heads)

            // whose status is followUp. The old call,

            //   selectLeadsScheduledBetweenDate(visibleAuthIds, null, null)

            // silently dropped any lead whose LATEST lead_activity row did not

            // carry a schedule_timestamp — which excludes leads that were

            // assigned but never scheduled, and leads whose most recent activity

            // was a visit-request action (create / reject / reassign / cancel)

            // that doesn't set schedule_timestamp. Result: most assigned leads

            // disappeared from the mobile "All Leads → Follow Up" tab.

            leads = leadRepository.selectByAssignAuthIdsAndStatus(visibleAuthIds, LeadStatus.followUp);

            // Hydrate Lead.scheduledTimestamp for the card date + sort order.

            // One batched lookup: lead_id → latest non-null schedule_timestamp.

            // Leads with no scheduled activity get null (still shown, just no date).

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

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

                Map<Integer, LocalDateTime> scheduleByLead =

                        leadActivityRepository.latestScheduleTimestampByLeadIds(leadIds);

                leads.forEach(l -> l.setScheduledTimestamp(scheduleByLead.get(l.getId())));

            }

            if (visitRequestMap != null) {

                for (Lead lead : leads) {

                    List<VisitRequest> visitRequest = visitRequestMap.get(lead.getId());

                    if (visitRequest != null) {

                        if (visitRequest.size() > 1) {

                            Comparator<VisitRequest> visitComparato = Comparator

                                    .comparing(VisitRequest::getCreatedTimestamp);

                            VisitRequest youngestVisit = visitRequest.stream().max(visitComparato).get();

                            lead.setVisitStatus(youngestVisit.getStatus());

                        } else {

                            lead.setVisitStatus(visitRequest.get(0).getStatus());

                        }

                    }

                }

            }

            leads = leads.stream()

                    .sorted(Comparator.comparing(Lead::getScheduledTimestamp, Comparator.nullsFirst(Comparator.reverseOrder())))

                    .collect(Collectors.toList());

            /*

             * Collections.sort(leads, (o1, o2) -> { if (o1.getScheduledTimestamp() != null

             * && o2.getScheduledTimestamp() != null) { return

             * o1.getScheduledTimestamp().isBefore(o2.getScheduledTimestamp()) ? -1 : 1; }

             * else if (o1.getScheduledTimestamp() != null) { return 1; } else { return -1;

             * } });

             */

        } else {

            // Same hierarchy expansion as the followUp branch — Sales heads see their

            // downline's leads alongside their own.

            leads = leadRepository.selectByAssignAuthIdsAndStatus(visibleAuthIds, status);

        }

        return responseSender.ok(leads);

    }

    // Returns the auth-user IDs whose leads are visible to `authUserId` on the

    // mobile "My Leads" screen. Sales heads see their full downline; everyone

    // else (incl. non-Sales) sees only themselves.

    private List<Integer> visibleAuthIdsForLeads(int authUserId) {

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

        ids.add(authUserId);

        EscalationType highestSales = null;

        try {

            for (Position p : positionRepository.selectPositionByAuthId(authUserId)) {

                if (p.getCategoryId() == ProfitMandiConstants.TICKET_CATEGORY_SALES) {

                    if (highestSales == null || p.getEscalationType().isGreaterThanEqualTo(highestSales)) {

                        highestSales = p.getEscalationType();

                    }

                }

            }

        } catch (Exception ignored) {

        }

        // Only sales heads (L2+) get the downline expansion. L1 / non-Sales stay at self.

        if (highestSales != null && highestSales.isGreaterThanEqualTo(EscalationType.L2)) {

            try {

                List<Integer> reportees = authService.getAllReportees(authUserId);

                if (reportees != null) {

                    for (Integer r : reportees) {

                        if (r != null && !ids.contains(r)) ids.add(r);

                    }

                }

            } catch (Exception ignored) {

            }

        }

        return ids;

    }

    @RequestMapping(value = "/getlead", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> getLead(HttpServletRequest request, @RequestParam(name = "id") int id) throws

            ProfitMandiBusinessException {

        List<LeadActivity> leadActivities = leadActivityRepository.selectBYLeadId(id);

        Lead lead = leadRepository.selectById(id);

        lead.setLeadActivities(leadActivities);

        return responseSender.ok(lead);

    }

    @RequestMapping(value = "/check-existing-lead", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> getLeadByMobile(HttpServletRequest request, @RequestParam(name = "mobile") String

            mobile) throws ProfitMandiBusinessException {

        int userId = (int) request.getAttribute("userId");

        LOGGER.info("userId: " + userId);

        Lead lead = leadRepository.selectByMobileNumber(mobile);

        return responseSender.ok(lead);

    }

    @RequestMapping(value = "/leadUpdate", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> leadUpdate(HttpServletRequest request, @RequestParam(name = "id") int id,

                                        @RequestParam(name = "status") LeadStatus status, @RequestParam(name = "colorCheck") Boolean colorCheck,

                                        @RequestParam(name = "remark") String remark, @RequestParam(name = "reason") String reason,

                                        @RequestParam(name = "schelduleTimestamp") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime schelduleTimestamp,

                                        @RequestParam(name = "closureTimestamp") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) LocalDateTime closureTimestamp,

                                        @RequestParam(name = "communicationType") CommunicationType communicationType) throws

            ProfitMandiBusinessException {

        Lead lead = leadRepository.selectById(id);

        LeadActivity leadActivity = new LeadActivity();

        lead.setStatus(status);

        lead.setNotinterestedReason(reason);

        leadActivity.setRemark(remark);

        leadActivity.setLeadId(id);

        leadActivity.setOutletName(lead.getOutLetName());

        leadActivity.setPotential(lead.getPotential());

        leadActivity.setCreatedTimestamp(LocalDateTime.now());

        leadActivity.setSchelduleTimestamp(null);

        leadActivity.setClosureTimestamp(null);

        leadActivity.setAuthId(lead.getAssignTo());

        lead.setUpdatedTimestamp(LocalDateTime.now());

        if (colorCheck == true) {

            lead.setColor("Green");

        } else {

            lead.setColor("Yellow");

        }

        if (status == LeadStatus.followUp) {

            if (schelduleTimestamp != null) {

                leadActivity.setCommunicationType(communicationType);

                if (leadActivity.getCommunicationType().equals(CommunicationType.VISIT)) {

                    visitRequestRepository.createVisitRequest(lead.getId(), "lead", lead.getAssignTo(), schelduleTimestamp);

                }

            }

            leadActivity.setSchelduleTimestamp(schelduleTimestamp);

            leadActivity.setClosureTimestamp(closureTimestamp);

            lead.setClosureTimestamp(closureTimestamp);

        } else {

            leadActivity.setSchelduleTimestamp(null);

            leadActivity.setClosureTimestamp(null);

            lead.setClosureTimestamp(null);

        }

        leadActivityRepository.persist(leadActivity);

        return responseSender.ok(true);

    }

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

    public ResponseEntity<?> newLead(HttpServletRequest request, @RequestBody CreateRefferalRequest

            createRefferalRequest) throws ProfitMandiBusinessException {

        LOGGER.info("requested url : " + request.getRequestURL().toString());

        Lead lead = new Lead();

        lead.setAddress(createRefferalRequest.getCity());

        Long.parseLong(createRefferalRequest.getMobile());

        if (createRefferalRequest.getMobile().length() != 10) {

            throw new ProfitMandiBusinessException("Mobile Number", createRefferalRequest.getMobile(), "Number should be of 10 digits");

        }

        lead.setLeadMobile(createRefferalRequest.getMobile());

        lead.setCity(createRefferalRequest.getCity());

        lead.setState(createRefferalRequest.getState());

        lead.setLastName(createRefferalRequest.getLastName());

        if (lead.getState().equals("Uttar Pradesh")) {

            lead.setAssignTo(53);

        } else if (lead.getState().equals("Haryana")) {

            lead.setAssignTo(53);

        } else if (lead.getState().equals("Delhi")) {

            lead.setAssignTo(53);

        } else {

            // Assign to sm

            lead.setAssignTo(53);

            // Assign to neha

            // lead.setAssignTo(1);

        }

        lead.setAuthId(lead.getAssignTo());

        lead.setCreatedBy("daily-sync");

        lead.setSource("SD-WEB");

        lead.setFirstName(createRefferalRequest.getFirstName());

        lead.setStatus(LeadStatus.followUp);

        lead.setColor("yellow");

        lead.setCreatedTimestamp(LocalDateTime.now());

        lead.setUpdatedTimestamp(LocalDateTime.now());

        // Unattended: SD-WEB capture has no interactive user to offer an override to.

        leadCreationService.createUnattended(lead);

        return responseSender.ok(true);

    }

    /**

     * Intake endpoint for leads captured by the AI assistant (chat + voice flows, external system).

     * <p>

     * The source is stamped server-side as {@value #AI_LEAD_SOURCE} so the caller cannot spoof it.

     * Authenticated with a shared secret sent in the standard {@code Auth-Token} header; this path is

     * excluded from the JWT {@code AuthenticationInterceptor} (see WebMVCConfig) so the secret is not

     * treated as a user token. The call is idempotent: the AI side fires fire-and-forget with retry,

     * so a repeat POST for a mobile that already has an AI lead returns OK without creating a

     * duplicate. Leads from other sources (SD-WEB, manual) for the same mobile do not block creation.

     */

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

    public ResponseEntity<?> aiLead(HttpServletRequest request,

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

                                    @RequestBody AiLeadRequest aiLeadRequest)

            throws ProfitMandiBusinessException {

        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 responseSender.unauthorized(null);

        }

        // Normalise mobile to the 10-digit number the lead table stores (mobile column is length 10).

        // The AI side sends digits-only 10-12 chars; strip any stray non-digits and drop a leading

        // country code (e.g. 91) when present.

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

            throw new ProfitMandiBusinessException("Mobile Number", String.valueOf(rawMobile),

                    "Mobile number must contain 10 digits");

        }

        String firstName = aiLeadRequest.getFirstName();

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

            throw new ProfitMandiBusinessException("First Name", firstName, "First name is required");

        }

        // Idempotency: scoped to AI leads only - the AI side retries fire-and-forget posts. A lead

        // for the same mobile under another source (e.g. SD-WEB, manual) does NOT block creation.

        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 responseSender.ok(existing.getId());

        }

        Lead lead = new Lead();

        lead.setLeadMobile(mobile);

        lead.setFirstName(firstName.trim());

        // last_name / city / address / state are NOT NULL (no default) in user.lead; a minimal

        // name+number lead from the AI omits them, so coalesce nulls to "" to avoid an insert crash.

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

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

        lead.setCity(city);

        lead.setOutLetName(aiLeadRequest.getOutletName());

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

        lead.setAddress(city);

        // AI now sends state (auto-detected from the city; may be absent). Column is NOT NULL - coalesce to "".

        String state = aiLeadRequest.getState();

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

        // Source is stamped server-side; the caller cannot override it

        lead.setSource(AI_LEAD_SOURCE);

        lead.setCreatedBy(AI_LEAD_SOURCE);

        // "NEW" in the AI contract maps to the standard open-lead status (same as web capture) so the

        // lead lands in the Open / New leads view, not the separate follow-up bucket.

        lead.setStatus(LeadStatus.pending);

        lead.setColor("yellow");

        // Optional call-recording URL - voice leads only. Store null when absent so chat leads stay empty.

        String recordingUrl = aiLeadRequest.getRecordingUrl();

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

            lead.setRecordingUrl(recordingUrl.trim());

        }

        // Auto-assign to a randomly picked active BGC L1 so AI leads spread across the lead desk

        lead.setAssignTo(resolveAiLeadAssignee());

        lead.setAuthId(lead.getAssignTo());

        lead.setCreatedTimestamp(LocalDateTime.now());

        lead.setUpdatedTimestamp(LocalDateTime.now());

        // Unattended: the AI intake is a bot; a collision is skipped and mailed, not thrown.

        leadCreationService.createUnattended(lead);

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

        return responseSender.ok(lead.getId());

    }

    /**

     * Picks the owner for an incoming AI lead: a uniformly random <b>active</b> BGC L1 from

     * cs.position (category {@link ProfitMandiConstants#TICKET_CATEGORY_BGC}, escalation L1).

     * <p>

     * BGC is the desk that works AI/inbound leads before they reach field sales, and BGC L1-L3 is

     * already one of the groups offered in the Lead Management "Assign To" list, so a BGC L1 owner

     * is a valid assignee the team can see and reassign. Field Sales (category

     * {@link ProfitMandiConstants#TICKET_CATEGORY_SALES}) is deliberately NOT the pool here.

     * <p>

     * Inactive users are filtered out because {@code getAuthUserByCategoryId(int, EscalationType)}

     * does not filter on active, and an inactive owner would strand the lead. Ids are already

     * distinct per user, so holding several regional positions does not raise a person's odds.

     */

    private int resolveAiLeadAssignee() {

        List<AuthUser> bgcL1 = csService.getAuthUserByCategoryId(

                ProfitMandiConstants.TICKET_CATEGORY_BGC, EscalationType.L1);

        List<AuthUser> eligible = bgcL1 == null ? Collections.<AuthUser>emptyList()

                : bgcL1.stream()

                        .filter(x -> Boolean.TRUE.equals(x.isActive()))

                        .collect(Collectors.toList());

        if (eligible.isEmpty()) {

            LOGGER.warn("AI lead intake: no active BGC L1 in cs.position, falling back to auth id {}",

                    AI_LEAD_FALLBACK_ASSIGNEE);

            return AI_LEAD_FALLBACK_ASSIGNEE;

        }

        AuthUser assignee = eligible.get(ThreadLocalRandom.current().nextInt(eligible.size()));

        LOGGER.info("AI lead intake: assigned to BGC L1 {} ({}) picked from {} eligible",

                assignee.getId(), assignee.getFullName(), eligible.size());

        return assignee.getId();

    }

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

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> getPartners(HttpServletRequest request, @RequestParam(name = "gmailId") String gmailId)

            throws ProfitMandiBusinessException {

        AuthUser authUser = authRepository.selectByGmailId(gmailId);

        if (authUser == null) {

            LOGGER.warn("No auth user found for gmailId: {}", gmailId);

            return responseSender.badRequest("No user found for the provided email");

        }

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

        // Copy: the mapping is a shared cached object and must not carry demo partners.

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

        if (storeGuyMap.get(authUser.getEmailId()) != null) {

            emails.addAll(storeGuyMap.get(authUser.getEmailId()));

        }

        emails.addAll(demoPartnerAccessService.getDemoPartnerEmails(authUser.getId()));

        LOGGER.info("emails: {}", emails);

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

            LOGGER.info("No partner emails found for user: {}", gmailId);

            return responseSender.ok(new ArrayList<>());

        }

        List<User> users = userRepository.selectAllByEmailIds(new ArrayList<>(emails));

        List<Partner> partners = new ArrayList<>();

        for (User user : users) {

            try {

                UserAccount uc = userAccountRepository.selectSaholicByUserId(user.getId());

                if (uc == null) {

                    LOGGER.warn("No user account found for userId: {}", user.getId());

                    continue;

                }

                com.spice.profitmandi.dao.entity.user.User userInfo = userUserRepository.selectById(uc.getAccountKey());

                if (userInfo == null) {

                    LOGGER.warn("No user info found for accountKey: {}", uc.getAccountKey());

                    continue;

                }

                CustomRetailer customRetailer = retailerService.getFofoRetailer(userInfo.getId());

                if (customRetailer == null) {

                    LOGGER.warn("No custom retailer found for userInfoId: {}", userInfo.getId());

                    continue;

                }

                Partner partner = new Partner();

                partner.setBusinessName(customRetailer.getBusinessName());

                partner.setPartnerId(customRetailer.getPartnerId());

                partner.setCartId(customRetailer.getCartId());

                partner.setEmail(customRetailer.getEmail());

                partner.setGstNumber(customRetailer.getGstNumber());

                partner.setDisplayName(customRetailer.getDisplayName());

                partner.setCity(customRetailer.getAddress() != null ? customRetailer.getAddress().getCity() : null);

                partner.setUserId(user.getId());

                partners.add(partner);

            } catch (Exception e) {

                LOGGER.error("Error processing partner for userId: {}", user.getId(), e);

            }

        }

        LOGGER.info("partners: {}", partners);

        return responseSender.ok(partners);

    }

    @RequestMapping(value = "/franchise-first-visit", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

    @ApiImplicitParams({@ApiImplicitParam(name = "Auth-Token", value = "Auth-Token", required = true, dataType = "string", paramType = "header")})

    public ResponseEntity<?> FranchiseFirstVisit(HttpServletRequest request, @RequestBody CreateFranchiseeRequest

            createFranchiseeRequest) throws Exception {

        FranchiseeVisit franchiseeVisit = new FranchiseeVisit();

        franchiseeVisit.setFofoId(createFranchiseeRequest.getFofoId());

        CustomRetailer customRetailer = retailerService.getFofoRetailer(createFranchiseeRequest.getFofoId());

        franchiseeVisit.setPartnerName(customRetailer.getBusinessName());

        franchiseeVisit.setAgenda(createFranchiseeRequest.getAgenda());

        franchiseeVisit.setCreatedTimestamp(LocalDateTime.now());

        franchiseeVisit.setUpdatedTimestamp(LocalDateTime.now());

        franchiseeVisit.setStatus(FranchiseeVisitStatus.OPEN);

        franchiseeVisit.setScheduleTimestamp(createFranchiseeRequest.getFirstSchelduleTimestamp());

        // change

        AuthUser authUser = authRepository.selectByGmailId(createFranchiseeRequest.getCreatedBy());

        String authUserName = authUser.getFirstName() + " " + authUser.getLastName();

        franchiseeVisit.setCreatedBy(authUserName);

        franchiseeVisit.setAuthId(authUser.getId());

        franchiseeVisitRepository.persist(franchiseeVisit);

        FranchiseeActivity franchiseeActivity = new FranchiseeActivity();

        franchiseeActivity.setAction(FranchiseeActivityStatus.FOLLOWUP);

        franchiseeActivity.setFranchiseeVisitd(franchiseeVisit.getId());

        franchiseeActivity.setResolution(createFranchiseeRequest.getResolution());

        franchiseeActivity.setSchelduleTimestamp(createFranchiseeRequest.getFirstSchelduleTimestamp());

        franchiseeActivity.setCreatedTimestamp(LocalDateTime.now());

        franchiseeActivityRepository.persist(franchiseeActivity);

        franchiseeVisit.setFranchiseActivityId(franchiseeActivity.getId());

        visitRequestRepository.createVisitRequest(franchiseeVisit.getId(), "franchiseeVisit", authUser.getId(), createFranchiseeRequest.getFirstSchelduleTimestamp());

        return responseSender.ok(true);

    }