package cn.huge.module.file.controller.web;

import cn.huge.base.common.exception.ClientException;
import cn.huge.module.file.domain.dto.IdFileDTO;
import cn.huge.module.file.domain.po.FileRelate;
import cn.huge.module.utils.BaiduOcrUtils;
import cn.huge.base.common.utils.ContentTypeUtils;
import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.base.config.CurrentUser;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.constant.BaseConsts;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.file.domain.dto.UploaderDTO;
import cn.huge.module.file.domain.po.FileInfo;
import cn.huge.module.file.service.FileInfoService;
import cn.huge.module.file.service.FileRelateService;
import cn.huge.module.file.utils.FileUtils;
import cn.huge.module.file.utils.FtpUtils;
import cn.huge.module.sys.constant.FileBaseConsts;
import cn.huge.module.sys.constant.FileOwnerTypeBaseEnum;
import cn.huge.module.sys.dto.FileInfoBaseDTO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
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.io.OutputStream;
import java.net.URLEncoder;
import java.util.*;
import java.util.stream.Collectors;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * @title: 附件信息表接口api-web端
 * @description: 附件信息表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-08-28 20:06:18
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/fileInfo")
public class FileInfoWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private FileInfoService service;
    @Autowired
    private FileRelateService fileRelateService;
    @Autowired
    private CustClientImpl custClient;

    /**
     * 页面附件上传-文件流方式
     *
     * @param mainId    所属业务主体编号
     * @param ownerId   所属业务编号
     * @param ownerType 所属业务类型
     * @param request   请求头
     * @return Object
     * @url {ctx}/api/web/fileInfo/upload?mainId=&ownerId=&ownerType=
     */
    @PostMapping("/upload")
    public Object upload(@RequestParam(value = "mainId") String mainId,
                         @RequestParam(value = "ownerId") String ownerId,
                         @RequestParam(value = "ownerType") String ownerType,
                         @CurrentUser String userId, MultipartHttpServletRequest request) {
        try {
            CtUserDTO loginUser = custClient.clientGetUser(userId);
            UploaderDTO uploaderDTO = new UploaderDTO();
            uploaderDTO.setUploaderId(loginUser.getId());
            uploaderDTO.setUploaderName(loginUser.getTrueName());
            uploaderDTO.setUploaderType(FileBaseConsts.UPLOADER_TYPE_1);
            uploaderDTO.setCustId(loginUser.getCustId());
            List<FileInfoBaseDTO> files = new ArrayList<>();
            Iterator<String> itr = request.getFileNames();
            int fileCount = fileRelateService.countByOwnerIdAndType(ownerId, ownerType) + 1;
            while (itr.hasNext()) {
                MultipartFile file = request.getFile(itr.next());
                if (file.getSize() > 30000000) {
                    return ReturnFailUtils.getRepInfo("您上传的文件已超过30M大小限制！");
                } else {
                    String fileSuffix = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf("."));
                    if (FileUtils.checkFileSuffix(fileSuffix)) {
                        if (StringUtils.isEmpty(ownerType)) {
                            ownerType = FileOwnerTypeBaseEnum.OWNER_TYPE_000.getIndex();
                        }
                        FileInfo fileInfo = service.webUploadFile(file, mainId, ownerId, ownerType, fileCount, uploaderDTO);
                        FileInfoBaseDTO fileInfoBaseDTO = new FileInfoBaseDTO();
                        BeanUtils.copyProperties(fileInfo, fileInfoBaseDTO);

                        // 如果是身份证，就调用ocr识别
                        if (FileOwnerTypeBaseEnum.OWNER_TYPE_202.getIndex().equals(ownerType)) {
                            fileInfoBaseDTO.setIdcardOcrResult(BaiduOcrUtils.ocrIdcard(file.getBytes()));
                        }

                        files.add(fileInfoBaseDTO);
                        fileCount++;
                    } else {
                        return ReturnFailUtils.getRepInfo("您上传的文件格式不正确！");
                    }
                }
            }
            return ReturnSucUtils.getRepInfo("上传成功！", files);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 在线查附件-文件流方式
     *
     * @param id       附件编号
     * @param response 响应头
     * @throws Exception
     * @url {ctx}/api/web/fileInfo/show/{id}
     */
    @GetMapping("/show/{id}")
    public void show(@PathVariable(value = "id") String id, HttpServletResponse response) {
        try {
            FileInfo fileInfo = service.getById(id);
            response.reset();
            String contentType = ContentTypeUtils.getContentType(fileInfo.getSuffix());
            response.setContentType(contentType);
            OutputStream outputStream = response.getOutputStream();
            FtpUtils ftpUtil = new FtpUtils();
            InputStream inputStream = ftpUtil.retrieveFileStream(fileInfo.getFullPath());

//            double fileSize = fileInfo.getSize(); // 文件大小
            int chunkSize = 512 * 1024; // 分块大小（ KB）
            byte[] buffer = new byte[chunkSize];
            int bytesRead;

            // 循环读取和发送文件的各个部分
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
                outputStream.flush();
            }

//            IOUtils.copy(inputStream, outputStream, chunkSize);
            //关闭流
            IOUtils.closeQuietly(inputStream);
            IOUtils.closeQuietly(outputStream);
        } catch (Exception e) {
            log.error("controller接口[FileInfoWebController.show]请求失败，异常信息：" + e, e);
            throw new ClientException("FileInfoWebController.show", e);
        }
    }

    /**
     * 在线下载附件-文件流方式
     *
     * @param id       附件编号
     * @param response 响应头
     * @url {ctx}/api/web/fileInfo/down/{id}
     */
    @GetMapping("/down/{id}")
    public void down(@PathVariable(value = "id") String id, HttpServletResponse response) {
        try {
            FileInfo fileInfo = service.getById(id);
            String contentType = ContentTypeUtils.getContentType(fileInfo.getSuffix());
            response.setContentType(contentType);
            String fileName = URLEncoder.encode(fileInfo.getName() + BaseConsts.DOT + fileInfo.getSuffix(), "UTF-8");
            response.addHeader("Content-Disposition", "attachment;filename=" + fileName);
            OutputStream outputStream = response.getOutputStream();
            FtpUtils ftpUtil = new FtpUtils();
            InputStream inputStream = ftpUtil.retrieveFileStream(fileInfo.getFullPath());
            IOUtils.copy(inputStream, outputStream);
            //关闭流
            IOUtils.closeQuietly(inputStream);
            IOUtils.closeQuietly(outputStream);
        } catch (Exception e) {
            log.error("controller接口[FileInfoWebController.down]请求失败，异常信息：" + e, e);
            throw new ClientException("FileInfoWebController.down", e);
        }
    }

    @GetMapping("/down/batch")
    public void downBatch(@RequestParam(value = "ids") String ids, HttpServletResponse response) {
        try {
            String[] id = ids.split(",");
            // 设置ZIP文件响应类型
            response.setContentType("application/zip");
            response.setHeader("Content-Disposition", "attachment;filename=files.zip");

            ZipOutputStream zipOutputStream = new ZipOutputStream(response.getOutputStream());
            for (String s : id) {
                FileInfo fileInfo = service.getById(s);
                FtpUtils ftpUtil = new FtpUtils();
                InputStream inputStream = ftpUtil.retrieveFileStream(fileInfo.getFullPath());

                // 每个文件写入到ZIP包中
                zipOutputStream.putNextEntry(new ZipEntry(fileInfo.getName() + BaseConsts.DOT + fileInfo.getSuffix()));
                IOUtils.copy(inputStream, zipOutputStream);
                zipOutputStream.closeEntry();
                IOUtils.closeQuietly(inputStream);
            }
            IOUtils.closeQuietly(zipOutputStream);
        } catch (Exception e) {
            log.error("controller接口[FileInfoWebController.down]请求失败，异常信息：" + e, e);
            throw new ClientException("FileInfoWebController.down", e);
        }
    }

    /**
     * ocr识别文字
     *
     * @param request
     * @return Object
     * @url {ctx}/api/web/fileInfo/recognitionText?ownerId=&ownerType=
     */
    @PostMapping(value = "/recognitionText")
    public Object recognitionText(MultipartHttpServletRequest request) {
        try {
            Map<String, Object> result = Maps.newHashMap();
            Iterator<String> itr = request.getFileNames();
            while (itr.hasNext()) {
                MultipartFile file = request.getFile(itr.next());
                try {
                    Map<String, Object> map = BaiduOcrUtils.ocrText(file.getBytes());
                    result.put("ocrResult", map);
                } catch (Exception e) {
                    log.error("Controller接口[FileInfoController.recognitionText]请求异常：" + e, e);
                    return ReturnFailUtils.getRepInfo("OCR失败！");
                }
            }
            return ReturnSucUtils.getRepInfo("识别成功", result);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }

    /**
     * 查看附件组件-分类查询附件
     *
     * @param mainId 所属业务主体编号
     * @return Object
     * @url {ctx}/api/web/fileInfo/listFileByCat
     */
    @GetMapping("/listFileByCat")
    public Object listFileByCat(@RequestParam(value = "mainId") String mainId, @CurrentUser String userId) {
        try {
            Map<String, Object> terms = Maps.newHashMap();
            // 材料大类
            String fileOwnerCat = request.getParameter("fileOwnerCat");
            if (StringUtils.isNotBlank(fileOwnerCat)) {
                terms.put("ownerCat", fileOwnerCat);
            }
            // 上传时间区间
            String createStart = request.getParameter("createStart");
            String createEnd = request.getParameter("createEnd");
            if (StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
                terms.put("createStart", createStart);
                terms.put("createEnd", createEnd);
            }
            // 上传人类型
            String uploaderType = request.getParameter("uploaderType");
            if (StringUtils.isNotBlank(uploaderType)) {
                terms.put("uploaderType", uploaderType);
            }
            // 所属主体编号
            terms.put("mainId", mainId);
            return ReturnSucUtils.getRepInfo(service.webListFileByCat(terms));
        } catch (Exception e) {
            log.error("service方法[FileInfoWebController.listFileByCat]请求失败，异常信息：" + e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 删除附件
     *
     * @param ids 附件编号集合
     * @return Object
     * @url {ctx}/api/web/fileInfo/deleteFileById?id=
     */
    @GetMapping("/deleteFileByIds")
    public Object deleteFileByIds(@RequestParam(value = "ids") String ids) {
        try {
            String[] id = ids.split(",");
            for (String s : id) {
                service.deleteFileById(s);
            }
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    @GetMapping("/deleteFileById")
    public Object deleteFileById(@RequestParam(value = "id") String id) {
        try {
            service.deleteFileById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 根据多个所属编号查询附件并根据先根据ownerId再根据附件类型分组
     *
     * @return Object
     * @url {ctx}/api/web/fileInfo/listIdTypeInfo
     */
    @PostMapping("/listIdTypeInfo")
    public Object listIdTypeInfo(@RequestBody IdFileDTO idFileDTO) {
        try {
            Map<String, Object> term = new HashMap<>();
            String ownerIds = idFileDTO.getOwnerIdList().stream().map(String::valueOf).collect(Collectors.joining("','"));
            String types = idFileDTO.getTypeList().stream().map(String::valueOf).collect(Collectors.joining("','"));
            if (StringUtils.isNotBlank(ownerIds)) {
                ownerIds = "'" + ownerIds + "'";
            }
            if (StringUtils.isNotBlank(types)) {
                types = "'" + types + "'";
            }
            term.put("ownerIds", ownerIds);
            term.put("types", types);
            term.put("mainId", idFileDTO.getMainId());
            return ReturnSucUtils.getRepInfo(service.listIdTypeInfoByOwnerIdList(term));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 公共方法-获取附件列表
     * @url {ctx}/api/web/fileInfo/lietNewSysFile
     * @param
     * @return Object
     */
    @GetMapping(value = "/listNewSysFile")
    public Object listNewSysFile(@RequestParam (value = "ownerId") String ownerId, @RequestParam (value = "ownerType") String ownerType,
                                 @RequestParam (value = "size") String size){
        try{
            QueryWrapper<FileRelate> fileRelateQueryWrapper = new QueryWrapper<>();
            fileRelateQueryWrapper.eq("owner_type", ownerType).eq("owner_id", ownerId).orderByDesc("create_time")
                    .last("limit "+size).select("file_id");
            List<FileRelate> fileRelateList = fileRelateService.list(fileRelateQueryWrapper);
            List<FileInfo> fileInfoList = null;
            if(CollectionUtils.isNotEmpty(fileRelateList)){
                List<String>fileIdList = fileRelateList.stream().map(FileRelate:: getFileId).collect(Collectors.toList());
                QueryWrapper<FileInfo>fileInfoQueryWrapper = new QueryWrapper<>();
                fileInfoQueryWrapper.in("id", fileIdList).select("id", "true_name").orderByDesc("create_time");
                fileInfoList = service.list(fileInfoQueryWrapper);
            }
            return ReturnSucUtils.getRepInfo(fileInfoList);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }
}