package com.gcc_manpower.gcctonermanagement.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
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.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.type.TypeReference;
import com.gcc_manpower.gcctonermanagement.service.TonerService;
import com.gcc_manpower.service.AppUserService;
import jakarta.servlet.http.HttpSession;
import jakarta.servlet.http.HttpServletRequest;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.context.HttpSessionSecurityContextRepository;

@Controller
@RequestMapping("/gcctonermanagement")
public class TonerController {

    @Autowired
    private AppUserService appUserService;

    @Autowired
    private TonerService tonerService;

    @Autowired
    private AuthenticationManager authenticationManager;

    @Value("${toner.upload.path:gcctonermanagementfiles}")
    private String tonerUploadPathConfig;

    @GetMapping({ "", "/", "/upload" })
    public String viewDashboard(Model model, HttpSession session) {
        String username = (String) session.getAttribute("toner_usrName");
        if (username == null) {
            return "redirect:/gcctonermanagement/login";
        }

        String usrRole = (String) session.getAttribute("toner_usrRole");
        boolean isAdmin = "ADMIN".equalsIgnoreCase(usrRole);

        // List<Map<String, Object>> vendorDetails =
        // appUserService.getVendorDetailsWithCounts();

        model.addAttribute("isLoggedIn", true);
        model.addAttribute("isAdmin", isAdmin);
        model.addAttribute("usrName", username);
        model.addAttribute("curPage", "gcctonermanagement");
        // model.addAttribute("vendorDetails", vendorDetails);

        return "gcctonermanagement/upload";
    }

    @GetMapping("/login")
    public String login(HttpSession session) {
        return "gcctonermanagement/login";
    }

    @PostMapping("/api/login")
    @ResponseBody
    public Map<String, Object> validateLogin(
            @RequestParam("usrName") String usrName,
            @RequestParam("usrPass") String usrPass,
            HttpSession session) {

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

        try {
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(usrName,
                    usrPass);
            Authentication authentication = authenticationManager.authenticate(authenticationToken);

            SecurityContextHolder.getContext().setAuthentication(authentication);
            session.setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY,
                    SecurityContextHolder.getContext());

            String role = authentication.getAuthorities().stream()
                    .map(auth -> auth.getAuthority().replace("ROLE_", ""))
                    .findFirst()
                    .orElse("USER");

            session.setAttribute("toner_usrName", usrName);
            session.setAttribute("toner_usrRole", role);
            session.setMaxInactiveInterval(1800); // 30 minutes session timeout
            response.put("result", true);
            response.put("usrName", usrName);
        } catch (AuthenticationException e) {
            response.put("result", false);
            response.put("error", e.getMessage() != null ? e.getMessage() : "Invalid username or password!");
        }

        return response;
    }

    @GetMapping("/logout")
    public String logoutGet(HttpSession session, HttpServletRequest request) {
        SecurityContextHolder.clearContext();
        if (session != null) {
            session.removeAttribute("toner_usrName");
            session.removeAttribute("toner_usrRole");
            session.invalidate();
        }
        request.getSession(true);
        return "redirect:/gcctonermanagement/login";
    }

    @GetMapping("/api/printers")
    @ResponseBody
    public List<Map<String, Object>> getPrinters(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getActivePrinters();
    }

    @GetMapping("/api/toners")
    @ResponseBody
    public List<Map<String, Object>> getToners(@RequestParam("pid") int pid, HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getActiveTonersByPrinter(pid);
    }

    @GetMapping("/api/departments")
    @ResponseBody
    public List<Map<String, Object>> getDepartments(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getActiveDepartments();
    }

    @GetMapping("/api/zones")
    @ResponseBody
    public List<Map<String, Object>> getZones(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getActiveZones();
    }

    @PostMapping("/api/inward")
    @ResponseBody
    public Map<String, Object> uploadInward(
            @RequestParam("refNo") String refNo,
            @RequestParam("companyName") String companyName,
            @RequestParam("itemsJson") String itemsJson,
            @RequestParam(value = "dcFile", required = false) MultipartFile dcFile,
            HttpSession session) {

        Map<String, Object> response = new HashMap<>();
        String username = (String) session.getAttribute("toner_usrName");
        if (username == null) {
            response.put("success", false);
            response.put("error", "Unauthorized access. Please log in.");
            return response;
        }

        String updatedBy = appUserService.getUserIdByName(username);
        if (updatedBy == null)
            updatedBy = username;

        if (dcFile == null || dcFile.isEmpty()) {
            response.put("success", false);
            response.put("error", "Delivery Challan (DC) PDF file is required.");
            return response;
        }

        if (!isPdfFile(dcFile)) {
            response.put("success", false);
            response.put("error", "Delivery Challan file must be a PDF.");
            return response;
        }

        try {
            ObjectMapper mapper = new ObjectMapper();
            List<Map<String, Object>> items = mapper.readValue(itemsJson,
                    new TypeReference<List<Map<String, Object>>>() {
                    });

            if (items == null || items.isEmpty()) {
                response.put("success", false);
                response.put("error", "Please enter quantity for at least one model.");
                return response;
            }

            File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
            if (!uploadDir.exists()) {
                uploadDir.mkdirs();
            }

            String dcPath = saveUploadedFile(dcFile, "dc", uploadDir);

            boolean saved = tonerService.saveInwardRegister(
                    refNo.trim(), companyName.trim(), items, dcPath, updatedBy);

            if (saved) {
                response.put("success", true);
                response.put("message", "Inward stock registered successfully.");
            } else {
                deleteFileIfExists(dcPath, uploadDir);
                response.put("success", false);
                response.put("error", "Failed to save inward details in the database.");
            }
        } catch (Exception e) {
            response.put("success", false);
            response.put("error", "An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
        return response;
    }

    @PostMapping("/api/request")
    @ResponseBody
    public Map<String, Object> uploadRequest(
            @RequestParam("itcellRefNo") String itcellRefNo,
            @RequestParam("deptId") String deptId,
            @RequestParam(value = "zoneId", required = false) String zoneId,
            @RequestParam("itemsJson") String itemsJson,
            @RequestParam(value = "userRequestFile", required = false) MultipartFile userRequestFile,
            HttpSession session) {

        Map<String, Object> response = new HashMap<>();
        String username = (String) session.getAttribute("toner_usrName");
        if (username == null) {
            response.put("success", false);
            response.put("error", "Unauthorized access. Please log in.");
            return response;
        }

        String updatedBy = appUserService.getUserIdByName(username);
        if (updatedBy == null)
            updatedBy = username;

        if (userRequestFile == null || userRequestFile.isEmpty()) {
            response.put("success", false);
            response.put("error", "User Request Letter PDF file is required.");
            return response;
        }

        if (!isPdfFile(userRequestFile)) {
            response.put("success", false);
            response.put("error", "User Request file must be a PDF.");
            return response;
        }

        try {
            ObjectMapper mapper = new ObjectMapper();
            List<Map<String, Object>> items = mapper.readValue(itemsJson,
                    new TypeReference<List<Map<String, Object>>>() {
                    });

            if (items == null || items.isEmpty()) {
                response.put("success", false);
                response.put("error", "Please add at least one printer/toner model request entry.");
                return response;
            }

            File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
            if (!uploadDir.exists()) {
                uploadDir.mkdirs();
            }

            String urPath = saveUploadedFile(userRequestFile, "user_request", uploadDir);

            String safeZoneId = (zoneId != null && !zoneId.trim().isEmpty()) ? zoneId.trim() : null;
            boolean saved = tonerService.saveUserRequest(
                    itcellRefNo.trim(), deptId.trim(), safeZoneId, items, urPath, updatedBy);

            if (saved) {
                response.put("success", true);
                response.put("message", "User request saved successfully.");
            } else {
                deleteFileIfExists(urPath, uploadDir);
                response.put("success", false);
                response.put("error", "Failed to save request details in the database.");
            }
        } catch (Exception e) {
            response.put("success", false);
            response.put("error", "An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
        return response;
    }

    @PostMapping("/api/request/update")
    @ResponseBody
    public Map<String, Object> updateRequest(
            @RequestParam("id") int id,
            @RequestParam("itcellRefNo") String itcellRefNo,
            @RequestParam("deptId") String deptId,
            @RequestParam(value = "zoneId", required = false) String zoneId,
            @RequestParam("pid") int pid,
            @RequestParam("tid") int tid,
            @RequestParam("qtyRequested") int qtyRequested,
            @RequestParam(value = "userRequestFile", required = false) MultipartFile userRequestFile,
            HttpSession session) {

        Map<String, Object> response = new HashMap<>();
        String username = (String) session.getAttribute("toner_usrName");
        if (username == null) {
            response.put("success", false);
            response.put("error", "Unauthorized access. Please log in.");
            return response;
        }

        String updatedBy = appUserService.getUserIdByName(username);
        if (updatedBy == null)
            updatedBy = username;

        if (itcellRefNo == null || itcellRefNo.trim().isEmpty()) {
            response.put("success", false);
            response.put("error", "IT Cell Reference No. is required.");
            return response;
        }

        if (deptId == null || deptId.trim().isEmpty()) {
            response.put("success", false);
            response.put("error", "Department is required.");
            return response;
        }

        if (qtyRequested <= 0) {
            response.put("success", false);
            response.put("error", "Quantity requested must be greater than 0.");
            return response;
        }

        if (userRequestFile != null && !userRequestFile.isEmpty() && !isPdfFile(userRequestFile)) {
            response.put("success", false);
            response.put("error", "User Request file must be a PDF.");
            return response;
        }

        try {
            File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
            if (!uploadDir.exists()) {
                uploadDir.mkdirs();
            }

            String urPath = null;
            if (userRequestFile != null && !userRequestFile.isEmpty()) {
                urPath = saveUploadedFile(userRequestFile, "user_request", uploadDir);
            }

            String safeZoneId = (zoneId != null && !zoneId.trim().isEmpty()) ? zoneId.trim() : null;
            boolean updated = tonerService.updateUserRequest(
                    id, itcellRefNo.trim(), deptId.trim(), safeZoneId, pid, tid, qtyRequested, urPath, updatedBy);

            if (updated) {
                response.put("success", true);
                response.put("message", "User request details updated successfully.");
            } else {
                if (urPath != null) {
                    deleteFileIfExists(urPath, uploadDir);
                }
                response.put("success", false);
                response.put("error", "Failed to update user request details in database.");
            }
        } catch (Exception e) {
            response.put("success", false);
            response.put("error", "An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
        return response;
    }

    @PostMapping("/api/outward")
    @ResponseBody
    public Map<String, Object> uploadOutward(
            @RequestParam("id") int id,
            @RequestParam("qtyIssued") String qtyIssued,
            @RequestParam(value = "finalDeliveredFile", required = false) MultipartFile finalDeliveredFile,
            @RequestParam(value = "userPhotoFile", required = false) MultipartFile userPhotoFile,
            @RequestParam(value = "userPhotoBase64", required = false) String userPhotoBase64,
            HttpSession session) {

        Map<String, Object> response = new HashMap<>();
        String username = (String) session.getAttribute("toner_usrName");
        if (username == null) {
            response.put("success", false);
            response.put("error", "Unauthorized access. Please log in.");
            return response;
        }

        String updatedBy = appUserService.getUserIdByName(username);
        if (updatedBy == null)
            updatedBy = username;

        if (finalDeliveredFile != null && !finalDeliveredFile.isEmpty()) {
            if (!isPdfFile(finalDeliveredFile)) {
                response.put("success", false);
                response.put("error", "Final Delivered file must be a PDF.");
                return response;
            }
            boolean hasPhoto = (userPhotoFile != null && !userPhotoFile.isEmpty())
                    || (userPhotoBase64 != null && !userPhotoBase64.trim().isEmpty());
            if (!hasPhoto) {
                response.put("success", false);
                response.put("error", "Receiver / User photo is mandatory.");
                return response;
            }
        }

        if (userPhotoFile != null && !userPhotoFile.isEmpty() && !isImageFile(userPhotoFile)) {
            response.put("success", false);
            response.put("error", "User photo must be a valid image file (JPG, PNG, WEBP).");
            return response;
        }

        Map<String, Object> req = tonerService.getUserRequestById(id);
        if (req == null) {
            response.put("success", false);
            response.put("error", "Invalid or non-existent request ID: " + id);
            return response;
        }

        boolean isInitialDelivery = (finalDeliveredFile == null || finalDeliveredFile.isEmpty()) &&
                (userPhotoFile == null || userPhotoFile.isEmpty()) &&
                (userPhotoBase64 == null || userPhotoBase64.trim().isEmpty());

        if (isInitialDelivery) {
            int issueQty = 0;
            try {
                issueQty = Integer.parseInt(qtyIssued.trim());
            } catch (Exception e) {
                response.put("success", false);
                response.put("error", "Invalid quantity issued value.");
                return response;
            }

            if (issueQty <= 0) {
                response.put("success", false);
                response.put("error", "Quantity issued must be greater than zero.");
                return response;
            }

            String pid = String.valueOf(req.get("pid"));
            String tid = String.valueOf(req.get("tid"));
            String modelName = req.get("model_name") != null ? String.valueOf(req.get("model_name")) : "Toner";
            String printerName = req.get("printer_name") != null ? String.valueOf(req.get("printer_name")) : "Printer";

            int availableStock = tonerService.getAvailableStockForModel(pid, tid);

            if (availableStock <= 0) {
                response.put("success", false);
                response.put("error", "Cannot issue: No inward stock available for " + printerName + " - " + modelName
                        + ". Please register inward stock before issuing outward delivery.");
                return response;
            }

            if (issueQty > availableStock) {
                response.put("success", false);
                response.put("error",
                        "Cannot issue: Quantity to issue (" + issueQty + ") exceeds available inward stock ("
                                + availableStock + ") for " + printerName + " - " + modelName + ".");
                return response;
            }

            int requestedQty = 0;
            int alreadyDelivered = 0;
            try {
                if (req.get("qty_requested") != null) {
                    requestedQty = Integer.parseInt(String.valueOf(req.get("qty_requested")));
                }
                if (req.get("qty_delivered") != null) {
                    alreadyDelivered = Integer.parseInt(String.valueOf(req.get("qty_delivered")));
                }
            } catch (Exception ignored) {
            }

            int remainingReq = Math.max(0, requestedQty - alreadyDelivered);
            if (issueQty > remainingReq) {
                response.put("success", false);
                response.put("error", "Cannot issue: Quantity to issue (" + issueQty
                        + ") exceeds remaining requested quantity (" + remainingReq + ").");
                return response;
            }
        }

        try {
            File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
            if (!uploadDir.exists()) {
                uploadDir.mkdirs();
            }

            String fdPath = saveUploadedFile(finalDeliveredFile, "final_delivered", uploadDir);
            String photoPath = null;
            if (userPhotoFile != null && !userPhotoFile.isEmpty()) {
                photoPath = saveUploadedFile(userPhotoFile, "receiver_photo", uploadDir);
            } else if (userPhotoBase64 != null && !userPhotoBase64.trim().isEmpty()) {
                photoPath = saveBase64Image(userPhotoBase64, "receiver_photo", uploadDir);
            }

            boolean saved = tonerService.saveOutwardRegister(
                    id, qtyIssued.trim(), fdPath, photoPath, updatedBy);

            if (saved) {
                response.put("success", true);
                response.put("message", "Outward delivery recorded successfully.");
            } else {
                deleteFileIfExists(fdPath, uploadDir);
                deleteFileIfExists(photoPath, uploadDir);
                response.put("success", false);
                response.put("error", "Failed to update outward details in the database.");
            }
        } catch (Exception e) {
            response.put("success", false);
            response.put("error", "An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
        return response;
    }

    @PostMapping("/api/workorder")
    @ResponseBody
    public Map<String, Object> saveWorkorder(
            @RequestParam("fileNumber") String fileNumber,
            @RequestParam("vendorName") String vendorName,
            @RequestParam("startDate") String startDate,
            @RequestParam("endDate") String endDate,
            @RequestParam("totalQty") String totalQty,
            @RequestParam("itemsJson") String itemsJson,
            @RequestParam("dcFile") MultipartFile dcFile,
            HttpSession session) {

        Map<String, Object> response = new HashMap<>();
        String username = (String) session.getAttribute("toner_usrName");
        if (username == null) {
            response.put("success", false);
            response.put("error", "Unauthorized access. Please log in.");
            return response;
        }

        String updatedBy = appUserService.getUserIdByName(username);
        if (updatedBy == null)
            updatedBy = username;

        if (dcFile == null || dcFile.isEmpty()) {
            response.put("success", false);
            response.put("error", "Delivery Challan (DC) PDF upload file is required.");
            return response;
        }

        if (!isPdfFile(dcFile)) {
            response.put("success", false);
            response.put("error", "Delivery Challan file must be a PDF.");
            return response;
        }

        // Auto-generate refNo: ITCell-YYYY/MM/DD/XXXX
        java.time.LocalDate today = java.time.LocalDate.now();
        int randomNum = (int) (Math.random() * 9000) + 1000; // 4-digit random number
        String refNo = String.format("ITCell-%d/%02d/%02d/%d", today.getYear(), today.getMonthValue(),
                today.getDayOfMonth(), randomNum);

        try {
            ObjectMapper mapper = new ObjectMapper();
            List<Map<String, Object>> items = mapper.readValue(itemsJson,
                    new TypeReference<List<Map<String, Object>>>() {
                    });

            if (items == null || items.isEmpty()) {
                response.put("success", false);
                response.put("error", "Please add at least one printer/toner model quantity entry.");
                return response;
            }

            File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
            if (!uploadDir.exists()) {
                uploadDir.mkdirs();
            }

            String dcPath = saveUploadedFile(dcFile, "workorder_dc", uploadDir);

            boolean saved = tonerService.saveWorkorder(
                    refNo, fileNumber.trim(), vendorName.trim(),
                    startDate, endDate, dcPath, totalQty.trim(), items, updatedBy);

            if (saved) {
                response.put("success", true);
                response.put("refNo", refNo);
                response.put("message", "Workorder registered successfully.");
            } else {
                deleteFileIfExists(dcPath, uploadDir);
                response.put("success", false);
                response.put("error", "Failed to save workorder details in the database.");
            }
        } catch (Exception e) {
            response.put("success", false);
            response.put("error", "An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
        return response;
    }

    @GetMapping("/api/report")
    @ResponseBody
    public Map<String, Object> getReportData(HttpSession session) {
        Map<String, Object> response = new HashMap<>();
        if (session.getAttribute("toner_usrName") == null) {
            response.put("success", false);
            return response;
        }
        response.put("success", true);
        response.put("metrics", tonerService.getDashboardMetrics());
        response.put("summary", tonerService.getInventorySummary());
        return response;
    }

    @GetMapping("/api/requests/pending")
    @ResponseBody
    public List<Map<String, Object>> getPendingRequestsData(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getPendingRequests();
    }

    @GetMapping("/api/inward/list")
    @ResponseBody
    public List<Map<String, Object>> getInwardListData(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getInwardHistory();
    }

    @GetMapping("/api/requests/list")
    @ResponseBody
    public List<Map<String, Object>> getUserRequestsListData(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getAllUserRequests();
    }

    @GetMapping("/api/outward/list")
    @ResponseBody
    public List<Map<String, Object>> getOutwardListData(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getOutwardHistory();
    }

    private boolean isPdfFile(MultipartFile file) {
        String originalFilename = file.getOriginalFilename();
        if (originalFilename == null)
            return false;
        return originalFilename.toLowerCase().endsWith(".pdf");
    }

    private boolean isImageFile(MultipartFile file) {
        String originalFilename = file.getOriginalFilename();
        if (originalFilename == null)
            return false;
        String lower = originalFilename.toLowerCase();
        return lower.endsWith(".jpg") || lower.endsWith(".jpeg") || lower.endsWith(".png") || lower.endsWith(".webp")
                || lower.endsWith(".gif");
    }

    private String saveUploadedFile(MultipartFile file, String prefix, File uploadDir) throws Exception {
        if (file == null || file.isEmpty()) {
            return null;
        }
        String originalFilename = file.getOriginalFilename();
        String ext = ".pdf";
        if (originalFilename != null && originalFilename.lastIndexOf('.') > 0) {
            ext = originalFilename.substring(originalFilename.lastIndexOf('.')).toLowerCase();
        }

        // Clean filename, make it unique
        String savedFilename = prefix + "_" + System.currentTimeMillis() + ext;
        File destFile = new File(uploadDir, savedFilename).getAbsoluteFile();
        file.transferTo(destFile);

        return "gcctonermanagementfiles/" + savedFilename;
    }

    private String saveBase64Image(String base64Data, String prefix, File uploadDir) throws Exception {
        if (base64Data == null || base64Data.trim().isEmpty()) {
            return null;
        }
        String cleanData = base64Data.trim();
        String ext = ".jpg";
        if (cleanData.contains("data:image/png;base64,")) {
            ext = ".png";
            cleanData = cleanData.replace("data:image/png;base64,", "");
        } else if (cleanData.contains("data:image/jpeg;base64,")) {
            ext = ".jpg";
            cleanData = cleanData.replace("data:image/jpeg;base64,", "");
        } else if (cleanData.contains("data:image/webp;base64,")) {
            ext = ".webp";
            cleanData = cleanData.replace("data:image/webp;base64,", "");
        } else if (cleanData.startsWith("data:") && cleanData.contains(";base64,")) {
            cleanData = cleanData.substring(cleanData.indexOf(";base64,") + 8);
        }

        byte[] decodedBytes = java.util.Base64.getDecoder().decode(cleanData);
        String savedFilename = prefix + "_" + System.currentTimeMillis() + ext;
        File destFile = new File(uploadDir, savedFilename).getAbsoluteFile();
        try (java.io.FileOutputStream fos = new java.io.FileOutputStream(destFile)) {
            fos.write(decodedBytes);
        }
        return "gcctonermanagementfiles/" + savedFilename;
    }

    private void deleteFileIfExists(String webPath, File uploadDir) {
        if (webPath == null || webPath.isEmpty())
            return;
        try {
            String filename = webPath.substring(webPath.lastIndexOf('/') + 1);
            File file = new File(uploadDir, filename).getAbsoluteFile();
            if (file.exists()) {
                file.delete();
            }
        } catch (Exception e) {
            System.err.println("Error deleting file: " + e.getMessage());
        }
    }

    @GetMapping("/api/workorders/active")
    @ResponseBody
    public List<String> getActiveWorkorderRefNos(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return new ArrayList<>();
        }
        return tonerService.getActiveWorkorderRefNos();
    }

    @GetMapping("/api/workorders/items")
    @ResponseBody
    public List<Map<String, Object>> getWorkorderRegisteredItems(
            @RequestParam("refNo") String refNo,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return new ArrayList<>();
        }
        return tonerService.getWorkorderRegisteredItems(refNo);
    }

    @GetMapping("/api/workorder/history")
    @ResponseBody
    public List<Map<String, Object>> getWorkorderRegisterHistory(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return new ArrayList<>();
        }
        return tonerService.getWorkorderRegisterHistory();
    }

    @PostMapping("/api/workorder-request")
    @ResponseBody
    public Map<String, Object> uploadWorkorderModelRequest(
            @RequestParam("refNo") String refNo,
            @RequestParam("companyName") String companyName,
            @RequestParam("pid") String pid,
            @RequestParam("itemsJson") String itemsJson,
            @RequestParam("emailCopyFile") MultipartFile emailCopyFile,
            HttpSession session) {

        Map<String, Object> response = new HashMap<>();
        String username = (String) session.getAttribute("toner_usrName");
        if (username == null) {
            response.put("success", false);
            response.put("error", "Unauthorized access. Please log in.");
            return response;
        }

        String updatedBy = appUserService.getUserIdByName(username);
        if (updatedBy == null)
            updatedBy = username;

        if (emailCopyFile == null || emailCopyFile.isEmpty()) {
            response.put("success", false);
            response.put("error", "Email copy PDF upload file is required.");
            return response;
        }

        if (!isPdfFile(emailCopyFile)) {
            response.put("success", false);
            response.put("error", "Email copy file must be a PDF.");
            return response;
        }

        try {
            ObjectMapper mapper = new ObjectMapper();
            List<Map<String, Object>> items = mapper.readValue(itemsJson,
                    new TypeReference<List<Map<String, Object>>>() {
                    });

            if (items == null || items.isEmpty()) {
                response.put("success", false);
                response.put("error", "Please add at least one toner model quantity entry.");
                return response;
            }

            File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
            if (!uploadDir.exists()) {
                uploadDir.mkdirs();
            }

            String ecPath = saveUploadedFile(emailCopyFile, "workorder_request_email",
                    uploadDir);

            boolean saved = tonerService.saveWorkorderModelRequest(
                    refNo.trim(), companyName.trim(), pid.trim(), items, ecPath, updatedBy);

            if (saved) {
                response.put("success", true);
                response.put("message",
                        "Workorder model request details saved successfully.");
            } else {
                deleteFileIfExists(ecPath, uploadDir);
                response.put("success", false);
                response.put("error",
                        "Failed to save workorder request details in the database.");
            }
        } catch (Exception e) {
            response.put("success", false);
            response.put("error", "An error occurred: " + e.getMessage());
            e.printStackTrace();
        }
        return response;
    }

    @GetMapping("/api/workorders/active-requests")
    @ResponseBody
    public List<String> getActiveWorkorderRequestRefNos(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return new ArrayList<>();
        }
        return tonerService.getActiveWorkorderRequestRefNos();
    }

    @GetMapping("/api/workorders/requests")
    @ResponseBody
    public List<Map<String, Object>> getWorkorderRequests(
            @RequestParam("refNo") String refNo,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return new ArrayList<>();
        }
        return tonerService.getWorkorderRequests(refNo);
    }

    @GetMapping("/api/workorder-request/history")
    @ResponseBody
    public List<Map<String, Object>> getWorkorderModelRequestHistory(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return new ArrayList<>();
        }
        return tonerService.getWorkorderModelRequestHistory();
    }

    // Save new department for workorder
    @PostMapping("/api/savedepartment")
    @ResponseBody
    public boolean saveNewDepartment(
            @RequestParam("department") String department,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }

        return tonerService.savenewdepartment(department);
    }

    @PostMapping("/api/savetonermodel")
    @ResponseBody
    public boolean saveNewTonerModel(
            @RequestParam("tonermodel") String tonermodel,
            @RequestParam("pid") int pid,
            @RequestParam(required = false) String partCode,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }

        return tonerService.savetonermodel(pid, tonermodel, partCode);
    }

    @PostMapping("/api/saveprintermodel")
    @ResponseBody
    public boolean saveNewPrinterModel(
            @RequestParam("printermodel") String printermodel,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.saveprintermodel(printermodel);
    }

    // ================= MASTER UPDATE ENDPOINTS =================

    @PostMapping("/api/updateprintermodel")
    @ResponseBody
    public boolean updatePrinterModel(
            @RequestParam("id") int id,
            @RequestParam("printermodel") String printermodel,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.updatePrinterModel(id, printermodel);
    }

    @PostMapping("/api/updatetonermodel")
    @ResponseBody
    public boolean updateTonerModel(
            @RequestParam("id") int id,
            @RequestParam("pid") int pid,
            @RequestParam("tonermodel") String tonermodel,
            @RequestParam(value = "partCode", required = false) String partCode,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.updateTonerModel(id, pid, tonermodel, partCode);
    }

    @PostMapping("/api/updatedepartment")
    @ResponseBody
    public boolean updateDepartment(
            @RequestParam("id") int id,
            @RequestParam("department") String department,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.updateDepartment(id, department);
    }

    // ================= MASTER DELETE & RESTORE ENDPOINTS =================

    @PostMapping("/api/deleteprintermodel")
    @ResponseBody
    public boolean deletePrinterModel(@RequestParam("id") int id, HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.deletePrinterModel(id);
    }

    @PostMapping("/api/restoreprintermodel")
    @ResponseBody
    public boolean restorePrinterModel(@RequestParam("id") int id, HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.restorePrinterModel(id);
    }

    @PostMapping("/api/deletetonermodel")
    @ResponseBody
    public boolean deleteTonerModel(@RequestParam("id") int id, HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.deleteTonerModel(id);
    }

    @PostMapping("/api/restoretonermodel")
    @ResponseBody
    public boolean restoreTonerModel(@RequestParam("id") int id, HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.restoreTonerModel(id);
    }

    @PostMapping("/api/deletedepartment")
    @ResponseBody
    public boolean deleteDepartment(@RequestParam("id") int id, HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.deleteDepartment(id);
    }

    @PostMapping("/api/restoredepartment")
    @ResponseBody
    public boolean restoreDepartment(@RequestParam("id") int id, HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return false;
        }
        return tonerService.restoreDepartment(id);
    }

    // ================= MASTER LISTING ENDPOINTS =================

    @GetMapping("/api/master/printers")
    @ResponseBody
    public List<Map<String, Object>> getMasterPrinters(
            @RequestParam(value = "status", defaultValue = "active") String status,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getMasterPrinters(status);
    }

    @GetMapping("/api/master/toners")
    @ResponseBody
    public List<Map<String, Object>> getMasterToners(
            @RequestParam(value = "status", defaultValue = "active") String status,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getMasterToners(status);
    }

    @GetMapping("/api/master/departments")
    @ResponseBody
    public List<Map<String, Object>> getMasterDepartments(
            @RequestParam(value = "status", defaultValue = "active") String status,
            HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getMasterDepartments(status);
    }

    @GetMapping("/api/toners/all")
    @ResponseBody
    public List<Map<String, Object>> getAllToners(HttpSession session) {
        if (session.getAttribute("toner_usrName") == null) {
            return java.util.Collections.emptyList();
        }
        return tonerService.getAllActiveToners();
    }

}