package com.ruoyi.web.controller.imagedata;

import com.ruoyi.common.annotation.Anonymous;
import com.ruoyi.common.annotation.DataSource;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.config.LegacySystemConfig;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.enums.DataSourceType;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.InputStreamBase64Converter;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.system.file.FileUploadResponse;
import com.ruoyi.system.file.IFileUploadService;
import com.ruoyi.system.imagedata.IImageDataService;
import com.ruoyi.system.domain.ImageData;
import com.ruoyi.system.domain.enums.ImageTypeEnum;
import com.ruoyi.system.imagedata.WxImageUploadRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.util.*;
import java.util.List;

/**
 * 图片数据控制器
 *
 * @author mhyl
 * @date 2024-01-01
 */
@RestController
@DataSource(DataSourceType.SQLSERVER)
@RequestMapping("/hospital/imagedata")
public class ImageDataController extends BaseController {

    private static final Logger log = LoggerFactory.getLogger(ImageDataController.class);
    @Autowired
    private IImageDataService imageDataService;

    @Autowired
    private IFileUploadService fileUploadService;


    @Autowired
    private LegacySystemConfig legacyConfig;
    /**
     * 查询图片数据列表
     */
//    @PreAuthorize("@ss.hasPermi('hospital:imagedata:list')")
    @GetMapping("/list")
    public TableDataInfo list(ImageData imageData) {
//        startPage();
        List<ImageData> list = imageDataService.selectImageDataList(imageData);
        return getDataTable(list);
    }

    /**
     * 导出图片数据列表
     */

    @Log(title = "图片数据", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, ImageData imageData) {
        List<ImageData> list = imageDataService.selectImageDataList(imageData);
        ExcelUtil<ImageData> util = new ExcelUtil<ImageData>(ImageData.class);
        util.exportExcel(response, list, "图片数据数据");
    }

    /**
     * 获取图片数据详细信息
     */

    @GetMapping(value = "/{id}")
    public AjaxResult getInfo(@PathVariable("id") Long id) {
        return AjaxResult.success(imageDataService.selectImageDataById(id));
    }

    /**
     * 新增图片数据
     */

    @Log(title = "图片数据", businessType = BusinessType.INSERT)
    @PostMapping
    public AjaxResult add(@RequestBody ImageData imageData) {
        return toAjax(imageDataService.insertImageData(imageData));
    }

    /**
     * 修改图片数据
     */
    @Log(title = "图片数据", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody ImageData imageData) {
        return toAjax(imageDataService.updateImageData(imageData));
    }

    /**
     * 删除图片数据
     */
    @Log(title = "图片数据", businessType = BusinessType.DELETE)
    @DeleteMapping("/{ids}")
    public AjaxResult remove(@PathVariable Long[] ids) {
        return toAjax(imageDataService.deleteImageDataByIds(ids));
    }

    /**
     * 根据调度单ID查询图片数据
     */
    @GetMapping("/byDispatchOrder/{dispatchOrdID}")
    public AjaxResult getByDispatchOrder(@PathVariable("dispatchOrdID") Long dispatchOrdID) {
        List<ImageData> list = imageDataService.selectImageDataByDOrdIDDt(dispatchOrdID);
        return AjaxResult.success(list);
    }

    /**
     * 根据调度单ID和图片类型获取有效图片（包含完整链接）
     *
     * @param dispatchOrdID 调度单ID
     * @param imageType 图片类型
     * @return 图片数据（包含完整链接）
     */
//    @PreAuthorize("@ss.hasPermi('hospital:imagedata:query')")
    @Anonymous()
    @GetMapping("/byDispatchOrderAndType/{dispatchOrdID}/{imageType}")
    public AjaxResult getByDispatchOrderAndType(@PathVariable("dispatchOrdID") Long dispatchOrdID,
                                                @PathVariable("imageType") Integer imageType) {
        try {
            // 查询指定调度单和类型的有效图片
            List<ImageData> imageDataList = imageDataService.selectImageDataByDOrdIDDtAndType(dispatchOrdID, imageType);

            // 过滤有效图片（未删除的）
            List<ImageData> validImages = imageDataList.stream()
                    .filter(img -> img.getImageDel() == null || img.getImageDel() == 0)
                    .collect(java.util.stream.Collectors.toList());

            // 为每个图片添加完整链接
            for (ImageData imageData : validImages) {
                // 添加原始图片完整链接
                if (StringUtils.hasText(imageData.getImageUrl())) {
                    String fullImageUrl = buildFullImageUrl(imageData.getImageUrl());
                    imageData.setImageUrl(fullImageUrl);
                }

                // 添加缩略图完整链接
                if (StringUtils.hasText(imageData.getImageUrls())) {
                    String fullThumbnailUrl = buildFullImageUrl(imageData.getImageUrls());
                    imageData.setImageUrls(fullThumbnailUrl);
                }
            }

            return AjaxResult.success("获取图片成功", validImages);
        } catch (Exception e) {
            return AjaxResult.error("获取图片失败：" + e.getMessage());
        }
    }

    /**
     * 根据调度单ID和图片类型获取有效图片（简化版，只返回图片链接）
     *
     * @param dispatchOrdID 调度单ID
     * @param imageType 图片类型
     * @return 图片链接列表
     */
    // @PreAuthorize("@ss.hasPermi('hospital:imagedata:query')")
    @Anonymous()
    @GetMapping("/links/byDispatchOrderAndType/{dispatchOrdID}/{imageType}")
    public AjaxResult getImageLinksByDispatchOrderAndType(@PathVariable("dispatchOrdID") Long dispatchOrdID,
                                                          @PathVariable("imageType") Integer imageType) {
        try {
            // 查询指定调度单和类型的有效图片
            List<ImageData> imageDataList = imageDataService.selectImageDataByDOrdIDDtAndType(dispatchOrdID, imageType);

            // 构建图片链接列表
            List<java.util.Map<String, String>> imageLinks = new java.util.ArrayList<>();

            for (ImageData imageData : imageDataList) {
                // 只处理未删除的图片
                if (imageData.getImageDel() == null || imageData.getImageDel() == 0) {
                    java.util.Map<String, String> linkMap = new java.util.HashMap<>();

                    // 原始图片链接
                    if (StringUtils.hasText(imageData.getImageUrl())) {
                        linkMap.put("originalUrl", buildFullImageUrl(imageData.getImageUrl()));
                    }

                    // 缩略图链接
                    if (StringUtils.hasText(imageData.getImageUrls())) {
                        linkMap.put("thumbnailUrl", buildFullImageUrl(imageData.getImageUrls()));
                    }

                    // 图片ID
                    linkMap.put("imageId", String.valueOf(imageData.getId()));

                    // 图片类型
                    linkMap.put("imageType", String.valueOf(imageData.getImageType()));

                    // 上传时间
                    if (imageData.getUpImageTime() != null) {
                        linkMap.put("uploadTime", DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, imageData.getUpImageTime()));
                    }

                    imageLinks.add(linkMap);
                }
            }

            return AjaxResult.success("获取图片链接成功", imageLinks);
        } catch (Exception e) {
            return AjaxResult.error("获取图片链接失败：" + e.getMessage());
        }
    }

    /**
     * 构建完整的图片URL
     *
     * @param imagePath 图片路径
     * @return 完整的图片URL
     */
    private String buildFullImageUrl(String imagePath) {
        if (!StringUtils.hasText(imagePath)) {
            return "";
        }

        // 如果已经是完整URL，直接返回
        if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
            return imagePath;
        }

        // 从配置中读取文件服务器URL
        String fileServerUrl = legacyConfig.getFileServerUrl();

        // 如果配置中没有设置，使用默认值
        if (!StringUtils.hasText(fileServerUrl)) {
            // 记录警告日志
            System.err.println("警告：配置文件中未设置 legacy.system.fileServerUrl，使用默认值");
            fileServerUrl = "https://sync.966120.com.cn";
        }

        // 确保文件服务器URL不以/结尾
        if (fileServerUrl.endsWith("/")) {
            fileServerUrl = fileServerUrl.substring(0, fileServerUrl.length() - 1);
        }

        // 处理图片路径：移除开头和结尾的空白字符
        imagePath = imagePath.trim();

        // 移除开头和结尾的斜杠
        while (imagePath.startsWith("/")) {
            imagePath = imagePath.substring(1);
        }
        while (imagePath.endsWith("/")) {
            imagePath = imagePath.substring(0, imagePath.length() - 1);
        }

        // 处理反斜杠：将反斜杠替换为正斜杠
        imagePath = imagePath.replace("\\", "/");

        // 移除路径中可能的重复斜杠
        imagePath = imagePath.replaceAll("/+", "/");

        // 确保图片路径以/开头
        if (!imagePath.startsWith("/")) {
            imagePath = "/" + imagePath;
        }

        // 构建完整URL
        String fullUrl = fileServerUrl + imagePath;

        // 记录调试信息
        System.out.println("构建图片URL - 配置URL: " + fileServerUrl + ", 图片路径: " + imagePath + ", 完整URL: " + fullUrl);

        return fullUrl;
    }

    /**
     * 根据服务单ID查询图片数据
     */
    @PreAuthorize("@ss.hasPermi('hospital:imagedata:query')")
    @GetMapping("/byServiceOrder/{serviceOrdID}")
    public AjaxResult getByServiceOrder(@PathVariable("serviceOrdID") Long serviceOrdID) {
        List<ImageData> list = imageDataService.selectImageDataBySOrdIDDt(serviceOrdID);
        return AjaxResult.success(list);
    }

    /**
     * 根据图片类型查询图片数据
     */
    @PreAuthorize("@ss.hasPermi('hospital:imagedata:query')")
    @GetMapping("/byType/{imageType}")
    public AjaxResult getByType(@PathVariable("imageType") Integer imageType) {
        List<ImageData> list = imageDataService.selectImageDataByType(imageType);
        return AjaxResult.success(list);
    }

    /**
     * 标记图片为删除状态
     */
    @PreAuthorize("@ss.hasPermi('hospital:imagedata:remove')")
    @Log(title = "标记图片删除", businessType = BusinessType.DELETE)
    @PutMapping("/markDelete/{id}")
    public AjaxResult markDelete(@PathVariable("id") Long id) {
        return toAjax(imageDataService.markImageDataAsDeleted(id));
    }

    /**
     * 微信图片上传处理（原ASP代码转换）
     */
    @Log(title = "微信图片上传", businessType = BusinessType.INSERT)
    @PostMapping("/uploadWxImage")
    public AjaxResult uploadWxImage(@RequestBody WxImageUploadRequest request) {

        // 获取当前登录用户ID
        Integer adminId = getUserId().intValue();

        String result = imageDataService.uploadWxImage(
                request.getDispatchOrdID(),
                request.getServiceOrdID(),
                request.getOaid(),
                request.getMediaId(),
                request.getImageType(),
                adminId
        );

        if (result.contains("成功")) {
            return success(result);
        } else {
            return error(result);
        }
    }

    /**
     * 微信图片上传处理（兼容原有参数格式）
     */
    @Log(title = "微信图片上传", businessType = BusinessType.INSERT)
    @PostMapping("/uploadWxImageForm")
    public AjaxResult uploadWxImageForm(
            @RequestParam(value = "DispatchOrdID", required = false) Long dispatchOrdID,
            @RequestParam(value = "ServiceOrdID", required = false) Long serviceOrdID,
            @RequestParam(value = "OAID", required = false) Integer oaid,
            @RequestParam(value = "media_id", required = true) String mediaId,
            @RequestParam(value = "ImageType", required = false) Integer imageType) {

        // 获取当前登录用户ID
        Integer adminId = getUserId().intValue();

        String result = imageDataService.uploadWxImage(dispatchOrdID, serviceOrdID, oaid, mediaId, imageType, adminId);

        if (result.contains("成功")) {
            return success(result);
        } else {
            return error(result);
        }
    }

    /**
     * 微信图片上传处理（完整版本，包含文件下载和缩略图生成）
     */
    @Log(title = "微信图片上传完整版", businessType = BusinessType.INSERT)
    @PostMapping("/uploadWxImageWithDownload")
    public AjaxResult uploadWxImageWithDownload(@RequestBody WxImageUploadRequest request) {

        // 获取当前登录用户ID
        Integer adminId = getUserId().intValue();

        // 这里需要从配置或请求中获取access_token
        // 实际使用时应该从微信配置或缓存中获取
        String accessToken = request.getAccessToken(); // 需要在WxImageUploadRequest中添加此字段

        if (accessToken == null || accessToken.isEmpty()) {
            return error("缺少微信访问令牌");
        }

        String result = imageDataService.uploadWxImageWithDownload(
                accessToken,
                request.getMediaId(),
                request.getDispatchOrdID(),
                request.getOaid(),
                request.getImageType(),
                adminId
        );

        if (result.contains("成功")) {
            return success(result);
        } else {
            return error(result);
        }
    }

    /**
     * 微信图片上传处理（完整版本，兼容原有参数格式）
     */
    @Log(title = "微信图片上传完整版", businessType = BusinessType.INSERT)
    @PostMapping("/uploadWxImageWithDownloadForm")
    public AjaxResult uploadWxImageWithDownloadForm(
            @RequestParam(value = "access_token", required = true) String accessToken,
            @RequestParam(value = "media_id", required = true) String mediaId,
            @RequestParam(value = "DispatchOrdID", required = false) Long dispatchOrdID,
            @RequestParam(value = "ServiceOrdID", required = false) Long serviceOrdID,
            @RequestParam(value = "OAID", required = false) Integer oaid,
            @RequestParam(value = "ImageType", required = false) Integer imageType) {

        // 获取当前登录用户ID
        Integer adminId = getUserId().intValue();

        String result = imageDataService.uploadWxImageWithDownload(
                accessToken, mediaId, dispatchOrdID, oaid, imageType, adminId);

        if (result.contains("成功")) {
            return success(result);
        } else {
            return error(result);
        }
    }



    /**
     * 生成缩略图
     */
    @Log(title = "生成缩略图", businessType = BusinessType.OTHER)
    @PostMapping("/createThumbnail")
    public AjaxResult createThumbnail(
            @RequestParam(value = "bigImgPath", required = true) String bigImgPath,
            @RequestParam(value = "width", required = true) int width,
            @RequestParam(value = "height", required = false, defaultValue = "0") int height,
            @RequestParam(value = "smallImgPath", required = true) String smallImgPath) {

        boolean result = imageDataService.createThumbnail(bigImgPath, width, height, smallImgPath);

        if (result) {
            return success("缩略图生成成功");
        } else {
            return error("缩略图生成失败");
        }
    }

    /**
     * 检查文件兼容性
     */

    @GetMapping("/checkCompatibility")
    public AjaxResult checkFileCompatibility(@RequestParam("filePath") String filePath) {
        try {
            String result = imageDataService.checkFileCompatibility(filePath);
            return AjaxResult.success("兼容性检查完成", result);
        } catch (Exception e) {
            return AjaxResult.error("兼容性检查失败：" + e.getMessage());
        }
    }

    /**
     * 验证URL格式是否与旧系统兼容
     */
    @GetMapping("/checkUrlCompatibility")
    public AjaxResult checkUrlCompatibility(@RequestParam("url") String url) {
        try {
            boolean isCompatible = imageDataService.isUrlCompatible(url);
            return AjaxResult.success("URL兼容性检查完成", isCompatible);
        } catch (Exception e) {
            return AjaxResult.error("URL兼容性检查失败：" + e.getMessage());
        }
    }

    /**
     * 生成与旧系统兼容的文件路径
     */

    @GetMapping("/generateCompatibleFilePath")
    public AjaxResult generateCompatibleFilePath(@RequestParam("dispatchOrdID") Long dispatchOrdID,
                                                 @RequestParam("mediaId") String mediaId,
                                                 @RequestParam(value = "isThumbnail", defaultValue = "false") boolean isThumbnail) {
        try {
            String filePath = imageDataService.generateCompatibleFilePath(dispatchOrdID, mediaId, isThumbnail);
            return AjaxResult.success("生成兼容文件路径成功", filePath);
        } catch (Exception e) {
            return AjaxResult.error("生成兼容文件路径失败：" + e.getMessage());
        }
    }

    /**
     * 生成与旧系统兼容的访问URL
     */

    @GetMapping("/generateCompatibleUrl")
    public AjaxResult generateCompatibleUrl(@RequestParam("dispatchOrdID") Long dispatchOrdID,
                                            @RequestParam("mediaId") String mediaId,
                                            @RequestParam(value = "isThumbnail", defaultValue = "false") boolean isThumbnail) {
        try {
            String url = imageDataService.generateCompatibleUrl(dispatchOrdID, mediaId, isThumbnail);
            return AjaxResult.success("生成兼容URL成功", url);
        } catch (Exception e) {
            return AjaxResult.error("生成兼容URL失败：" + e.getMessage());
        }
    }


    /**
     * 通过图片URL上传处理（完整版本）
     *
     * @param dispatchOrdID 调度单ID
     * @param serviceOrdID 服务单ID
     * @param oaid OA用户ID
     * @param imageUrl 图片URL
     * @param thumbnailUrl 缩略图URL
     * @param imageType 图片类型
     * @return 处理结果
     */
    @PreAuthorize("@ss.hasPermi('hospital:imagedata:add')")
    @Log(title = "图片URL上传", businessType = BusinessType.INSERT)
    @PostMapping("/uploadByUrl")
    public AjaxResult uploadImageByUrl(@RequestParam(value = "dispatchOrdID", required = false) Long dispatchOrdID,
                                       @RequestParam(value = "serviceOrdID", required = false) Long serviceOrdID,
                                       @RequestParam(value = "oaid", required = false) Integer oaid,
                                       @RequestParam("imageUrl") String imageUrl,
                                       @RequestParam(value = "thumbnailUrl", required = false) String thumbnailUrl,
                                       @RequestParam(value = "imageType", defaultValue = "0") Integer imageType) {
        try {
            // 获取当前管理员ID
            Integer adminId = getUserId().intValue();

            // 调用图片数据服务处理上传
            String result = imageDataService.uploadImageByUrl(dispatchOrdID, serviceOrdID, oaid,
                    imageUrl, thumbnailUrl, imageType, adminId);

            if (result.contains("成功")) {
                return AjaxResult.success("图片URL上传成功", result);
            } else {
                return AjaxResult.error(result);
            }
        } catch (Exception e) {
            return AjaxResult.error("图片URL上传失败：" + e.getMessage());
        }
    }

    /**
     * 通过图片URL上传处理（简化版本）
     *
     * @param dispatchOrdID 调度单ID
     * @param serviceOrdID 服务单ID
     * @param oaid OA用户ID
     * @param imageUrl 图片URL
     * @param imageType 图片类型
     * @return 处理结果
     */
    @Log(title = "图片URL上传简化版", businessType = BusinessType.INSERT)
    @PostMapping("/uploadByUrlSimple")
    public AjaxResult uploadImageByUrlSimple(@RequestParam(value = "dispatchOrdID", required = false) Long dispatchOrdID,
                                             @RequestParam(value = "serviceOrdID", required = false) Long serviceOrdID,
                                             @RequestParam(value = "oaid", required = false) Integer oaid,
                                             @RequestParam("imageUrl") String imageUrl,
                                             @RequestParam(value = "imageType", defaultValue = "0") Integer imageType) {
        try {
            // 获取当前管理员ID
            Integer adminId = getUserId().intValue();

            // 调用图片数据服务处理上传（简化版）
            String result = imageDataService.uploadImageByUrlSimple(dispatchOrdID, serviceOrdID, oaid,
                    imageUrl, imageType, adminId);

            if (result.contains("成功")) {
                return AjaxResult.success("图片URL上传成功", result);
            } else {
                return AjaxResult.error(result);
            }
        } catch (Exception e) {
            return AjaxResult.error("图片URL上传失败：" + e.getMessage());
        }
    }

    /**
     * 通过图片URL上传处理（JSON格式）
     *
     * @param requestBody 请求体
     * @return 处理结果
     */
    @PreAuthorize("@ss.hasPermi('hospital:imagedata:add')")
    @Log(title = "图片URL上传JSON", businessType = BusinessType.INSERT)
    @PostMapping("/uploadByUrlJson")
    public AjaxResult uploadImageByUrlJson(@RequestBody ImageUrlUploadRequest requestBody) {
        try {
            // 获取当前管理员ID
            Integer adminId = getUserId().intValue();

            // 调用图片数据服务处理上传
            String result = imageDataService.uploadImageByUrl(requestBody.getDispatchOrdID(),
                    requestBody.getServiceOrdID(), requestBody.getOaid(), requestBody.getImageUrl(),
                    requestBody.getThumbnailUrl(), requestBody.getImageType(), adminId);

            if (result.contains("成功")) {
                return AjaxResult.success("图片URL上传成功", result);
            } else {
                return AjaxResult.error(result);
            }
        } catch (Exception e) {
            return AjaxResult.error("图片URL上传失败：" + e.getMessage());
        }
    }

    /**
     * 图片URL上传请求对象
     */
    public static class ImageUrlUploadRequest {

        private Long dispatchOrdID;
        private Long serviceOrdID;
        private Integer oaid;
        private String imageUrl;
        private String thumbnailUrl;
        private Integer imageType;

        // getter和setter方法
        public Long getDispatchOrdID() {
            return dispatchOrdID;
        }

        public void setDispatchOrdID(Long dispatchOrdID) {
            this.dispatchOrdID = dispatchOrdID;
        }

        public Long getServiceOrdID() {
            return serviceOrdID;
        }

        public void setServiceOrdID(Long serviceOrdID) {
            this.serviceOrdID = serviceOrdID;
        }

        public Integer getOaid() {
            return oaid;
        }

        public void setOaid(Integer oaid) {
            this.oaid = oaid;
        }

        public String getImageUrl() {
            return imageUrl;
        }

        public void setImageUrl(String imageUrl) {
            this.imageUrl = imageUrl;
        }

        public String getThumbnailUrl() {
            return thumbnailUrl;
        }

        public void setThumbnailUrl(String thumbnailUrl) {
            this.thumbnailUrl = thumbnailUrl;
        }

        public Integer getImageType() {
            return imageType;
        }

        public void setImageType(Integer imageType) {
            this.imageType = imageType;
        }
    }

    /**
     * 图片文件上传接口
     *
     * @param file 上传的图片文件
     * @param dispatchOrdID 调度单ID
     * @param serviceOrdID 服务单ID
     * @param imageType 图片类型
     * @return 处理结果
     */
//    @PreAuthorize("@ss.hasPermi('hospital:imagedata:add')")
    @Anonymous()
    @Log(title = "图片文件上传", businessType = BusinessType.INSERT)
    @PostMapping("/uploadFile")
    public AjaxResult uploadImageFile(@RequestParam("file") MultipartFile file,
                                      @RequestParam(value = "dispatchOrdID", required = false) Long dispatchOrdID,
                                      @RequestParam(value = "serviceOrdID", required = false) Long serviceOrdID,
                                      @RequestParam(value = "imageType", defaultValue = "0", required = true) Integer imageType,
                                      @RequestParam(value = "adminId", defaultValue = "0", required = false) Integer adminId) {
        try {

            adminId = getUserId().intValue();

            // 验证文件
            if (file.isEmpty()) {
                return AjaxResult.error("请选择要上传的图片文件");
            }

            // 验证文件类型
            String originalFilename = file.getOriginalFilename();
            if (originalFilename == null || !isValidImageFile(originalFilename)) {
                return AjaxResult.error("只支持上传图片文件（jpg、jpeg、png、gif、bmp）");
            }

            // 生成目标路径（使用年月目录结构）
            String yearMonth = DateUtils.datePath();
            String targetPath = dispatchOrdID.toString();
            //在结果另返回 fileUrl,thumbnailUrl,及mediaid
            // 使用文件上传服务保存到文件服务器（包含缩略图生成）
            FileUploadResponse uploadResponse = fileUploadService.uploadMultipartFileWithThumbnail(file, targetPath);

            // 添加调试信息
            System.out.println("文件上传响应 - 成功: " + uploadResponse.isSuccess());
            System.out.println("文件上传响应 - 消息: " + uploadResponse.getMessage());
            System.out.println("文件上传响应 - 文件路径: " + uploadResponse.getFilePath());
            System.out.println("文件上传响应 - 缩略图路径: " + uploadResponse.getThumbnailPath());

            if (!uploadResponse.isSuccess()) {
                return AjaxResult.error("文件上传失败：" + uploadResponse.getMessage());
            }

            // 创建图片数据对象
            ImageData imageData = new ImageData();
            imageData.setDOrdIDDt(dispatchOrdID);
            imageData.setSOrdIDDt(serviceOrdID);
            imageData.setImageType(imageType);
            imageData.setImageUrl(uploadResponse.getFilePath());
            imageData.setImageUrls(uploadResponse.getThumbnailPath()); // 缩略图路径
            imageData.setUpImageTime(new Date());
            imageData.setUpImageOAid(adminId);
            imageData.setImageDel(0);

            // 插入数据库
            int result = imageDataService.insertImageData(imageData);

            if (result > 0) {
                // 根据图片类型进行特殊处理
                ImageTypeEnum imageTypeEnum = ImageTypeEnum.getByCode(imageType);


                //返回全路径
                //在结果另返回 fileUrl,thumbnailUrl,及id
                HashMap<String, String> map = new HashMap<>();
                //加上fileServerUrl
                map.put("fileUrl", buildFullImageUrl(uploadResponse.getFilePath()));
                map.put("thumbnailUrl", buildFullImageUrl(uploadResponse.getThumbnailPath()));
                map.put("id", imageData.getId().toString());

                return AjaxResult.success("图片上传成功", map);
            } else {
                return AjaxResult.error("图片数据保存失败");
            }

        } catch (Exception e) {
            return AjaxResult.error("图片上传失败：" + e.getMessage());
        }
    }
    @Anonymous()
    @Log(title = "图片文件上传", businessType = BusinessType.INSERT)
    @PostMapping("/uploadFileBase64")
    public AjaxResult uploadFileBase64(@RequestParam("fileContent") String fileContent,@RequestParam("filename") String filename,
                                       @RequestParam(value = "dispatchOrdID", required = false) Long dispatchOrdID,
                                       @RequestParam(value = "serviceOrdID", required = false) Long serviceOrdID,
                                       @RequestParam(value = "imageType", defaultValue = "0", required = true) Integer imageType,
                                       @RequestParam(value = "adminId", defaultValue = "0", required = false) Integer adminId) {
        try {

            if( adminId == 0)
                adminId = getUserId().intValue();

            InputStream stream= InputStreamBase64Converter.base64ToInputStream(fileContent);

            // 生成目标路径（使用年月目录结构）
            String yearMonth = DateUtils.datePath();
            String targetPath = dispatchOrdID.toString();
            //在结果另返回 fileUrl,thumbnailUrl,及mediaid
            // 使用文件上传服务保存到文件服务器（包含缩略图生成）
            FileUploadResponse uploadResponse = fileUploadService.uploadInputStream(stream,filename, targetPath);

            // 添加调试信息
            System.out.println("文件上传响应 - 成功: " + uploadResponse.isSuccess());
            System.out.println("文件上传响应 - 消息: " + uploadResponse.getMessage());
            System.out.println("文件上传响应 - 文件路径: " + uploadResponse.getFilePath());
            System.out.println("文件上传响应 - 缩略图路径: " + uploadResponse.getThumbnailPath());

            if (!uploadResponse.isSuccess()) {
                return AjaxResult.error("文件上传失败：" + uploadResponse.getMessage());
            }

            // 创建图片数据对象
            ImageData imageData = new ImageData();
            imageData.setDOrdIDDt(dispatchOrdID);
            imageData.setSOrdIDDt(serviceOrdID);
            imageData.setImageType(imageType);
            imageData.setImageUrl(uploadResponse.getFilePath());
            imageData.setImageUrls(uploadResponse.getThumbnailPath()); // 缩略图路径
            imageData.setUpImageTime(new Date());
            imageData.setUpImageOAid(adminId);
            imageData.setImageDel(0);

            // 插入数据库
            int result = imageDataService.insertImageData(imageData);

            if (result > 0) {
                // 根据图片类型进行特殊处理
                ImageTypeEnum imageTypeEnum = ImageTypeEnum.getByCode(imageType);


                //返回全路径
                //在结果另返回 fileUrl,thumbnailUrl,及id
                HashMap<String, String> map = new HashMap<>();
                //加上fileServerUrl
                map.put("fileUrl", buildFullImageUrl(uploadResponse.getFilePath()));
                map.put("thumbnailUrl", buildFullImageUrl(uploadResponse.getThumbnailPath()));
                map.put("id", imageData.getId().toString());

                return AjaxResult.success("图片上传成功", map);
            } else {
                return AjaxResult.error("图片数据保存失败");
            }

        } catch (Exception e) {
            return AjaxResult.error("图片上传失败：" + e.getMessage());
        }
    }

    /**
     * 微信小程序专用图片文件上传接口
     * 支持微信小程序的 wx.uploadFile API
     *
     * @param request HttpServletRequest 请求对象
     * @param dispatchOrdID 调度单ID
     * @param serviceOrdID 服务单ID
     * @param imageType 图片类型
     * @param adminId 管理员ID
     * @return 处理结果
     */
    @Anonymous()
    @Log(title = "微信小程序图片上传", businessType = BusinessType.INSERT)
    @PostMapping("/uploadWxFile")
    public AjaxResult uploadWxFile(HttpServletRequest request,
                                   @RequestParam(value = "dispatchOrdID", required = false) Long dispatchOrdID,
                                   @RequestParam(value = "serviceOrdID", required = false) Long serviceOrdID,
                                   @RequestParam(value = "imageType", defaultValue = "0", required = true) Integer imageType,
                                   @RequestParam(value = "adminId", defaultValue = "0", required = false) Integer adminId) {
        try {
            adminId = getUserId().intValue();

            // 获取文件参数 - 微信小程序专用
            MultipartFile file = null;

            // 检查是否为 multipart 请求
            if (request instanceof MultipartHttpServletRequest) {
                MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;

                // 微信小程序通常使用 "file" 作为文件参数名
                file = multipartRequest.getFile("file");

                // 如果没找到，尝试其他可能的参数名
                if (file == null || file.isEmpty()) {
                    String[] possibleFileParams = {"image", "photo", "upload"};
                    for (String paramName : possibleFileParams) {
                        file = multipartRequest.getFile(paramName);
                        if (file != null && !file.isEmpty()) {
                            break;
                        }
                    }
                }

                // 如果还是没找到文件，获取第一个文件
                if (file == null || file.isEmpty()) {
                    Iterator<String> fileNames = multipartRequest.getFileNames();
                    if (fileNames.hasNext()) {
                        file = multipartRequest.getFile(fileNames.next());
                    }
                }
            }

            // 验证文件
            if (file == null || file.isEmpty()) {
                return AjaxResult.error("请选择要上传的图片文件");
            }

            // 验证文件类型
            String originalFilename = file.getOriginalFilename();
            if (originalFilename == null || !isValidImageFile(originalFilename)) {
                return AjaxResult.error("只支持上传图片文件（jpg、jpeg、png、gif、bmp）");
            }

            // 生成目标路径
            String targetPath = dispatchOrdID != null ? dispatchOrdID.toString() : "default";

            // 使用文件上传服务保存到文件服务器（包含缩略图生成）
            FileUploadResponse uploadResponse = fileUploadService.uploadMultipartFileWithThumbnail(file, targetPath);

            // 添加调试信息
            System.out.println("微信小程序文件上传响应 - 成功: " + uploadResponse.isSuccess());
            System.out.println("微信小程序文件上传响应 - 消息: " + uploadResponse.getMessage());
            System.out.println("微信小程序文件上传响应 - 文件路径: " + uploadResponse.getFilePath());
            System.out.println("微信小程序文件上传响应 - 缩略图路径: " + uploadResponse.getThumbnailPath());

            if (!uploadResponse.isSuccess()) {
                return AjaxResult.error("文件上传失败：" + uploadResponse.getMessage());
            }

            // 创建图片数据对象
            ImageData imageData = new ImageData();
            imageData.setDOrdIDDt(dispatchOrdID);
            imageData.setSOrdIDDt(serviceOrdID);
            imageData.setImageType(imageType);
            imageData.setImageUrl(uploadResponse.getFilePath());
            imageData.setImageUrls(uploadResponse.getThumbnailPath()); // 缩略图路径
            imageData.setUpImageTime(new Date());
            imageData.setUpImageOAid(adminId);
            imageData.setImageDel(0);

            // 插入数据库
            int result = imageDataService.insertImageData(imageData);

            if (result > 0) {
                // 根据图片类型进行特殊处理
                ImageTypeEnum imageTypeEnum = ImageTypeEnum.getByCode(imageType);



                // 返回微信小程序需要的格式
                HashMap<String, Object> map = new HashMap<>();
                map.put("fileUrl", buildFullImageUrl(uploadResponse.getFilePath()));
                map.put("thumbnailUrl", buildFullImageUrl(uploadResponse.getThumbnailPath()));
                map.put("id", imageData.getId());
                map.put("success", true);
                map.put("message", "图片上传成功");

                return AjaxResult.success("图片上传成功", map);
            } else {
                return AjaxResult.error("图片数据保存失败");
            }

        } catch (Exception e) {
            log.error("微信小程序图片上传失败", e);
            return AjaxResult.error("图片上传失败：" + e.getMessage());
        }
    }

    /**
     * 微信小程序Base64图片上传接口
     * 支持微信小程序将图片转换为Base64后上传
     *
     * @param fileContent Base64编码的图片内容
     * @param filename 文件名
     * @param dispatchOrdID 调度单ID
     * @param serviceOrdID 服务单ID
     * @param imageType 图片类型
     * @param adminId 管理员ID
     * @return 处理结果
     */
    @Anonymous()
    @Log(title = "微信小程序Base64图片上传", businessType = BusinessType.INSERT)
    @PostMapping("/uploadWxBase64")
    public AjaxResult uploadWxBase64(@RequestParam("fileContent") String fileContent,
                                     @RequestParam("filename") String filename,
                                     @RequestParam(value = "dispatchOrdID", required = false) Long dispatchOrdID,
                                     @RequestParam(value = "serviceOrdID", required = false) Long serviceOrdID,
                                     @RequestParam(value = "imageType", defaultValue = "0", required = true) Integer imageType,
                                     @RequestParam(value = "adminId", defaultValue = "0", required = false) Integer adminId) {
        try {
            if (adminId == 0) {
                adminId = getUserId().intValue();
            }

            // 验证Base64内容
            if (fileContent == null || fileContent.trim().isEmpty()) {
                return AjaxResult.error("图片内容不能为空");
            }

            // 验证文件类型
            if (filename == null || !isValidImageFile(filename)) {
                return AjaxResult.error("只支持上传图片文件（jpg、jpeg、png、gif、bmp）");
            }

            // 将Base64转换为InputStream
            InputStream stream = InputStreamBase64Converter.base64ToInputStream(fileContent);

            // 生成目标路径
            String targetPath = dispatchOrdID != null ? dispatchOrdID.toString() : "default";

            // 使用文件上传服务保存到文件服务器
            FileUploadResponse uploadResponse = fileUploadService.uploadInputStream(stream, filename, targetPath);

            // 添加调试信息
            System.out.println("微信小程序Base64上传响应 - 成功: " + uploadResponse.isSuccess());
            System.out.println("微信小程序Base64上传响应 - 消息: " + uploadResponse.getMessage());
            System.out.println("微信小程序Base64上传响应 - 文件路径: " + uploadResponse.getFilePath());
            System.out.println("微信小程序Base64上传响应 - 缩略图路径: " + uploadResponse.getThumbnailPath());

            if (!uploadResponse.isSuccess()) {
                return AjaxResult.error("文件上传失败：" + uploadResponse.getMessage());
            }

            // 创建图片数据对象
            ImageData imageData = new ImageData();
            imageData.setDOrdIDDt(dispatchOrdID);
            imageData.setSOrdIDDt(serviceOrdID);
            imageData.setImageType(imageType);
            imageData.setImageUrl(uploadResponse.getFilePath());
            imageData.setImageUrls(uploadResponse.getThumbnailPath()); // 缩略图路径
            imageData.setUpImageTime(new Date());
            imageData.setUpImageOAid(adminId);
            imageData.setImageDel(0);

            // 插入数据库
            int result = imageDataService.insertImageData(imageData);

            if (result > 0) {
                // 根据图片类型进行特殊处理
                ImageTypeEnum imageTypeEnum = ImageTypeEnum.getByCode(imageType);



                // 返回微信小程序需要的格式
                HashMap<String, Object> map = new HashMap<>();
                map.put("fileUrl", buildFullImageUrl(uploadResponse.getFilePath()));
                map.put("thumbnailUrl", buildFullImageUrl(uploadResponse.getThumbnailPath()));
                map.put("id", imageData.getId());
                map.put("success", true);
                map.put("message", "图片上传成功");

                return AjaxResult.success("图片上传成功", map);
            } else {
                return AjaxResult.error("图片数据保存失败");
            }

        } catch (Exception e) {
            log.error("微信小程序Base64图片上传失败", e);
            return AjaxResult.error("图片上传失败：" + e.getMessage());
        }
    }

    /**
     * 验证是否为有效的图片文件
     */
    private boolean isValidImageFile(String filename) {
        String[] allowedExtensions = {".jpg", ".jpeg", ".png", ".gif", ".bmp"};
        String lowerFilename = filename.toLowerCase();
        for (String ext : allowedExtensions) {
            if (lowerFilename.endsWith(ext)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取文件扩展名
     */
    private String getFileExtension(String filename) {
        int lastDotIndex = filename.lastIndexOf('.');
        if (lastDotIndex > 0) {
            return filename.substring(lastDotIndex + 1);
        }
        return "jpg"; // 默认扩展名
    }

    /**
     * 获取上传路径
     */
    private String getUploadPath() {
        // 这里可以根据实际配置返回上传路径
        // 可以从配置文件中读取或使用默认路径
        return System.getProperty("user.dir") + "/upload";
    }



}