communityhallv22/src/main/java/com/gcc/communityHall/controller/HQAPIController.java

package com.gcc.communityHall.controller;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.ui.Model;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.springframework.web.multipart.MultipartFile;

import com.gcc.communityHall.component.JwtUtil;
import com.gcc.communityHall.dto.BookingResponseDTO;
import com.gcc.communityHall.dto.ErrorResponseDto;
import com.gcc.communityHall.entity.ApplicationLogs;
import com.gcc.communityHall.entity.BookingCalendar;
import com.gcc.communityHall.entity.BookingDetails;
import com.gcc.communityHall.entity.BookingDetails.BookingStatus;
import com.gcc.communityHall.entity.BookingDetails.RefundStatus;
import com.gcc.communityHall.entity.DiscountRange;
import com.gcc.communityHall.entity.FloorDetails;
import com.gcc.communityHall.entity.GccBlockingDate;
import com.gcc.communityHall.entity.GccBlockingHistory;
import com.gcc.communityHall.entity.HallDetails;
import com.gcc.communityHall.entity.HallImages;
import com.gcc.communityHall.entity.Notification;
import com.gcc.communityHall.entity.ReasonDocumentMaster;
import com.gcc.communityHall.entity.ReasonMaster;
import com.gcc.communityHall.entity.Settlement;
import com.gcc.communityHall.entity.Users;
import com.gcc.communityHall.others.AppConfig;
import com.gcc.communityHall.others.UserSession;
import com.gcc.communityHall.paymentService.service.PaymentGatewayServiceImpl;
import com.gcc.communityHall.repository.ApplicationLogsRepository;
import com.gcc.communityHall.repository.BookingCalendarRepository;
import com.gcc.communityHall.repository.BookingDetailsRepository;
import com.gcc.communityHall.repository.DiscountRangeRepository;
import com.gcc.communityHall.repository.GccBlockingDateRepository;
import com.gcc.communityHall.repository.GccBlockingHistoryRepository;
import com.gcc.communityHall.repository.HallDetailsRepository;
import com.gcc.communityHall.repository.HallReasonRestrictionRepository;
import com.gcc.communityHall.repository.HallImagesRepository;
import com.gcc.communityHall.repository.NotificationRepository;
import com.gcc.communityHall.repository.ReasonMasterRepository;
import com.gcc.communityHall.repository.SettlementRepository;
import com.gcc.communityHall.repository.UsersRepository;
import com.gcc.communityHall.service.BookingService;
import com.gcc.communityHall.service.HallDetailService;
import com.gcc.communityHall.service.ReasonMasterService;
import com.gcc.communityHall.service.SettlementService;
import com.gcc.communityHall.service.UserService;
import com.gcc.communityHall.service.Impl.BookingServiceImpl;

import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.media.ExampleObject;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;
import lombok.AllArgsConstructor;

//@RestController
//@RequestMapping("/admin/api")
@Tag(name = "CRUD REST APIs for HQ's in CommunityHall", description = "CRUD REST APIs in CommunityHall to CREATE, UPDATE, FETCH AND DELETE Booking details")
@RestController
@RequestMapping("/communityhall/headquarters/api")
@AllArgsConstructor
@Validated
public class HQAPIController {

    @Autowired
    private HallDetailsRepository hallDetailsRepository;

    @Autowired
    private HallDetailService hallDetailService;
    @Autowired
    private BookingDetailsRepository bookingDetailsRepository;

    @Autowired
    private SettlementService settlementService;

    @Autowired
    private SettlementRepository settlementRepository;

    @Autowired
    private BookingServiceImpl bookingService;

    @Autowired
    private BookingDetailsRepository bookingDetailsRepo;

    @Autowired
    private DiscountRangeRepository discountRangeRepo;

    @Autowired
    private GccBlockingDateRepository blockingDateRepository;

    @Autowired
    private ReasonMasterService reasonMasterService;

    @Autowired
    private HallDetailService hallService;
    @Autowired
    private UserService userService;

    @Autowired
    private BookingCalendarRepository bookingCalendarRepository;

    @Autowired
    private UsersRepository userRepository;

    @Autowired
    private HallImagesRepository hallImagesRepository;

    @Autowired
    private JwtUtil jwtUtil;

    @Autowired
    private AppConfig appConfig;

    @Autowired
    private PaymentGatewayServiceImpl paymentGatewayServiceImpl;

    @Autowired
    private NotificationRepository notificationRepo;

    @Autowired
    private HttpSession session;

    @Autowired
    private ApplicationLogsRepository applicationLogsRepository;

    @Autowired
    private HallReasonRestrictionRepository hallReasonRestrictionRepository;

    @Autowired
    private BookingServiceImpl bookingServiceImpl;

    @Operation(summary = "Update HallDetails REST API", description = "REST API to update the Hall Details")
    @ApiResponses({
            @ApiResponse(responseCode = "200", description = "HTTP Status UPDATED", content = @Content(mediaType = "text/plain", schema = @Schema(implementation = HallDetails.class), examples = @ExampleObject(value = "Hall details updated successfully"))),
            @ApiResponse(responseCode = "500", description = "HTTP Status Internal Server Error", content = @Content(mediaType = "application/json", schema = @Schema(implementation = ErrorResponseDto.class), examples = @ExampleObject(name = "Internal Server Error Example", value = "{ \"path\": \"/updateHallDetails\", \"status\": 500, \"error\": \"Internal Server Error\", \"timestamp\": \"2024-06-22T05:47:04.347+00:00\" }")))
    })
    @PostMapping("/updateHallDetails")
    public ResponseEntity<String> updateHallInfo(
            @RequestParam("hallId") String hallId,
            @RequestParam("zone") String zone,
            @RequestParam("division") String division,
            @RequestParam("hallName") String hallName,
            @RequestParam("hallArea") String hallArea,
            @RequestParam("doorNo") String doorNo,
            @RequestParam("street") String street,
            @RequestParam("area") String area,
            @RequestParam("pinCode") int pinCode,
            @RequestParam("landMark") String landMark,
            @RequestParam("latitude") String latitude,
            @RequestParam("longitude") String longitude,
            @RequestParam("hallInchargeMobno") long hallInchargeMobno,
            @RequestParam("hallInchargeName") String hallInchargeName,
            @RequestParam("depositAmount") float depositAmount,
            @RequestParam("halfDepositAmount") float halfDepositAmount,
            @RequestParam("fullDayRent") float fullDayRent,
            @RequestParam("halfDayRent") float halfDayRent,
            @RequestParam("parkingCapacity") String parkingCapacity,
            @RequestParam("seatingCapacity") int seatingCapacity,
            @RequestParam(value = "images", required = false) List<MultipartFile> images,
            @RequestParam("ebNumber") String ebNumber,
            @RequestParam("ebCostPerUnit") float ebCostPerUnit,
            @RequestParam("gst") float gst,
            @RequestParam("city") String city,
            @RequestParam("isActive") boolean isActive,
            @RequestParam(value = "floorName", required = false) List<String> floorNames,
            @RequestParam(value = "floorCapacity", required = false) List<Double> floorCapacities) {

        HallDetails hallDetails = new HallDetails();
        hallDetails.setHallId(Integer.parseInt(hallId));
        hallDetails.setZone(zone);
        hallDetails.setDivision(division);
        hallDetails.setHallName(hallName);
        hallDetails.setHallArea(Float.parseFloat(hallArea));
        hallDetails.setDoorNo(doorNo);
        hallDetails.setStreet(street);
        hallDetails.setArea(area);
        hallDetails.setPinCode(pinCode);
        hallDetails.setLandMark(landMark);
        hallDetails.setLatitude(latitude);
        hallDetails.setLongitude(longitude);
        hallDetails.setHallInchargeMobno(hallInchargeMobno);
        hallDetails.setHallInchargeName(hallInchargeName);
        hallDetails.setDepositAmount(depositAmount);
        hallDetails.setHalfDepositAmount(halfDepositAmount);
        hallDetails.setFullDayRent(fullDayRent);
        hallDetails.setHalfDayRent(halfDayRent);
        hallDetails.setParkingCapacity(parkingCapacity);
        hallDetails.setSeatingCapacity(seatingCapacity);
        hallDetails.setEbNumber(ebNumber);
        hallDetails.setEbCostPerUnit(ebCostPerUnit);
        hallDetails.setGst(gst);
        hallDetails.setCity(city);
        hallDetails.setActive(isActive);

        hallDetailService.updateHallDetail(hallDetails, images);

        // Update floor details for this hall (HQ only addition)
        hallDetailService.updateFloorDetails(Integer.parseInt(hallId), floorNames, floorCapacities);

        String adminname = (String) session.getAttribute("usertype");
        Integer loginid = (Integer) session.getAttribute("id");
        ApplicationLogs logs = new ApplicationLogs();
        logs.setComments("Action by " + adminname);
        logs.setLoginId(loginid);
        logs.setLogType("Hall Details edit:-" + hallName);
        InetAddress inetAddress;
        try {
            inetAddress = InetAddress.getLocalHost();
            String hostname = InetAddress.getLocalHost().getHostName();
            logs.setIpaddress(inetAddress.getHostAddress());
            logs.setSystemName(hostname);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        applicationLogsRepository.save(logs);

        return ResponseEntity.ok("Success");
    }

    @Operation(summary = "Update Settlement Status REST API", description = "REST API to update the Settlement Status to INITIATED")
    @ApiResponses({
            @ApiResponse(responseCode = "200", description = "HTTP Status UPDATED", content = @Content(mediaType = "application/json", schema = @Schema(implementation = Settlement.class), examples = @ExampleObject(name = "Settlement Example", value = "{\"settlementId\": Id, \"Refundstatus\": \"INITIATED\", \"comments\": \"Settlement initiated successfully\"}"))),
            @ApiResponse(responseCode = "500", description = "HTTP Status Internal Server Error", content = @Content(mediaType = "application/json", schema = @Schema(implementation = ErrorResponseDto.class), examples = @ExampleObject(name = "Internal Server Error Example", value = "{ \"path\": \"/updateInitiatedSettlementStatus/{settlementId}\", \"status\": 500, \"error\": \"Internal Server Error\", \"timestamp\": \"2024-06-22T05:47:04.347+00:00\" }")))
    })
    @PostMapping("/updateInitiatedSettlementStatus/{settlementId}")
    public ResponseEntity<Settlement> updateInitiatedSettlementStatus(
            @PathVariable("settlementId") int settlementId,
            @RequestParam("status") BookingDetails.RefundStatus status,
            @RequestParam("comments") String comments) {
        Settlement updateInitialiseSettlement = settlementService.updateSettlementStatus(settlementId, status,
                comments);
        String adminname = (String) session.getAttribute("usertype");
        Integer loginid = (Integer) session.getAttribute("id");
        ApplicationLogs logs = new ApplicationLogs();
        logs.setComments("Action by " + adminname);
        logs.setLoginId(loginid);
        logs.setLogType("Settlement Initiation:-" + status);
        InetAddress inetAddress;
        try {
            inetAddress = InetAddress.getLocalHost();
            String hostname = InetAddress.getLocalHost().getHostName();
            logs.setIpaddress(inetAddress.getHostAddress());
            logs.setSystemName(hostname);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        applicationLogsRepository.save(logs);
        if (updateInitialiseSettlement != null) {
            return new ResponseEntity<>(updateInitialiseSettlement, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    @Operation(summary = "HallDetails by HallId REST API", description = "REST API to Retrieving the Hall Details by hallId")
    @ApiResponses({
            @ApiResponse(responseCode = "200", description = "HTTP Status OK", content = @Content(mediaType = "application/json", schema = @Schema(implementation = HallDetails.class))),
            @ApiResponse(responseCode = "400", description = "Bad Request"),
            @ApiResponse(responseCode = "404", description = "Not Found")
    })
    @GetMapping("/getHallDetails/{hallId}")
    public ResponseEntity<HallDetails> getHallDetails(@PathVariable String hallId) {
        int id;
        try {
            id = Integer.parseInt(hallId);
        } catch (NumberFormatException e) {
            return ResponseEntity.badRequest().build();
        }

        HallDetails hallDetails = hallDetailsRepository.findHallDetailsById(id);
        // System.out.println(hallDetails.isActive());
        if (hallDetails != null) {
            return ResponseEntity.ok(hallDetails);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @Operation(summary = "Saving the DiscountRange REST API", description = "REST API to Saving the Discount Range for usertypes")
    @PostMapping("/savediscountrange")
    public String saveDiscountrange(
            @RequestParam String userType,
            @RequestParam float discountRange, HttpSession session) {

        Optional<DiscountRange> existingDiscountRanges = discountRangeRepo.findByUsertype(userType);
        if (!existingDiscountRanges.isEmpty()) {
            return "waiting";
        }

        String adminname = (String) session.getAttribute("usertype");
        DiscountRange discount = new DiscountRange();
        discount.setUsertype(userType);
        discount.setDiscountRange(discountRange);
        discount.setcDate(LocalDate.now());
        discount.setUpdtedBy(adminname);
        discount.setIs_active(true);
        discount.setIs_delete(false);

        discountRangeRepo.save(discount);
        return "success";
    }

    @PostMapping("/savenotification")
    public String saveNotification(
            @RequestParam String notification, HttpSession session) {

        String adminname = (String) session.getAttribute("usertype");
        Notification newnotification = new Notification();
        newnotification.setNotification_description(notification);
        newnotification.setCdate(LocalDate.now());
        newnotification.setCreatedBY(adminname);
        newnotification.setActive(true);
        newnotification.setDelete(false);
        notificationRepo.save(newnotification);
        Integer loginid = (Integer) session.getAttribute("id");
        ApplicationLogs logs = new ApplicationLogs();
        logs.setComments("Action by " + adminname);
        logs.setLoginId(loginid);
        logs.setLogType("Added New Notification:-" + newnotification.getNotification_description());
        InetAddress inetAddress;
        try {
            inetAddress = InetAddress.getLocalHost();
            String hostname = InetAddress.getLocalHost().getHostName();
            logs.setIpaddress(inetAddress.getHostAddress());
            logs.setSystemName(hostname);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        applicationLogsRepository.save(logs);
        return "success";
    }

    @Operation(summary = " Update the DiscountRange REST API", description = "REST API to Updating the Discount Range for usertypes")
    @PutMapping("/updateById/{id}")
    public String updateDiscountRangeById(@PathVariable int id, @RequestParam float discountRange,
            HttpSession session) {
        String adminname = (String) session.getAttribute("usertype");
        Optional<DiscountRange> existingDiscount = discountRangeRepo.findById(id);
        if (existingDiscount.isPresent()) {
            DiscountRange updatediscount = existingDiscount.get();
            updatediscount.setDiscountRange(discountRange);
            updatediscount.setUpdtedBy(adminname);
            updatediscount.setcDate(LocalDate.now());
            discountRangeRepo.save(updatediscount);
            Integer loginid = (Integer) session.getAttribute("id");
            ApplicationLogs logs = new ApplicationLogs();
            logs.setComments("Action by " + adminname);
            logs.setLoginId(loginid);
            logs.setLogType("Discount Details Update:-" + updatediscount.getUsertype());
            InetAddress inetAddress;
            try {
                inetAddress = InetAddress.getLocalHost();
                String hostname = InetAddress.getLocalHost().getHostName();
                logs.setIpaddress(inetAddress.getHostAddress());
                logs.setSystemName(hostname);
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
            applicationLogsRepository.save(logs);
            return "success";
        } else {
            return "error: Entry with ID " + id + " not found";
        }
    }

    @Operation(summary = " Delete the DiscountRange REST API", description = "REST API to Deleting the Discount for usertypes")
    @DeleteMapping("/deleteById/{id}")
    public ResponseEntity<String> deleteDiscountRangeById(@PathVariable int id) {
        if (discountRangeRepo.existsById(id)) {
            discountRangeRepo.deleteById(id);
            String adminname = (String) session.getAttribute("usertype");
            Integer loginid = (Integer) session.getAttribute("id");
            ApplicationLogs logs = new ApplicationLogs();
            logs.setComments("Action by " + adminname);
            logs.setLoginId(loginid);
            logs.setLogType("Discount Details Delete:-" + id);
            InetAddress inetAddress;
            try {
                inetAddress = InetAddress.getLocalHost();
                String hostname = InetAddress.getLocalHost().getHostName();
                logs.setIpaddress(inetAddress.getHostAddress());
                logs.setSystemName(hostname);
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
            applicationLogsRepository.save(logs);
            return ResponseEntity.ok("DiscountRange with ID " + id + " deleted successfully.");
        } else {
            return ResponseEntity.notFound().build(); // Return 404 if the entry does not exist
        }
    }

    @PostMapping("/deletenotificationById/{id}")
    public ResponseEntity<String> deleteNotificationById(@PathVariable int id, HttpSession session) {
        Optional<Notification> notification = notificationRepo.findById(id);
        Notification newnotification = notification.get();
        newnotification.setActive(false);
        newnotification.setDelete(true);
        String adminname = (String) session.getAttribute("usertype");
        newnotification.setUpdatedBy(adminname);
        String date = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        newnotification.setUpdatedDate(date);
        notificationRepo.save(newnotification);
        Integer loginid = (Integer) session.getAttribute("id");
        ApplicationLogs logs = new ApplicationLogs();
        logs.setComments("Action by " + adminname);
        logs.setLoginId(loginid);
        logs.setLogType("Detele Notification:-" + newnotification.getNotification_description());
        InetAddress inetAddress;
        try {
            inetAddress = InetAddress.getLocalHost();
            String hostname = InetAddress.getLocalHost().getHostName();
            logs.setIpaddress(inetAddress.getHostAddress());
            logs.setSystemName(hostname);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        applicationLogsRepository.save(logs);
        return ResponseEntity.ok("Notification with ID " + id + " deleted successfully.");

    }

    @Operation(summary = "Retrieving the Discount Details REST API", description = "REST API to Retrieve the Discount Details for usertypes")
    // Retrieving the Discount Details
    @GetMapping("/getDiscountDetails")
    public Optional<DiscountRange> getDIscountDetails(@RequestParam("id") int id) {
        Optional<DiscountRange> discountdetails = discountRangeRepo.findById(id);
        return discountdetails;
    }

    @Operation(summary = "Save Reasons REST API", description = "REST API to save the reasons")
    // saving the Reason
    @PostMapping("/saveReason")
    public ResponseEntity<?> saveReason(@RequestBody ReasonMaster reasaon) {
        return ResponseEntity.ok(reasonMasterService.saveTheReason(reasaon));
    }

    @Operation(summary = "All Reasons REST API", description = "REST API to retrie the allreasons")
    // retrieving the allreasons
    @GetMapping("/getReasons")
    @ResponseBody
    public List<ReasonMaster> getAllReasons() {
        return reasonMasterService.getAllReasons();
    }

    // retrieving allowed reasons for a specific hall (filtered by restriction)
    @GetMapping("/getAllowedReasons")
    @ResponseBody
    public List<ReasonMaster> getAllowedReasons(@RequestParam int hallId) {
        HallDetails hallDetails = hallDetailsRepository.findHallDetailsById(hallId);
        if (hallDetails != null && hallDetails.isReasonRestricted()) {
            List<Integer> allowedReasonIds = hallReasonRestrictionRepository.findReasonIdsByHallId(hallId);
            if (!allowedReasonIds.isEmpty()) {
                List<ReasonMaster> allReasons = reasonMasterService.getAllReasons();
                return allReasons.stream()
                        .filter(r -> allowedReasonIds.contains(r.getReasonId()))
                        .collect(java.util.stream.Collectors.toList());
            }
        }
        return reasonMasterService.getAllReasons();
    }

    @Operation(summary = "Reason Documents by reasonId REST API", description = "REST API to Get the ReasonDocuments By reasonId")
    // Getting ReasonDocuments By reasonId
    @GetMapping("/getReasonDocumentDetails")
    public List<ReasonDocumentMaster> getReasonDocumentDetails(@RequestParam int reasonId) {
        return reasonMasterService.getReasonDocumentDetailsByReasonId(reasonId);
    }

    @Operation(summary = "Booking Details by Fromdate,toDate and HallId REST API", description = "REST API to get the Booking Details by Fromdate,toDate and HallId for GccBlokcing")
    // @GetMapping("/filter")
    // public ResponseEntity<List<BookingResponseDTO>> getFilteredBookings(
    // @RequestParam("fromDate") @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate
    // fromDate,
    // @RequestParam("toDate") @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate
    // toDate,
    // @RequestParam("hallIds") List<Long> hallIds) {
    //
    // List<BookingDetails> bookings = bookingService.getFilteredBookings(fromDate,
    // toDate, hallIds);
    //
    // List<BookingResponseDTO> responses = new ArrayList<>();
    // for (BookingDetails bookingDetails : bookings) {
    // // Fetch GccBlockingDate records for each bookingId
    // List<GccBlockingDate> gccBlockedList =
    // blockingDateRepository.getByBookingId(bookingDetails.getBookingId());
    // Integer blockingId = gccBlockedList.isEmpty() ? null :
    // gccBlockedList.get(0).getBlockingId();
    // responses.add(new BookingResponseDTO(bookingDetails, blockingId));
    // }
    //
    // return ResponseEntity.ok(responses);
    // }
    @GetMapping("/filter")
    public ResponseEntity<Map<String, Object>> getFilteredBookings(
            @RequestParam("fromDate") @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate fromDate,
            @RequestParam("toDate") @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate toDate,
            @RequestParam("hallIds") List<Long> hallIds) {

        List<BookingDetails> bookings = bookingService.getFilteredBookings(fromDate, toDate, hallIds);
        List<GccBlockingDate> gccBlockedList = blockingDateRepository
                .findByFromDateAndToDateBetweenAndHallIdIn(fromDate, toDate, hallIds);

        Map<String, Object> response = new HashMap<>();
        response.put("bookings", bookings);
        response.put("blockedEvents", gccBlockedList);

        return ResponseEntity.ok(response);
    }

    @Operation(summary = " GCC Blocked Booking Details REST API", description = "REST API to get the GCC Blocked BookingDetails")
    // retrieving the GCC Blocked BookingDetails
    @GetMapping("/blockedevents")
    public ResponseEntity<List<GccBlockingDate>> getBlockedEvents() {
        List<GccBlockingDate> blockedBookings = bookingService.getBlockedEvents();
        if (blockedBookings.isEmpty()) {
            return ResponseEntity.ok(blockedBookings);
        }

        for (GccBlockingDate blockedBooking : blockedBookings) {
            // System.out.println("Blocked Event: " + blockedBooking);
        }

        return ResponseEntity.ok(blockedBookings);
    }

    @Operation(summary = "UNBLOCK the gcc Blocked Event REST API", description = "REST API to unblocking the Gcc blocked Events for blocking")
    @GetMapping("/cancelByid")
    public ResponseEntity<String> cancellationById(@RequestParam int blockingId,
            @RequestParam("fromDate") @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate fromDate,
            @RequestParam("endDate") @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate endDate) {

        // Fetch the blocking date entity
        GccBlockingDate blockingDate = blockingDateRepository.findById(blockingId).orElse(null);

        if (blockingDate == null) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Blocking ID not found.");
        }

        // Get the booking IDs from the blocking date entity
        String bookingIds = blockingDate.getBookingIds();
        String hallIds = blockingDate.getHallId();

        // Convert the booking IDs to a list of integers
        List<Integer> bookingIdList = Arrays.stream(bookingIds.split(","))
                .map(Integer::parseInt)
                .collect(Collectors.toList());

        // Convert the hall IDs to a list of longs if provided
        List<Long> hallIdList = hallIds != null ? Arrays.stream(hallIds.split(","))
                .map(Long::parseLong)
                .collect(Collectors.toList())
                : Collections.emptyList();

        // Fetch the booking calendar entries within the date range
        List<BookingCalendar> bookingCalendars = bookingService.getBookedslots(fromDate, endDate, hallIdList);

        // ── Smart unblock: per-slot decision ──────────────────────────────────
        // If morning+evening+is_blocked are all true AND an APPROVED user booking
        // exists for that hall/date → only clear is_blocked (leave slots intact).
        // Otherwise (GCC-owned slot) → clear everything.
        for (BookingCalendar bookingslots : bookingCalendars) {
            if (bookingslots.isMorningSlot() && bookingslots.isEveningSlot() && bookingslots.getIs_blocked()) {
                List<BookingDetails> approvedBookings = bookingDetailsRepository.findByHallIdAndDate(
                        bookingslots.getBdate(), bookingslots.getHallId());
                if (!approvedBookings.isEmpty()) {
                    // Approved user booking owns the slots — only remove gcc flag
                    bookingslots.setIs_blocked(false);
                } else {
                    // GCC owned this slot fully — release everything
                    bookingslots.setBookingId_1(null);
                    bookingslots.setBookingId_2(null);
                    bookingslots.setMorningSlot(false);
                    bookingslots.setEveningSlot(false);
                    bookingslots.setIs_blocked(false);
                }
            } else {
                // Partial slot scenario — only clear the gcc overlay flag
                bookingslots.setIs_blocked(false);
            }
            bookingCalendarRepository.save(bookingslots);
        }

        blockingDate.setBlockedStatus(GccBlockingDate.BlockedStatus.UNBLOCKED);
        blockingDateRepository.save(blockingDate);

        // Update GCC_BLOCKED booking_details entries back to GCC_UNBLOCKED
        for (int bookingId : bookingIdList) {
            Optional<BookingDetails> bookingDetails = bookingDetailsRepo.findById(bookingId);
            if (bookingDetails.isPresent()) {
                BookingDetails bookings = bookingDetails.get();
                if (bookings.getBookingStatus() == BookingDetails.BookingStatus.GCC_BLOCKED) {
                    bookings.setBookingStatus(BookingDetails.BookingStatus.GCC_UNBLOCKED);
                    bookings.setRefundStatus(BookingDetails.RefundStatus.NA);
                    bookingDetailsRepo.save(bookings);
                }
            }
        }
        String adminname = (String) session.getAttribute("usertype");
        Integer loginid = (Integer) session.getAttribute("id");
        ApplicationLogs logs = new ApplicationLogs();
        logs.setComments("Action by " + adminname);
        logs.setLoginId(loginid);
        logs.setLogType("Gcc UnBlocking for the Id:-" + blockingDate.getBlockingId());
        InetAddress inetAddress;
        try {
            inetAddress = InetAddress.getLocalHost();
            String hostname = InetAddress.getLocalHost().getHostName();
            logs.setIpaddress(inetAddress.getHostAddress());
            logs.setSystemName(hostname);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        applicationLogsRepository.save(logs);
        return ResponseEntity.ok("Success");
    }
    // @GetMapping("/cancelByid")
    // public ResponseEntity<String> cancellationById(@RequestParam int blockingId,
    // @RequestParam("fromDate") @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate
    // fromDate,
    // @RequestParam("endDate") @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate
    // endDate) {

    // // Fetch the blocking date entity
    // GccBlockingDate blockingDate =
    // blockingDateRepository.findById(blockingId).orElse(null);

    // if (blockingDate == null) {
    // return ResponseEntity.status(HttpStatus.NOT_FOUND).body("Blocking ID not
    // found.");
    // }

    // // Get the booking IDs from the blocking date entity (may be null/empty for
    // // block-only entries)
    // String bookingIds = blockingDate.getBookingIds();
    // String hallIds = blockingDate.getHallId();

    // // Parse booking IDs only if present
    // List<Integer> bookingIdList = (bookingIds != null &&
    // !bookingIds.trim().isEmpty())
    // ? Arrays.stream(bookingIds.split(","))
    // .map(String::trim)
    // .filter(s -> !s.isEmpty())
    // .map(Integer::parseInt)
    // .collect(Collectors.toList())
    // : Collections.emptyList();

    // // Convert the hall IDs to a list of longs if provided
    // List<Long> hallIdList = (hallIds != null && !hallIds.trim().isEmpty())
    // ? Arrays.stream(hallIds.split(","))
    // .map(Long::parseLong)
    // .collect(Collectors.toList())
    // : Collections.emptyList();

    // // Fetch the booking calendar entries within the date range
    // List<BookingCalendar> bookingCalendars =
    // bookingService.getBookedslots(fromDate, endDate, hallIdList);

    // // Release the GCC block flag ONLY.
    // // Do NOT touch bookingId_1, bookingId_2, morningSlot, or eveningSlot –
    // // those belong to real user bookings that must remain intact.
    // for (BookingCalendar bookingslots : bookingCalendars) {
    // bookingslots.setIs_blocked(false);
    // bookingCalendarRepository.save(bookingslots);
    // }

    // blockingDate.setBlockedStatus(GccBlockingDate.BlockedStatus.UNBLOCKED);
    // blockingDateRepository.save(blockingDate);

    // // Restore status of any bookings that were cancelled as part of this GCC
    // block
    // for (int bookingId : bookingIdList) {
    // Optional<BookingDetails> bookingDetails =
    // bookingDetailsRepo.findById(bookingId);
    // if (bookingDetails.isPresent()) {
    // BookingDetails bookings = bookingDetails.get();
    // bookings.setBookingStatus(BookingDetails.BookingStatus.GCC_UNBLOCKED);
    // bookings.setRefundStatus(BookingDetails.RefundStatus.NA);
    // bookingDetailsRepo.save(bookings);
    // }
    // }
    // String adminname = (String) session.getAttribute("usertype");
    // Integer loginid = (Integer) session.getAttribute("id");
    // ApplicationLogs logs = new ApplicationLogs();
    // logs.setComments("Action by " + adminname);
    // logs.setLoginId(loginid);
    // logs.setLogType("Gcc UnBlocking for the Id:-" +
    // blockingDate.getBlockingId());
    // InetAddress inetAddress;
    // try {
    // inetAddress = InetAddress.getLocalHost();
    // String hostname = InetAddress.getLocalHost().getHostName();
    // logs.setIpaddress(inetAddress.getHostAddress());
    // logs.setSystemName(hostname);
    // } catch (UnknownHostException e) {
    // e.printStackTrace();
    // }
    // applicationLogsRepository.save(logs);
    // return ResponseEntity.ok("Success");
    // }

    @Operation(summary = "HAll IMAGES by HallId REST API", description = "REST API to get the hall Images by Hall Id")
    // retrieving Hall Images by Hallid
    @GetMapping("/getImageById")
    public List<HallImages> getImageDetails(@RequestParam int hallId) {
        return hallService.getHallImages(hallId);
    }

    @Operation(summary = "GCC Block Without Cancelling REST API", description = "REST API to Block halls without cancelling existing bookings (smart slot logic)")
    @PostMapping("/blockWithoutCancel")
    public ResponseEntity<String> blockWithoutCancel(
            @RequestParam("fromDate") String fromDate,
            @RequestParam("toDate") String toDate,
            @RequestParam("hallID") String hallID,
            @RequestParam("reasonforblocking") String reasonforblocking,
            @RequestParam(value = "description", required = false) String[] descriptions,
            @RequestParam(value = "document", required = false) MultipartFile[] documents,
            HttpSession session) {

        String updatedBy = (String) session.getAttribute("employeeId");
        List<Long> hallIdsList = Arrays.stream(hallID.split(","))
                .map(Long::parseLong)
                .collect(Collectors.toList());

        bookingService.blockWithoutCancellingBookings(fromDate, toDate, hallIdsList, reasonforblocking,
                updatedBy, descriptions, documents);

        String adminname = (String) session.getAttribute("usertype");
        Integer loginid = (Integer) session.getAttribute("id");
        ApplicationLogs logs = new ApplicationLogs();
        logs.setComments("Action by " + adminname);
        logs.setLoginId(loginid);
        logs.setLogType("Gcc Block Without Cancel for the Reason:-" + reasonforblocking);
        InetAddress inetAddress;
        try {
            inetAddress = InetAddress.getLocalHost();
            String hostname = InetAddress.getLocalHost().getHostName();
            logs.setIpaddress(inetAddress.getHostAddress());
            logs.setSystemName(hostname);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        applicationLogsRepository.save(logs);
        return ResponseEntity.ok("Success");
    }

    @Operation(summary = "GCC Blocking REST API", description = "REST API to Block the Halls by Admin")
    // GccBlocking Api
    @PostMapping("/cancelAll")
    public ResponseEntity<String> cancelAllBookings(
            @RequestParam("fromDate") String fromDate,
            @RequestParam("toDate") String toDate,
            @RequestParam("hallID") String hallID,
            @RequestParam("reasonforblocking") String reasonforblocking,
            @RequestParam(value = "selectedBookings", required = false) List<String> selectedBookings,
            @RequestParam(value = "description", required = false) String[] descriptions, // Handle descriptions
            @RequestParam(value = "document", required = false) MultipartFile[] documents, // Handle documents
            HttpSession session) {

        // Your existing logic
        String updatedBy = (String) session.getAttribute("employeeId");

        // Split and convert hall IDs
        List<Long> hallIdsList = Arrays.stream(hallID.split(","))
                .map(Long::parseLong)
                .collect(Collectors.toList());

        System.out.println("fromDate " + fromDate + "\n toDate " + toDate + "\n hallID " + hallID
                + "\n reasonforblocking " + reasonforblocking + "\n selectedBookings " + selectedBookings
                + "\n descriptions " + descriptions + "\n documents " + documents + "\n updatedBy " + updatedBy);

        // Call the service with descriptions and documents
        bookingService.cancelAllBookings(fromDate, toDate, hallIdsList, reasonforblocking, selectedBookings, updatedBy,
                descriptions, documents);
        String adminname = (String) session.getAttribute("usertype");
        Integer loginid = (Integer) session.getAttribute("id");
        ApplicationLogs logs = new ApplicationLogs();
        logs.setComments("Action by " + adminname);
        logs.setLoginId(loginid);
        logs.setLogType("Gcc Blocking for the Reason:-" + reasonforblocking);
        InetAddress inetAddress;
        try {
            inetAddress = InetAddress.getLocalHost();
            String hostname = InetAddress.getLocalHost().getHostName();
            logs.setIpaddress(inetAddress.getHostAddress());
            logs.setSystemName(hostname);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        applicationLogsRepository.save(logs);
        return ResponseEntity.ok("Success");
    }

    // @PostMapping("/blockhall")
    // public ResponseEntity<String> blockHall(
    // @RequestParam("blockingId") Integer blockingId,
    // @RequestParam("hallID") String hallID, // Ensure this matches the parameter
    // name used in AJAX
    // @RequestParam(value = "selectedBookings", required = false) List<String>
    // selectedBookings,
    // HttpSession session) {
    //
    // String updatedBy = (String) session.getAttribute("employeeId");
    // Optional<GccBlockingDate> gccblocking =
    // blockingDateRepository.findById(blockingId);
    // GccBlockingDate gccblockingdata = gccblocking.get();
    //
    // // Convert startDate and endDate to String
    // SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    // String startDateString = sdf.format(gccblockingdata.getStartDate());
    // String endDateString = sdf.format(gccblockingdata.getEndDate());
    //
    // // Split and convert hall IDs
    // List<Long> hallIdsList = Arrays.stream(hallID.split(","))
    // .map(Long::parseLong)
    // .collect(Collectors.toList());
    //
    // System.out.println("selected BookingIds: " + selectedBookings);
    //
    // // Pass the formatted date strings
    // bookingService.cancelAllBookings(startDateString, endDateString, hallIdsList,
    // gccblockingdata.getDepartment(), gccblockingdata.getBlockingReason(),
    // selectedBookings, updatedBy);
    //
    // return ResponseEntity.ok("Success");
    // }

    @GetMapping("/bookingdetailsByuserId")
    public List<BookingDetails> getuserDetails(@RequestParam Integer userId) {
        return bookingService.getAllBookingsByUserId(userId);
    }

    @GetMapping("/settlement-approved")
    public ResponseEntity<List<Settlement>> getApprovedSettlements(HttpSession session) {
        List<Settlement> approvedSettlements = settlementRepository
                .findByBookingDetailsRefundStatus(RefundStatus.APPROVED);
        return ResponseEntity.ok(approvedSettlements);
    }
    // @PostMapping("/complete-refund")
    // public ResponseEntity<String> completeRefund(@RequestBody List<String>
    // bookingIds, HttpSession session, HttpServletResponse response) throws
    // IOException {
    // String token = (String) session.getAttribute("jwtToken");
    // //System.out.println("tokensssssssss" + token);
    //
    // // Validate JWT token
    // if (token != null && jwtUtil.validateToken(token)) {
    // // System.out.println("tokennnnnnnnnnnnnnns" + token);
    // try {
    // // System.out.println("Received booking IDs for refund: " + bookingIds);
    //
    // List<String> bookids = bookingService.processRefundRequests(bookingIds);
    //
    // if (!bookids.isEmpty()) {
    // // Prepare and return error response if there are errors
    // StringBuilder errorResponse = new StringBuilder("Errors processing refund for
    // IDs: ");
    // for (String bookId : bookids) {
    // errorResponse.append(bookId).append(", ");
    // }
    // return
    // ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse.toString());
    // }
    //
    // return ResponseEntity.ok("Refund completed successfully");
    // } catch (Exception e) {
    // e.printStackTrace();
    // return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Error
    // processing refund: " + e.getMessage());
    // }
    // } else {
    // // Token is invalid or not present, redirect to login
    // session.invalidate(); // Invalidate the session to clear all session
    // attributes
    // response.sendRedirect("/login"); // Redirect to the login page
    // return ResponseEntity.status(HttpStatus.UNAUTHORIZED).build(); // Return HTTP
    // 401 Unauthorized
    // }
    // }

    // @GetMapping("/Gccblocking")
    // public ResponseEntity<List<Object>>
    // getGccBlockingEvents(@RequestParam("hallId") int hallId) {
    // System.out.println("Received hallId: " + hallId);
    //
    // List<Object> results = bookingService.getGccBlockingEvents(hallId);
    //
    // return ResponseEntity.ok(results);
    // }
    @GetMapping("/Gccblocking")
    public ResponseEntity<List<Object>> getGccBlockingEvents(@RequestParam("hallId") String hallId) {
        // System.out.println("Received hallId: " + hallId);

        List<Object> results = bookingService.getGccBlockingEvents(hallId);

        return ResponseEntity.ok(results);
    }

    @GetMapping("/getblockedbookingdetails")
    public ResponseEntity<List<Map<String, Object>>> viewBlockedHallsByHallIdAndReason(
            @RequestParam String hallIds,
            @RequestParam int blockingId) {

        // System.out.println("Received hallIds: " + hallIds);
        // System.out.println("Received blockingId: " + blockingId);

        List<Integer> hallIdList;
        try {
            hallIdList = Arrays.stream(hallIds.split("\\s*,\\s*"))
                    .map(Integer::parseInt)
                    .collect(Collectors.toList());
        } catch (NumberFormatException e) {
            System.err.println("Invalid hall ID format: " + e.getMessage());
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(Collections.emptyList());
        }

        Optional<GccBlockingDate> gccOpt = blockingDateRepository.findById(blockingId);
        if (!gccOpt.isPresent()) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Collections.emptyList());
        }

        GccBlockingDate savedGcc = gccOpt.get();
        LocalDate startDate = LocalDate.ofInstant(savedGcc.getStartDate().toInstant(), ZoneId.systemDefault());
        LocalDate endDate = LocalDate.ofInstant(savedGcc.getEndDate().toInstant(), ZoneId.systemDefault());

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

        for (int hallId : hallIdList) {
            int bookingCount = bookingDetailsRepository.countByHallIdAndBookingDateBetween(hallId, startDate, endDate);
            // System.out.println("bookingCount==="+bookingCount);
            Optional<HallDetails> hallDetailsOpt = hallDetailsRepository.findById(hallId);

            if (hallDetailsOpt.isPresent()) {
                HallDetails hallDetails = hallDetailsOpt.get();
                List<Integer> bookingIds = bookingDetailsRepository.findBookingIdsByHallIdAndBookingDateBetween(hallId,
                        startDate, endDate);
                // System.out.println("Booking IDs for hallId " + hallId + ": " + bookingIds);
                // // Add this line

                Map<String, Object> hallInfo = new HashMap<>();
                hallInfo.put("hallName", hallDetails.getHallName());
                hallInfo.put("zone", hallDetails.getZone());
                hallInfo.put("division", hallDetails.getDivision());
                hallInfo.put("bookingCount", bookingCount);
                hallInfo.put("bookingIds", bookingIds);
                hallInfo.put("hallId", hallId);

                result.add(hallInfo);
            }
        }

        return ResponseEntity.ok(result);
    }

    @GetMapping("/getbookingdetails")
    public ResponseEntity<List<BookingDetails>> getBookingDetails(@RequestParam("bookingId") Long bookingId) {
        // System.out.println("Received bookingId: " + bookingId);
        try {
            List<BookingDetails> details = bookingService.findBookingDetailsByBookingId(bookingId);
            // System.out.println("bookingdetails==="+details);
            return ResponseEntity.ok(details);
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    @GetMapping("/blockedHallsByHallIdAndReason")
    @ResponseBody
    public Map<String, Object> viewBlockedHallsByHallIdAndReason(
            @RequestParam String department,
            @RequestParam String blockingReason,
            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) Date startDate,
            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) Date endDate) {

        List<GccBlockingDate> blockedHalls = blockingDateRepository.findByBlockingReasonAndDateRange(blockingReason,
                startDate, endDate);

        // Ensure distinct by hallId and other keys
        List<GccBlockingDate> uniqueGccBlockingDates = blockedHalls.stream()
                .filter(distinctByKey(
                        g -> Arrays.asList(g.getHallId(), g.getBlockingReason(), g.getStartDate(), g.getEndDate())))
                .collect(Collectors.toList());

        // Prepare response data
        Map<String, Object> response = new HashMap<>();
        if (!uniqueGccBlockingDates.isEmpty()) {
            GccBlockingDate firstBlockedHall = uniqueGccBlockingDates.get(0); // Adjust as necessary
            response.put("blockingReason", firstBlockedHall.getBlockingReason());
            response.put("cdate", firstBlockedHall.getCdate());
            response.put("startDate", firstBlockedHall.getStartDate());
            response.put("endDate", firstBlockedHall.getEndDate());

            List<Map<String, Object>> hallDetailsList = new ArrayList<>();
            for (GccBlockingDate blockedHall : uniqueGccBlockingDates) {
                // Split the hallId string into individual hall IDs
                String[] hallIds = blockedHall.getHallId().split(",");

                for (String hallIdStr : hallIds) {
                    try {
                        int hallId = Integer.parseInt(hallIdStr.trim());
                        HallDetails hall = hallService.getHallById(hallId);
                        if (hall != null) {
                            Map<String, Object> hallDetails = new HashMap<>();
                            hallDetails.put("hallName", hall.getHallName());
                            hallDetails.put("zone", hall.getZone());
                            hallDetails.put("division", hall.getDivision());
                            hallDetails.put("numOfBookings", calculateBookings(hall, blockedHall));
                            hallDetails.put("refundedAmount", calculateRefund(hall, blockedHall));
                            hallDetailsList.add(hallDetails);
                        }
                    } catch (NumberFormatException e) {
                        // Handle the case where hallId is not a valid integer
                        e.printStackTrace();
                    }
                }
            }
            response.put("halls", hallDetailsList);
        } else {
            response.put("blockingReason", "N/A");
            response.put("cdate", "N/A");
            response.put("startDate", "N/A");
            response.put("endDate", "N/A");
            response.put("halls", Collections.emptyList());
        }
        return response;
    }

    // Utility method to ensure distinct by a key
    private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
        Set<Object> seen = new HashSet<>();
        return t -> seen.add(keyExtractor.apply(t));
    }

    // Method to calculate number of bookings
    private int calculateBookings(HallDetails hall, GccBlockingDate blockedHall) {
        return blockingDateRepository.countBlockedBookings(hall.getHallId(), blockedHall.getStartDate(),
                blockedHall.getEndDate());
    }

    private double calculateRefund(HallDetails hall, GccBlockingDate blockedHall) {
        // Implement logic to calculate refund
        return 0.0;
    }

    // admin dashboard
    @GetMapping("/bookingstatistics")
    public ResponseEntity<Map<String, Map<String, Integer>>> getBookingStatistics(
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate fromDate,
            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate toDate,
            @RequestParam(required = false, defaultValue = "ALL") String zone,
            @RequestParam(required = false, defaultValue = "ALL") String division,
            @RequestParam(required = false, defaultValue = "1000") Integer hallid,
            @RequestParam(required = false, defaultValue = "ALL") String userType) {

        try {
            Map<String, Map<String, Integer>> statistics = bookingService.getBookingStatistics(fromDate, toDate, zone,
                    division, hallid, userType);
            return ResponseEntity.ok(statistics);
        } catch (Exception e) {
            // Log the exception and return an appropriate error response
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(Collections.emptyMap());
        }
    }

    @GetMapping("/getHallsDetailsByZone")
    public ResponseEntity<Map<String, Object>> getHallsDetailsByZone(@RequestParam String zone) {
        Map<String, Object> hallzones = hallDetailService.getHallsDetailsByZone(zone);
        // Debug log to verify the response before sending it to the client
        // System.out.println("Response from getHallsDetailsByZone: " + hallzones);
        return ResponseEntity.ok(hallzones);
    }

    @GetMapping("/byhallid")
    public ResponseEntity<List<Map<String, Object>>> getBookingDetailsByHallId(@RequestParam int hallId) {
        List<Map<String, Object>> bookingDetails = bookingService.getBookingDetailsByHallId(hallId);
        return ResponseEntity.ok(bookingDetails);
    }

    @PostMapping("/savenewHallImages")
    public ResponseEntity<?> updateHallImages(@RequestParam("hallId") Integer hallId,
            @RequestParam("newHallImages") MultipartFile[] newHallImages) {
        // Call the service method to update the hall images
        hallService.updatenewHallImages(hallId, newHallImages);
        return ResponseEntity.ok().build();
    }

    // @DeleteMapping("/deleteHallImage/{hallImageId}")
    // public ResponseEntity<?> deleteHallImage(@PathVariable Long hallImageId) {
    // // Call the service method to delete the hall image
    // hallService.deleteHallImage(hallImageId);
    // return ResponseEntity.ok().build();
    // }

    @PutMapping("/updateHallImage/{hallImageId}")
    public ResponseEntity<Map<String, String>> updateHallImage(
            @PathVariable Integer hallImageId,
            @RequestParam("hallImage") MultipartFile hallImage) throws IOException {

        try {
            String newImageUrl = hallService.updateHallImage(hallImageId, hallImage);
            Map<String, String> response = new HashMap<>();
            response.put("newImageUrl", newImageUrl);
            return ResponseEntity.ok(response);
        } catch (IllegalArgumentException e) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Collections.singletonMap("error", e.getMessage()));
        } catch (IOException e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body(Collections.singletonMap("error", "Failed to update image"));
        }
    }

    @DeleteMapping("/deleteHallImage/{hallImageId}")
    public ResponseEntity<String> deleteHallImage(@PathVariable Integer hallImageId) {
        try {
            // Find the image by ID and delete it
            hallImagesRepository.deleteById(hallImageId);
            return ResponseEntity.ok("Image deleted successfully.");
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Error deleting image.");
        }
    }

    @GetMapping("/bookingdetailsByzone")
    public ResponseEntity<List<BookingDetails>> getBookingDetailsByZone(@RequestParam String zone) {
        List<BookingDetails> bookingDetails = bookingDetailsRepository.findByZone(zone);
        return ResponseEntity.ok(bookingDetails);
    }

    @GetMapping("/divisionsByZone")
    public List<String> getDivisionsByZone(@RequestParam("zoneId") String zoneId) {
        // Use zoneId instead of zone
        return hallDetailsRepository.findDistinctDivisionsByZone(zoneId);
    }

    // Fetch hall names by division
    @GetMapping("/hallsByDivision")
    public ResponseEntity<List<String>> getHallsByDivision(@RequestParam String division) {
        List<String> halls = hallDetailsRepository.findHallsByDivision(division);
        if (halls.isEmpty()) {
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        }
        return new ResponseEntity<>(halls, HttpStatus.OK);
    }

    @PostMapping("/manualrefund")
    public ResponseEntity<?> manualRefund(
            @RequestParam int bookingId,
            @RequestParam String txansactionId,
            @RequestParam int userId,
            @RequestParam String code,
            @RequestParam String amount) throws Exception {

        // Check if the code matches the value from AppConfig
        if (code.equals(appConfig.getManualRefundCode())) {
            // Call the refund method from PaymentService
            String response = paymentGatewayServiceImpl.manualrefundTheAmount(bookingId, userId, txansactionId, amount);
            // Check the response from the payment service
            if ("Refunded".equals(response)) {
                return ResponseEntity.ok("Refund processed successfully");
            } else {
                // If there was an error in processing the refund
                return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("Error processing refund.");
            }
        } else {
            // Return error message if the code doesn't match
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Code is wrong");
        }
    }

    // gccapps
    @GetMapping("/viewsettlement-pending")
    public ResponseEntity<Map<String, Object>> viewSettlementPendingMaster(HttpSession session) {

        List<BookingDetails> settlement = bookingDetailsRepository.findAllWithPendingRefundStatus();
        List<BookingDetails> cancelledbookings = bookingDetailsRepository.findPendingCancelledList();
        List<BookingDetails> rejectedbookings = bookingDetailsRepository.findPendingRejectedList();

        Map<String, Object> response = new HashMap<>();
        response.put("settlementlist", settlement);
        response.put("cancelledbookings", cancelledbookings);
        response.put("rejectedbookings", rejectedbookings);

        return ResponseEntity.ok(response);
    }

    @GetMapping("/viewsettlement-complete")
    public ResponseEntity<Map<String, Object>> viewSettlementcompleteMaster(HttpSession session) {

        List<BookingDetails> completedlist = bookingDetailsRepository.findAllwithCompletedRefundStatus();
        List<BookingDetails> Completedcancelledbookings = bookingDetailsRepository.findCompletedCancelledList();
        List<BookingDetails> Completedrejectedbookings = bookingDetailsRepository.findCompletedRejectedList();

        Map<String, Object> response = new HashMap<>();
        response.put("completedlist", completedlist);
        response.put("Completedcancelledbookings", Completedcancelledbookings);
        response.put("Completedrejectedbookings", Completedrejectedbookings);

        return ResponseEntity.ok(response);
    }

    @GetMapping("/viewsettlement-approved")
    public ResponseEntity<Map<String, Object>> viewSettlementApprovedMaster(HttpSession session) {

        List<BookingDetails> approvedSettlements = bookingDetailsRepository.findAllWithApprovedRefundStatus();
        List<BookingDetails> settlements = new ArrayList<>(approvedSettlements);
        List<BookingDetails> approvedCancelledBookings = bookingDetailsRepository.findCancelledList();
        List<BookingDetails> approvedRejectedBookings = bookingDetailsRepository.findRejectedList();

        Map<String, Object> response = new HashMap<>();
        response.put("settlementList", settlements);
        response.put("approvedCancelledBookings", approvedCancelledBookings);
        response.put("approvedRejectedBookings", approvedRejectedBookings);

        return ResponseEntity.ok(response);
    }

    @GetMapping("/viewsettlement-reject")
    public ResponseEntity<Map<String, Object>> viewSettlementRejectedMaster(HttpSession session) {

        List<BookingDetails> settlementReject = bookingDetailsRepository.findSettlementRejected();

        Map<String, Object> response = new HashMap<>();
        response.put("settlementlist", settlementReject);

        return ResponseEntity.ok(response);
    }

    @GetMapping("/viewsettlement-initiated")
    public ResponseEntity<Map<String, Object>> viewSettlementInitiateMaster(HttpSession session) {

        List<BookingDetails> settlement = bookingDetailsRepository.findByBookingDetailsRefundStatus();
        List<BookingDetails> Initiatedcancelledbookings = bookingDetailsRepository.findInitiatedCancelledList();
        List<BookingDetails> Initiatedrejectedbookings = bookingDetailsRepository.findInitiatedRejectedList();

        Map<String, Object> response = new HashMap<>();
        response.put("settlementlist", settlement);
        response.put("Initiatedcancelledbookings", Initiatedcancelledbookings);
        response.put("Initiatedrejectedbookings", Initiatedrejectedbookings);

        return ResponseEntity.ok(response);
    }

    @GetMapping("/user-pending")
    public ResponseEntity<List<Users>> viewApproval() {
        List<Users> pendingList = userRepository.getPendingList();
        return new ResponseEntity<>(pendingList, HttpStatus.OK);
    }

    @GetMapping("/user-approved")
    public ResponseEntity<List<Users>> viewUserApproved() {
        List<Users> approved = userRepository.getUserApproved();
        return new ResponseEntity<>(approved, HttpStatus.OK);
    }

    @GetMapping("/user-reject")
    public ResponseEntity<List<Users>> viewUserReject() {
        List<Users> rejected = userRepository.getUserReject();
        return new ResponseEntity<>(rejected, HttpStatus.OK);
    }

    @GetMapping("/halldetailslist")
    public ResponseEntity<List<HallDetails>> getHallDetailsList() {
        List<HallDetails> list = hallDetailsRepository.findAll();
        return ResponseEntity.ok(list);
    }

    @GetMapping("/discountRange")
    public ResponseEntity<List<DiscountRange>> getAllDiscountRanges() {
        List<DiscountRange> discount = discountRangeRepo.findAll();
        return ResponseEntity.ok(discount);
    }

    @PostMapping("/getReport")
    public ResponseEntity<Map<String, Object>> generateReport(
            @RequestParam(name = "FromDate") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) String fromDate,
            @RequestParam(name = "ToDate") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) String toDate,
            @RequestParam(name = "request") String request,
            @RequestParam(name = "userstatus", required = false) String userstatus,
            @RequestParam(name = "usertype", required = false) String usertype,
            @RequestParam(name = "bookingStatus", required = false) String bookingStatus,
            @RequestParam(name = "refundStatus", required = false) String refundStatus,
            @RequestParam(name = "bookingId", required = false) Long bookingId) {

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

        List<Users> userList = handleUserRequest(request, fromDate, toDate, userstatus, usertype);
        List<Object[]> bookingList = handleBookingRequest(request, fromDate, toDate, bookingStatus, bookingId);
        List<BookingDetails> bookingSettlementList = handleBookingSettlementRequest(request, fromDate, toDate,
                refundStatus);
        List<Object[]> paymentList = request.equals("3") ? bookingService.getAllPaymentsDetails(fromDate, toDate)
                : new ArrayList<>();
        List<Object[]> userbookingList = request.equals("4")
                ? bookingService.getBookingUserDetailsReport(fromDate, toDate)
                : new ArrayList<>();
        List<Object[]> hallbookingList = request.equals("5")
                ? bookingService.getBookingHallDetailsReport(fromDate, toDate)
                : new ArrayList<>();

        response.put("users", userList);
        response.put("bookings", bookingList);
        response.put("fromdate", fromDate);
        response.put("todate", toDate);
        response.put("userstatus", userstatus);
        response.put("bookingSettlementList", bookingSettlementList);
        response.put("usertype", usertype);
        response.put("bookingStatus", bookingStatus);
        response.put("refundStatus", refundStatus);
        response.put("request", request);
        response.put("paymentLists", paymentList);
        response.put("userbookingLists", userbookingList);
        response.put("hallbookingLists", hallbookingList);
        response.put("bookingId", bookingId);

        return new ResponseEntity<>(response, HttpStatus.OK);
    }

    private List<Users> handleUserRequest(String request, String fromDate, String toDate, String userstatus,
            String usertype) {
        if (!request.equals("1")) {
            return new ArrayList<>();
        }
        if ((userstatus != null && !userstatus.isEmpty()) && (usertype != null && !usertype.isEmpty())) {
            return userService.getAllUsersWithFilters(fromDate, toDate, userstatus, usertype);
        }
        if (userstatus.isEmpty() && (usertype != null && !usertype.isEmpty())) {
            return userService.getAllUsersWithTypeFilters(fromDate, toDate, usertype);
        }
        if (usertype.isEmpty() && (userstatus != null && !userstatus.isEmpty())) {
            return userService.getAllUsersWithStatusFilters(fromDate, toDate, userstatus);
        }
        return userService.getAllUsers(fromDate, toDate);
    }

    private List<Object[]> handleBookingRequest(String request, String fromDate, String toDate, String bookingStatus,
            Long bookingId) {
        if (!request.equals("2")) {
            return new ArrayList<>();
        }
        if (bookingStatus != null && !bookingStatus.isEmpty()) {
            return bookingDetailsRepo.getAllBookingDetailsWithStatus(fromDate, toDate, bookingStatus);
        } else if (bookingId != null) {
            return bookingDetailsRepo.getAllBookingDetailsWithBookingId(fromDate, toDate, bookingId);
        } else {
            return bookingDetailsRepo.getAllBookingDetails(fromDate, toDate);
        }
    }

    private List<BookingDetails> handleBookingSettlementRequest(String request, String fromDate, String toDate,
            String refundStatus) {
        if (!request.equals("6")) {
            return new ArrayList<>();
        }
        if (refundStatus != null && !refundStatus.isEmpty()) {
            return bookingDetailsRepository.getAllBookingsettlementDetailsWithStatus(fromDate, toDate, refundStatus);
        }
        return bookingDetailsRepository.getAllBookingsettlementDetails(fromDate, toDate);
    }

    @GetMapping("/getHallDetailsById")
    public ResponseEntity<List<Map<String, Object>>> getHallDetailsById(@RequestParam Integer hall_id) {
        List<Map<String, Object>> halldetails = bookingService.getHallDetailsForOfficer(hall_id);
        return ResponseEntity.ok(halldetails);
    }

    @GetMapping("/listgccblocking")
    public ResponseEntity<Map<String, Object>> getGccBlocking() {

        // Fetch all blocked GCC dates
        List<GccBlockingDate> gccBlocked = blockingDateRepository.findAllBlocked();

        // Ensure distinct by hallId, blockingReason, startDate, and endDate
        List<GccBlockingDate> uniqueGccBlockingDates = gccBlocked.stream()
                .filter(distinctByKey(g -> Arrays.asList(
                        g.getHallId(),
                        g.getBlockingReason(),
                        g.getStartDate(),
                        g.getEndDate())))
                .collect(Collectors.toList());

        // Map to store the count of blocked halls for each GccBlockingDate
        Map<Integer, Integer> hallCountMap = new HashMap<>();
        for (GccBlockingDate blockedDate : uniqueGccBlockingDates) {
            // Parse and count unique hall IDs
            String hallIds = blockedDate.getHallId();
            if (hallIds != null && !hallIds.isEmpty()) {
                Set<String> uniqueHallIds = new HashSet<>(Arrays.asList(hallIds.split(",")));
                int hallCount = uniqueHallIds.size();
                hallCountMap.put(blockedDate.getBlockingId(), hallCount);
            } else {
                hallCountMap.put(blockedDate.getBlockingId(), 0); // No halls blocked
            }
        }

        // Prepare the response data
        Map<String, Object> response = new HashMap<>();
        response.put("gccblocked", uniqueGccBlockingDates);
        response.put("hallCountMap", hallCountMap);

        return ResponseEntity.ok(response);
    }

    @GetMapping("/details")
    public ResponseEntity<List<Object[]>> getUserDetails(
            @RequestParam("fromDate") String fromDate,
            @RequestParam("toDate") String toDate) {
        List<Object[]> userDetails = userRepository.findUserDetailsByBookingDate(fromDate, toDate);
        return ResponseEntity.ok(userDetails);
    }

    @GetMapping("/getPaymentswithRefunds")
    public List<Object[]> getPaymentsWithRefunds(@RequestParam String startDate, @RequestParam String endDate) {
        return userRepository.findPaymentsWithRefunds(startDate, endDate);
    }

    @GetMapping("/getpaymentswithoutRefunds")
    public List<Object[]> getPaymentsWithoutRefunds(@RequestParam String startDate, @RequestParam String endDate) {
        return userRepository.findPaymentsWithoutRefunds(startDate, endDate);
    }

    @GetMapping("/getRefundDetails")
    public List<Object[]> getPaymentsWithRefundsOnly(@RequestParam String startDate, @RequestParam String endDate) {
        return userRepository.findPaymentsWithRefundsOnly(startDate, endDate);
    }

    @PostMapping("/send")
    public ResponseEntity<Map<String, String>> sendMessage(@RequestBody Map<String, String> messagePayload) {
        String userMessage = messagePayload.get("message");

        // Process the user message and prepare a response
        String response = processMessage(userMessage);

        Map<String, String> responseBody = new HashMap<>();
        responseBody.put("response", response);

        return ResponseEntity.ok(responseBody);
    }

    private String processMessage(String userMessage) {
        // Simple logic to return a response, could be more advanced (AI, NLP, etc.)
        if (userMessage.toLowerCase().contains("hello")) {
            return "Hello! How can I assist you today?";
        } else {
            return "Thanks for your message! We will get back to you shortly.";
        }
    }

    @PostMapping("/uploadnoc")
    public ResponseEntity<String> uploadnoc(@RequestParam("nocFile") MultipartFile file,
            @RequestParam("bookingid") int bookingId) {
        try {
            System.out.println("Received file: " + file.getOriginalFilename());
            System.out.println("Booking ID: " + bookingId);

            bookingService.uploadNOCFile(file, bookingId);
            return ResponseEntity.ok("File uploaded and saved successfully");
        } catch (Exception e) {
            System.err.println("Error during file upload: " + e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .body("File upload failed: " + e.getMessage());
        }
    }

    @Operation(summary = "Settlement APPROVED REST API", description = "REST API for Updating the Refund Status to Approved by Settlement Id If the settlement is Approved")
    // Updating the Refund Status to Approved by Settlement Id If the settlement is
    // Approved
    @PostMapping("/updateApprovedSettlementStatus/{bookingId}") // need to check this API for settlement approval
    public ResponseEntity<Object> updateApprovedSettlementStatus(
            @PathVariable("bookingId") int bookingId,
            @RequestParam("status") BookingDetails.RefundStatus status,
            @RequestParam("comments") String comments) {
        Map<String, Object> response = new HashMap<>();

        try {
            System.out.println("settlementId1: " + bookingId);
            System.out.println("status" + status);
            System.out.println("comments" + comments);

            // Update settlement status
            Settlement updateSettlement = settlementService.updateSettlementStatus(bookingId, status, comments);
            if (updateSettlement == null) {
                return new ResponseEntity<>(HttpStatus.NOT_FOUND);
            }
            System.out.println("updateSettlement12" + updateSettlement);
            // ak
            // Set approvedFlag and approvedFlagDate
            updateSettlement.setApprovedFlag(1);
            updateSettlement.setApprovedFlagDate(new Date());
            settlementRepository.save(updateSettlement);
            // ak

            // Log the action
            String adminname = (String) session.getAttribute("usertype");
            Integer loginid = (Integer) session.getAttribute("id");
            ApplicationLogs logs = new ApplicationLogs();
            logs.setComments("Action by " + adminname);
            logs.setLoginId(loginid);
            logs.setBookingId(updateSettlement.getBookingDetails().getBookingId());
            logs.setLogType("Booking Status: " + status.toString());

            try {
                InetAddress inetAddress = InetAddress.getLocalHost();
                String hostname = InetAddress.getLocalHost().getHostName();
                logs.setIpaddress(inetAddress.getHostAddress());
                logs.setSystemName(hostname);
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }

            applicationLogsRepository.save(logs);

            // Process refund request
            String refundResponse = bookingServiceImpl
                    .processRefundRequest(updateSettlement.getBookingDetails().getBookingId());
            // ak
            // Prepare response map

            response.put("settlement", updateSettlement);
            response.put("approvedFlag", updateSettlement.getApprovedFlag());
            response.put("approvedFlagDate", updateSettlement.getApprovedFlagDate());

            if (refundResponse.contains("successful")) {
                // Refund success, return updated settlement and status
                // return new ResponseEntity<>(updateSettlement, HttpStatus.OK);
                return new ResponseEntity<>(response, HttpStatus.OK);
            } else {

                // Refund failure, update refund status to FAILURE
                bookingService.updateRefundStatus(updateSettlement.getBookingDetails().getBookingId(),
                        BookingDetails.RefundStatus.FAILURE);
                Map<String, Object> responses = new HashMap<>();
                responses.put("approvedFlag", 1);
                responses.put("message", "Refund processing failed: " + refundResponse);
                responses.put("status", "FAILURE");

                return new ResponseEntity<>(responses, HttpStatus.INTERNAL_SERVER_ERROR);
                // return new ResponseEntity<>("Refund processing failed: " + refundResponse,
                // HttpStatus.INTERNAL_SERVER_ERROR);
            }

        } catch (Exception e) {
            response.put("approvedFlag", 1);
            response.put("message", "Exception while approving settlement: " + e.getMessage());
            return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);

            // return new ResponseEntity<>("An error occurred while processing the
            // settlement for Settlement ID: " + settlementId,
            // HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}