Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.common.model.CustomRetailer;
import com.spice.profitmandi.common.web.util.ResponseSender;
import com.spice.profitmandi.dao.entity.auth.AuthUser;
import com.spice.profitmandi.dao.entity.fofo.FofoStore;
import com.spice.profitmandi.dao.entity.logistics.PublicHolidays;
import com.spice.profitmandi.dao.entity.user.AuthUserLocation;
import com.spice.profitmandi.dao.entity.user.BeatPlan;
import com.spice.profitmandi.dao.entity.user.BeatPlanDay;
import com.spice.profitmandi.dao.enumuration.cs.EscalationType;
import com.spice.profitmandi.dao.repository.auth.AuthRepository;
import com.spice.profitmandi.dao.repository.cs.CsService;
import com.spice.profitmandi.dao.repository.dtr.*;
import com.spice.profitmandi.dao.repository.logistics.PublicHolidaysRepository;
import com.spice.profitmandi.service.user.RetailerService;
import com.spice.profitmandi.web.model.LoginDetails;
import com.spice.profitmandi.web.util.CookiesProcessor;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Type;
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

@Controller
@Transactional(rollbackFor = Throwable.class)
public class BeatPlanController {
        private static final Logger LOGGER = LogManager.getLogger(BeatPlanController.class);
        private static final String[] BEAT_COLORS = {
                        "#3498DB", "#E74C3C", "#2ECC71", "#9B59B6", "#F39C12",
                        "#1ABC9C", "#E67E22", "#34495E", "#16A085", "#C0392B"
        };
        @Autowired
        private CsService csService;
        @Autowired
        private AuthRepository authRepository;
        @Autowired
        private FofoStoreRepository fofoStoreRepository;
        @Autowired
        private RetailerService retailerService;
        @Autowired
        private BeatPlanRepository beatPlanRepository;
        @Autowired
        private BeatPlanDayRepository beatPlanDayRepository;
        @Autowired
        private AuthUserLocationRepository authUserLocationRepository;
        @Autowired
        private LeadRepository leadRepository;
        @Autowired
        private PublicHolidaysRepository publicHolidaysRepository;
        @Autowired
        private com.spice.profitmandi.service.GeocodingService geocodingService;
        @Autowired
        private CookiesProcessor cookiesProcessor;
        @Autowired
        private ResponseSender responseSender;

        @GetMapping(value = "/beatPlan")
        public String beatPlan(HttpServletRequest request, Model model) {
                EscalationType[] escalationTypes = EscalationType.values();
                model.addAttribute("escalationTypes", escalationTypes);
                return "beat-plan";
        }

        @GetMapping(value = "/beatPlanWindow")
        public String beatPlanWindow(HttpServletRequest request, Model model) {
                EscalationType[] escalationTypes = EscalationType.values();
                model.addAttribute("escalationTypes", escalationTypes);
                return "beat-plan-window";
        }

        @GetMapping(value = "/beatPlan/getAuthUsers")
        public ResponseEntity<?> getAuthUsers(
                        @RequestParam int categoryId,
                        @RequestParam EscalationType escalationType) {

                List<AuthUser> authUsers = csService.getAuthUserByCategoryId(categoryId, escalationType);
                List<Map<String, Object>> result = authUsers.stream()
                                .filter(au -> au.getActive())
                                .map(au -> {
                                        Map<String, Object> map = new HashMap<>();
                                        map.put("id", au.getId());
                                        map.put("name", au.getFirstName() + " " + au.getLastName());
                                        return map;
                                })
                                .collect(Collectors.toList());

                return responseSender.ok(result);
        }

        @GetMapping(value = "/beatPlan/getBaseLocation")
        public ResponseEntity<?> getBaseLocation(@RequestParam int authUserId) {
                AuthUserLocation baseLoc = authUserLocationRepository.selectLatestByAuthUserIdAndType(authUserId, "BASE");
                if (baseLoc == null) {
                        return responseSender.ok(new HashMap<>());
                }
                Map<String, Object> result = new HashMap<>();
                result.put("id", baseLoc.getId());
                result.put("locationName", baseLoc.getLocationName());
                result.put("latitude", baseLoc.getLatitude());
                result.put("longitude", baseLoc.getLongitude());
                result.put("address", baseLoc.getAddress());
                return responseSender.ok(result);
        }

        @PostMapping(value = "/beatPlan/saveBaseLocation")
        public ResponseEntity<?> saveBaseLocation(
                        @RequestParam int authUserId,
                        @RequestParam String locationName,
                        @RequestParam String latitude,
                        @RequestParam String longitude,
                        @RequestParam(required = false) String address) {

                AuthUserLocation loc = new AuthUserLocation();
                loc.setAuthUserId(authUserId);
                loc.setLocationType("BASE");
                loc.setLocationName(locationName);
                loc.setLatitude(latitude);
                loc.setLongitude(longitude);
                loc.setAddress(address);
                loc.setCreatedTimestamp(LocalDateTime.now());
                authUserLocationRepository.persist(loc);

                Map<String, Object> result = new HashMap<>();
                result.put("status", true);
                result.put("id", loc.getId());
                return responseSender.ok(result);
        }

        @GetMapping(value = "/beatPlan/getPartners")
        public ResponseEntity<?> getPartners(
                        @RequestParam int authUserId,
                        @RequestParam int categoryId,
                        @RequestParam(required = false) String startLat,
                        @RequestParam(required = false) String startLng) throws ProfitMandiBusinessException {

                Map<Integer, List<Integer>> pp = csService.getAuthUserIdPartnerIdMapping();
                List<Integer> fofoIds = pp.get(authUserId);


                if (fofoIds.isEmpty()) {
                        Map<String, Object> empty = new HashMap<>();
                        empty.put("partners", new ArrayList<>());
                        return responseSender.ok(empty);
                }

                List<FofoStore> fofoStores = fofoStoreRepository.selectByRetailerIds(fofoIds);
                Map<Integer, CustomRetailer> retailerMap = retailerService.getFofoRetailers(fofoIds);

                // Build partner data list with addresses
                List<Map<String, Object>> partners = new ArrayList<>();
                List<String> addressesToGeocode = new ArrayList<>();
                List<FofoStore> activeStores = new ArrayList<>();

                for (FofoStore store : fofoStores) {
                        if (!store.isActive() || store.isClosed()) continue;
                        activeStores.add(store);

                        CustomRetailer retailer = retailerMap.get(store.getId());

                        Map<String, Object> partnerData = new HashMap<>();
                        partnerData.put("fofoId", store.getId());
                        partnerData.put("code", store.getCode());
                        partnerData.put("outletName", store.getOutletName());
                        partnerData.put("type", "partner");

                        String addressStr = null;
                        if (retailer != null) {
                                partnerData.put("businessName", retailer.getBusinessName());
                                if (retailer.getAddress() != null) {
                                        addressStr = retailer.getAddress().getAddressString();
                                        partnerData.put("address", addressStr);
                                }
                        }

                        addressesToGeocode.add(addressStr);
                        partners.add(partnerData);
                }

                // Geocode all addresses in parallel (cached eternally in Redis, so only first call hits Google)
                java.util.concurrent.ExecutorService executor = java.util.concurrent.Executors.newFixedThreadPool(
                                Math.min(10, partners.size()));
                List<java.util.concurrent.Future<double[]>> futures = new ArrayList<>();

                for (String addr : addressesToGeocode) {
                        futures.add(executor.submit(() -> {
                                if (addr != null && !addr.isEmpty()) {
                                        try {
                                                return geocodingService.geocodeAddress(addr);
                                        } catch (Exception e) {
                                                return null;
                                        }
                                }
                                return null;
                        }));
                }

                // Collect results
                for (int i = 0; i < partners.size(); i++) {
                        Map<String, Object> partnerData = partners.get(i);
                        String lat = null, lng = null;

                        try {
                                double[] coords = futures.get(i).get(10, java.util.concurrent.TimeUnit.SECONDS);
                                if (coords != null) {
                                        lat = String.valueOf(coords[0]);
                                        lng = String.valueOf(coords[1]);
                                }
                        } catch (Exception e) {
                                LOGGER.warn("Geocoding timeout/error for partner {}", partnerData.get("code"));
                        }

                        partnerData.put("latitude", lat);
                        partnerData.put("longitude", lng);
                }

                executor.shutdown();

                // Sort by nearest neighbor from start location if provided, otherwise from first partner
                if (startLat != null && startLng != null && !startLat.isEmpty() && !startLng.isEmpty()) {
                        partners = sortByNearestNeighborFromStart(partners, Double.parseDouble(startLat), Double.parseDouble(startLng));
                } else {
                        partners = sortByNearestNeighbor(partners);
                }

                Map<String, Object> response = new HashMap<>();
                response.put("partners", partners);
                return responseSender.ok(response);
        }

        @PostMapping(value = "/beatPlan/submitPlan")
        public ResponseEntity<?> submitPlan(
                        HttpServletRequest request,
                        @RequestParam int authUserId,
                        @RequestParam String planData) throws Exception {

                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                AuthUser currentUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

                Gson gson = new Gson();
                Type type = new TypeToken<Map<String, Object>>() {
                }.getType();
                Map<String, Object> plan = gson.fromJson(planData, type);

                List<Map<String, Object>> days = (List<Map<String, Object>>) plan.get("days");
                List<String> dates = (List<String>) plan.get("dates");

                // Build visit fingerprint to detect duplicates
                List<Integer> newVisitIds = new ArrayList<>();
                for (Map<String, Object> day : days) {
                        List<Map<String, Object>> visits = (List<Map<String, Object>>) day.get("visits");
                        if (visits != null) {
                                for (Map<String, Object> v : visits) {
                                        newVisitIds.add(((Number) v.get("id")).intValue());
                                }
                        }
                }
                Collections.sort(newVisitIds);

                // Check existing beats for this auth user
                List<BeatPlanDay> existingBeatDays = beatPlanDayRepository.selectByAuthUserIdAndDateRange(
                                authUserId, LocalDate.of(2000, 1, 1), LocalDate.of(2099, 12, 31));
                Set<String> existingGroups = existingBeatDays.stream()
                                .map(BeatPlanDay::getPlanGroupId).filter(g -> g != null).collect(Collectors.toSet());

                for (String existingGroup : existingGroups) {
                        List<BeatPlan> existingVisits = beatPlanRepository.selectByPlanGroupId(existingGroup);
                        List<Integer> existingIds = existingVisits.stream()
                                        .map(BeatPlan::getFofoId).sorted().collect(Collectors.toList());
                        if (existingIds.equals(newVisitIds)) {
                                // Duplicate found — return existing planGroupId
                                Map<String, Object> response = new HashMap<>();
                                response.put("status", true);
                                response.put("planGroupId", existingGroup);
                                response.put("duplicate", true);
                                response.put("message", "Beat already exists with same visits");
                                return responseSender.ok(response);
                        }
                }

                String planGroupId = UUID.randomUUID().toString();
                String beatName = plan.get("beatName") != null ? (String) plan.get("beatName") : "Beat";
                String beatColor = BEAT_COLORS[Math.abs(planGroupId.hashCode()) % BEAT_COLORS.length];

                for (int d = 0; d < days.size(); d++) {
                        Map<String, Object> day = days.get(d);
                        int dayNumber = d + 1;
                        LocalDate planDate = (dates != null && d < dates.size() && dates.get(d) != null)
                                        ? LocalDate.parse(dates.get(d), DateTimeFormatter.ISO_DATE)
                                        : null;

                        // Save day-level info
                        BeatPlanDay bpDay = new BeatPlanDay();
                        bpDay.setPlanGroupId(planGroupId);
                        bpDay.setAuthUserId(authUserId);
                        bpDay.setDayNumber(dayNumber);
                        bpDay.setPlanDate(planDate);
                        bpDay.setBeatName(beatName);
                        bpDay.setBeatColor(beatColor);
                        bpDay.setStartLocationName((String) day.get("startLocationName"));
                        bpDay.setStartLatitude((String) day.get("startLatitude"));
                        bpDay.setStartLongitude((String) day.get("startLongitude"));
                        bpDay.setEndAction((String) day.get("endAction"));
                        bpDay.setStayLocationName((String) day.get("stayLocationName"));
                        bpDay.setStayLatitude((String) day.get("stayLatitude"));
                        bpDay.setStayLongitude((String) day.get("stayLongitude"));
                        if (day.get("totalDistanceKm") != null) {
                                bpDay.setTotalDistanceKm(((Number) day.get("totalDistanceKm")).doubleValue());
                        }
                        if (day.get("totalTimeMins") != null) {
                                bpDay.setTotalTimeMins(((Number) day.get("totalTimeMins")).intValue());
                        }
                        bpDay.setCreatedBy(currentUser.getId());
                        bpDay.setCreatedTimestamp(LocalDateTime.now());
                        bpDay.setActive(true);
                        beatPlanDayRepository.persist(bpDay);

                        // Save visits for this day
                        List<Map<String, Object>> visits = (List<Map<String, Object>>) day.get("visits");
                        if (visits != null) {
                                for (int i = 0; i < visits.size(); i++) {
                                        Map<String, Object> visit = visits.get(i);
                                        BeatPlan bp = new BeatPlan();
                                        bp.setAuthUserId(authUserId);
                                        bp.setFofoId(((Number) visit.get("id")).intValue());
                                        bp.setVisitType((String) visit.get("type"));
                                        bp.setDayNumber(dayNumber);
                                        bp.setPlanGroupId(planGroupId);
                                        bp.setPlanDate(planDate);
                                        bp.setSequenceOrder(i);
                                        bp.setCreatedBy(currentUser.getId());
                                        bp.setCreatedTimestamp(LocalDateTime.now());
                                        bp.setUpdatedTimestamp(LocalDateTime.now());
                                        bp.setActive(true);
                                        beatPlanRepository.persist(bp);
                                }
                        }
                }

                Map<String, Object> response = new HashMap<>();
                response.put("status", true);
                response.put("planGroupId", planGroupId);
                response.put("message", "Beat plan submitted successfully");
                return responseSender.ok(response);
        }

        // ============ CALENDAR ENDPOINTS ============

        @PostMapping(value = "/beatPlan/delete")
        public ResponseEntity<?> deleteBeat(@RequestParam String planGroupId) {
                beatPlanDayRepository.deleteByPlanGroupId(planGroupId);
                beatPlanRepository.deleteByPlanGroupId(planGroupId);

                Map<String, Object> response = new HashMap<>();
                response.put("status", true);
                response.put("message", "Beat deleted");
                return responseSender.ok(response);
        }

        @GetMapping(value = "/beatPlan/calendar")
        public ResponseEntity<?> getCalendar(
                        @RequestParam int authUserId,
                        @RequestParam String month) {

                YearMonth ym = YearMonth.parse(month);
                LocalDate startDate = ym.atDay(1);
                LocalDate endDate = ym.atEndOfMonth();

                // Get holidays
                List<PublicHolidays> holidays = publicHolidaysRepository.selectAllBetweenDates(startDate, endDate);
                List<Map<String, String>> holidayList = holidays.stream().map(h -> {
                        Map<String, String> m = new HashMap<>();
                        m.put("date", h.getDate().toString());
                        m.put("occasion", h.getOccasion());
                        return m;
                }).collect(Collectors.toList());

                // Get beats for this month (includes null-date/unscheduled ones)
                List<BeatPlanDay> beatDays = beatPlanDayRepository.selectByAuthUserIdAndDateRange(authUserId, startDate, endDate);

                // Group by planGroupId
                Map<String, List<BeatPlanDay>> grouped = beatDays.stream()
                                .filter(d -> d.getPlanGroupId() != null)
                                .collect(Collectors.groupingBy(BeatPlanDay::getPlanGroupId));

                LocalDate today = LocalDate.now();
                List<Map<String, Object>> scheduledBeats = new ArrayList<>();

                for (Map.Entry<String, List<BeatPlanDay>> entry : grouped.entrySet()) {
                        List<BeatPlanDay> days = entry.getValue();
                        BeatPlanDay first = days.get(0);

                        // Determine status
                        boolean allNullDates = days.stream().allMatch(d -> d.getPlanDate() == null);
                        boolean hasToday = days.stream().anyMatch(d -> d.getPlanDate() != null && d.getPlanDate().equals(today));
                        boolean allPast = !allNullDates && days.stream().filter(d -> d.getPlanDate() != null).allMatch(d -> d.getPlanDate().isBefore(today));
                        boolean allFuture = !allNullDates && days.stream().filter(d -> d.getPlanDate() != null).allMatch(d -> d.getPlanDate().isAfter(today));

                        String status;
                        if (allNullDates) status = "unscheduled";
                        else if (hasToday) status = "running";
                        else if (allPast) status = "completed";
                        else if (allFuture) status = "scheduled";
                        else status = "scheduled"; // mixed past/future

                        // Get visit counts per day
                        Map<String, Object> beat = new HashMap<>();
                        beat.put("planGroupId", entry.getKey());
                        beat.put("beatName", first.getBeatName() != null ? first.getBeatName() : "Beat");
                        beat.put("beatColor", first.getBeatColor() != null ? first.getBeatColor() : "#3498DB");
                        beat.put("status", status);

                        List<Map<String, Object>> dayInfoList = new ArrayList<>();
                        for (BeatPlanDay d : days) {
                                Map<String, Object> dayInfo = new HashMap<>();
                                dayInfo.put("dayNumber", d.getDayNumber());
                                dayInfo.put("planDate", d.getPlanDate() != null ? d.getPlanDate().toString() : null);
                                dayInfo.put("totalKm", d.getTotalDistanceKm());
                                dayInfo.put("totalMins", d.getTotalTimeMins());

                                // Count visits for this day
                                List<BeatPlan> visits = beatPlanRepository.selectByPlanGroupId(entry.getKey()).stream()
                                                .filter(bp -> bp.getDayNumber() == d.getDayNumber())
                                                .collect(Collectors.toList());
                                dayInfo.put("visitCount", visits.size());
                                dayInfoList.add(dayInfo);
                        }
                        beat.put("days", dayInfoList);
                        scheduledBeats.add(beat);
                }

                // Build blocked dates (Sundays + holidays)
                Set<String> blockedDates = new HashSet<>();
                for (LocalDate d = startDate; !d.isAfter(endDate); d = d.plusDays(1)) {
                        if (d.getDayOfWeek() == DayOfWeek.SUNDAY) {
                                blockedDates.add(d.toString());
                        }
                }
                for (PublicHolidays h : holidays) {
                        blockedDates.add(h.getDate().toString());
                }

                Map<String, Object> response = new HashMap<>();
                response.put("holidays", holidayList);
                response.put("scheduledBeats", scheduledBeats);
                response.put("blockedDates", blockedDates);

                return responseSender.ok(response);
        }

        @PostMapping(value = "/beatPlan/scheduleOnCalendar")
        public ResponseEntity<?> scheduleOnCalendar(
                        HttpServletRequest request,
                        @RequestParam String planGroupId,
                        @RequestParam String dates,
                        @RequestParam(required = false) String beatName,
                        @RequestParam(required = false) String beatColor) throws Exception {

                Gson gson = new Gson();
                List<String> dateList = gson.fromJson(dates, new TypeToken<List<String>>() {
                }.getType());

                List<BeatPlanDay> beatDays = beatPlanDayRepository.selectByPlanGroupId(planGroupId);
                if (beatDays.isEmpty()) {
                        return responseSender.badRequest("No beat found for this plan group");
                }

                // Check running beat — can't reschedule
                LocalDate today = LocalDate.now();
                boolean isRunning = beatDays.stream().anyMatch(d -> d.getPlanDate() != null && d.getPlanDate().equals(today));
                if (isRunning) {
                        return responseSender.badRequest("Cannot reschedule a running beat");
                }

                // Auto-assign color if not provided
                if (beatColor == null || beatColor.isEmpty()) {
                        beatColor = BEAT_COLORS[Math.abs(planGroupId.hashCode()) % BEAT_COLORS.length];
                }

                // Update dates on beat_plan_day
                beatDays.sort(Comparator.comparingInt(BeatPlanDay::getDayNumber));
                for (int i = 0; i < beatDays.size() && i < dateList.size(); i++) {
                        BeatPlanDay day = beatDays.get(i);
                        day.setPlanDate(LocalDate.parse(dateList.get(i)));
                        if (beatName != null) day.setBeatName(beatName);
                        day.setBeatColor(beatColor);
                        beatPlanDayRepository.persist(day);
                }

                // Update dates on beat_plan records too
                List<BeatPlan> beatPlans = beatPlanRepository.selectByPlanGroupId(planGroupId);
                for (BeatPlan bp : beatPlans) {
                        for (int i = 0; i < beatDays.size() && i < dateList.size(); i++) {
                                if (bp.getDayNumber() == beatDays.get(i).getDayNumber()) {
                                        bp.setPlanDate(LocalDate.parse(dateList.get(i)));
                                        beatPlanRepository.persist(bp);
                                }
                        }
                }

                Map<String, Object> response = new HashMap<>();
                response.put("status", true);
                response.put("message", "Beat scheduled successfully");
                return responseSender.ok(response);
        }

        @PostMapping(value = "/beatPlan/repeatBeat")
        public ResponseEntity<?> repeatBeat(
                        HttpServletRequest request,
                        @RequestParam String sourcePlanGroupId,
                        @RequestParam int authUserId,
                        @RequestParam String dates) throws Exception {

                LoginDetails loginDetails = cookiesProcessor.getCookiesObject(request);
                AuthUser currentUser = authRepository.selectByEmailOrMobile(loginDetails.getEmailId());

                Gson gson = new Gson();
                List<String> dateList = gson.fromJson(dates, new TypeToken<List<String>>() {
                }.getType());

                // Get source beat days and visits
                List<BeatPlanDay> sourceDays = beatPlanDayRepository.selectByPlanGroupId(sourcePlanGroupId);
                List<BeatPlan> sourceVisits = beatPlanRepository.selectByPlanGroupId(sourcePlanGroupId);

                if (sourceDays.isEmpty()) {
                        return responseSender.badRequest("Source beat not found");
                }

                String newPlanGroupId = UUID.randomUUID().toString();
                String beatName = sourceDays.get(0).getBeatName();
                String beatColor = sourceDays.get(0).getBeatColor();

                // Copy days with new dates
                sourceDays.sort(Comparator.comparingInt(BeatPlanDay::getDayNumber));
                for (int i = 0; i < sourceDays.size() && i < dateList.size(); i++) {
                        BeatPlanDay src = sourceDays.get(i);
                        BeatPlanDay newDay = new BeatPlanDay();
                        newDay.setPlanGroupId(newPlanGroupId);
                        newDay.setAuthUserId(authUserId);
                        newDay.setDayNumber(src.getDayNumber());
                        newDay.setPlanDate(LocalDate.parse(dateList.get(i)));
                        newDay.setBeatName(beatName);
                        newDay.setBeatColor(beatColor);
                        newDay.setStartLocationName(src.getStartLocationName());
                        newDay.setStartLatitude(src.getStartLatitude());
                        newDay.setStartLongitude(src.getStartLongitude());
                        newDay.setEndAction(src.getEndAction());
                        newDay.setStayLocationName(src.getStayLocationName());
                        newDay.setStayLatitude(src.getStayLatitude());
                        newDay.setStayLongitude(src.getStayLongitude());
                        newDay.setTotalDistanceKm(src.getTotalDistanceKm());
                        newDay.setTotalTimeMins(src.getTotalTimeMins());
                        newDay.setCreatedBy(currentUser.getId());
                        newDay.setCreatedTimestamp(LocalDateTime.now());
                        newDay.setActive(true);
                        beatPlanDayRepository.persist(newDay);
                }

                // Copy visits with new plan group and dates
                for (BeatPlan srcVisit : sourceVisits) {
                        BeatPlan newVisit = new BeatPlan();
                        newVisit.setAuthUserId(authUserId);
                        newVisit.setFofoId(srcVisit.getFofoId());
                        newVisit.setVisitType(srcVisit.getVisitType());
                        newVisit.setDayNumber(srcVisit.getDayNumber());
                        newVisit.setPlanGroupId(newPlanGroupId);
                        newVisit.setSequenceOrder(srcVisit.getSequenceOrder());
                        newVisit.setCreatedBy(currentUser.getId());
                        newVisit.setCreatedTimestamp(LocalDateTime.now());
                        newVisit.setUpdatedTimestamp(LocalDateTime.now());
                        newVisit.setActive(true);

                        // Set date from new dateList
                        int dayIdx = srcVisit.getDayNumber() - 1;
                        if (dayIdx >= 0 && dayIdx < dateList.size()) {
                                newVisit.setPlanDate(LocalDate.parse(dateList.get(dayIdx)));
                        }
                        beatPlanRepository.persist(newVisit);
                }

                Map<String, Object> response = new HashMap<>();
                response.put("status", true);
                response.put("planGroupId", newPlanGroupId);
                response.put("message", "Beat repeated successfully");
                return responseSender.ok(response);
        }

        @GetMapping(value = "/beatPlan/availableSlots")
        public ResponseEntity<?> getAvailableSlots(
                        @RequestParam int authUserId,
                        @RequestParam String month,
                        @RequestParam int daysNeeded) {

                YearMonth ym = YearMonth.parse(month);
                LocalDate startDate = ym.atDay(1);
                LocalDate endDate = ym.atEndOfMonth();
                LocalDate today = LocalDate.now();

                // Blocked: Sundays + holidays + already scheduled dates
                Set<LocalDate> blocked = new HashSet<>();

                for (LocalDate d = startDate; !d.isAfter(endDate); d = d.plusDays(1)) {
                        if (d.getDayOfWeek() == DayOfWeek.SUNDAY) blocked.add(d);
                        if (!d.isAfter(today)) blocked.add(d); // past dates blocked
                }

                List<PublicHolidays> holidays = publicHolidaysRepository.selectAllBetweenDates(startDate, endDate);
                for (PublicHolidays h : holidays) blocked.add(h.getDate());

                List<BeatPlanDay> existingBeats = beatPlanDayRepository.selectByAuthUserIdAndDateRange(authUserId, startDate, endDate);
                for (BeatPlanDay bd : existingBeats) {
                        if (bd.getPlanDate() != null) blocked.add(bd.getPlanDate());
                }

                // Find earliest available slots
                List<String> available = new ArrayList<>();
                for (LocalDate d = startDate.isAfter(today) ? startDate : today.plusDays(1);
                         !d.isAfter(endDate) && available.size() < daysNeeded;
                         d = d.plusDays(1)) {
                        if (!blocked.contains(d)) {
                                available.add(d.toString());
                        }
                }

                Map<String, Object> response = new HashMap<>();
                response.put("suggestedDates", available);
                response.put("totalAvailable", available.size());
                return responseSender.ok(response);
        }

        // --- Sorting helpers ---

        private List<Map<String, Object>> sortByNearestNeighborFromStart(
                        List<Map<String, Object>> partners, double startLat, double startLng) {

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

                for (Map<String, Object> p : partners) {
                        if (hasValidCoords(p)) {
                                withCoords.add(p);
                        } else {
                                withoutCoords.add(p);
                        }
                }

                List<Map<String, Object>> sorted = new ArrayList<>();
                double currentLat = startLat;
                double currentLng = startLng;

                while (!withCoords.isEmpty()) {
                        int nearestIdx = 0;
                        double nearestDist = Double.MAX_VALUE;
                        for (int i = 0; i < withCoords.size(); i++) {
                                double lat = Double.parseDouble(withCoords.get(i).get("latitude").toString());
                                double lng = Double.parseDouble(withCoords.get(i).get("longitude").toString());
                                double dist = haversine(currentLat, currentLng, lat, lng);
                                if (dist < nearestDist) {
                                        nearestDist = dist;
                                        nearestIdx = i;
                                }
                        }
                        Map<String, Object> nearest = withCoords.remove(nearestIdx);
                        sorted.add(nearest);
                        currentLat = Double.parseDouble(nearest.get("latitude").toString());
                        currentLng = Double.parseDouble(nearest.get("longitude").toString());
                }

                sorted.addAll(withoutCoords);
                return sorted;
        }

        private List<Map<String, Object>> sortByNearestNeighbor(List<Map<String, Object>> partners) {
                List<Map<String, Object>> withCoords = new ArrayList<>();
                List<Map<String, Object>> withoutCoords = new ArrayList<>();

                for (Map<String, Object> p : partners) {
                        if (hasValidCoords(p)) {
                                withCoords.add(p);
                        } else {
                                withoutCoords.add(p);
                        }
                }

                List<Map<String, Object>> sorted = new ArrayList<>();
                if (!withCoords.isEmpty()) {
                        sorted.add(withCoords.remove(0));
                        while (!withCoords.isEmpty()) {
                                Map<String, Object> last = sorted.get(sorted.size() - 1);
                                double lastLat = Double.parseDouble(last.get("latitude").toString());
                                double lastLng = Double.parseDouble(last.get("longitude").toString());

                                int nearestIdx = 0;
                                double nearestDist = Double.MAX_VALUE;
                                for (int i = 0; i < withCoords.size(); i++) {
                                        double lat = Double.parseDouble(withCoords.get(i).get("latitude").toString());
                                        double lng = Double.parseDouble(withCoords.get(i).get("longitude").toString());
                                        double dist = haversine(lastLat, lastLng, lat, lng);
                                        if (dist < nearestDist) {
                                                nearestDist = dist;
                                                nearestIdx = i;
                                        }
                                }
                                sorted.add(withCoords.remove(nearestIdx));
                        }
                }
                sorted.addAll(withoutCoords);
                return sorted;
        }

        private boolean hasValidCoords(Map<String, Object> p) {
                Object lat = p.get("latitude");
                Object lng = p.get("longitude");
                return lat != null && lng != null
                                && !lat.toString().isEmpty() && !lng.toString().isEmpty();
        }

        private double haversine(double lat1, double lng1, double lat2, double lng2) {
                double R = 6371;
                double dLat = Math.toRadians(lat2 - lat1);
                double dLng = Math.toRadians(lng2 - lng1);
                double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
                                + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))
                                * Math.sin(dLng / 2) * Math.sin(dLng / 2);
                double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
                return R * c;
        }
}