package com.dbnt.faisp.config;

import com.dbnt.faisp.main.counterIntelligence.service.CounterIntelligenceService;
import com.dbnt.faisp.main.faRpt.service.FaRptService;
import com.dbnt.faisp.main.faStatistics.crackdownsStatus.service.FishingBoatService;
import com.dbnt.faisp.main.faStatistics.crackdownsStatus.service.SailorService;
import com.dbnt.faisp.main.fpiMgt.affair.service.AffairService;
import com.dbnt.faisp.main.fpiMgt.affairPlan.service.PlanService;
import com.dbnt.faisp.main.fpiMgt.affairResult.service.ResultService;
import com.dbnt.faisp.main.fpiMgt.intelligenceNetwork.service.IntelligenceNetworkService;
import com.dbnt.faisp.main.fpiMgt.monitoring.service.MonitoringService;
import com.dbnt.faisp.main.faRpt.service.SriService;
import com.dbnt.faisp.main.ivsgtMgt.boardInvestigation.service.IvsgtService;
import com.dbnt.faisp.main.ivsgtMgt.majorStatus.service.MajorStatusService;
import com.dbnt.faisp.main.publicBoard.service.PublicBoardService;
import com.dbnt.faisp.util.Utils;
import lombok.RequiredArgsConstructor;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

@RestController
@RequiredArgsConstructor
@RequestMapping("/file")
public class FileController extends BaseService{

  private final FaRptService faRptService;
  private final PlanService planService;
  private final PublicBoardService publicBoardService;
  private final AffairService affairService;
  private final ResultService resultService;
  private final IvsgtService ivsgtService;
  private final FishingBoatService fishingBoatService;
  private final SailorService sailorService;
  private final SriService sriService;
  private final CounterIntelligenceService ciService;
  private final MajorStatusService majorStatusService;
  private final IntelligenceNetworkService inrelligenceNetworkService;
  private final MonitoringService monitoringService;

  @GetMapping("/editorFileDisplay")
  public ResponseEntity<Resource> editorFileDisplay(HttpServletRequest request,
                                              HttpServletResponse response,
                                              String fileNm) {

    String pathStr = locationPath+editorPath+File.separator+fileNm;
    Resource resource = new FileSystemResource(pathStr);
    if(!resource.exists()){
      return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }
    HttpHeaders header = new HttpHeaders();
    Path filePath = null;
    try {
      filePath = Paths.get(pathStr);
      header.add("Content-type", Files.probeContentType(filePath));
    }catch (IOException e){
      e.printStackTrace();
    }
    return new ResponseEntity<Resource>(resource, header, HttpStatus.OK);
  }

  @GetMapping("/fileDisplay")
  public ResponseEntity<Resource> fileDisplay(HttpServletRequest request,
                                              HttpServletResponse response,
                                              String board,
                                              Integer parentKey,
                                              Integer fileSeq) {
    FileInfo fileInfo = getFileInfo(board, parentKey, fileSeq);
    String pathStr = fileInfo.getSavePath()+File.separator+fileInfo.getConvNm();
    Resource resource = new FileSystemResource(pathStr);
    if(!resource.exists()){
      return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }
    HttpHeaders header = new HttpHeaders();
    Path filePath = null;
    try {
      filePath = Paths.get(pathStr);
      header.add("Content-type", Files.probeContentType(filePath));
    }catch (IOException e){
      e.printStackTrace();
    }
    return new ResponseEntity<Resource>(resource, header, HttpStatus.OK);
  }

  @GetMapping("/fileDownload")
  public void fileDownload(HttpServletRequest request,
                           HttpServletResponse response,
                           String board,
                           Integer parentKey,
                           Integer fileSeq) {

    FileInfo fileInfo = getFileInfo(board, parentKey, fileSeq);
    BufferedInputStream in;
    BufferedOutputStream out;
    try {
      File file = new File(fileInfo.getSavePath(), fileInfo.getConvNm());

      Utils.setDisposition(fileInfo.getFullName(), request, response);
      in = new BufferedInputStream(new FileInputStream(file));
      out = new BufferedOutputStream(response.getOutputStream());
      FileCopyUtils.copy(in, out);
      out.flush();
      if(out!=null) out.close();
      if(in!=null )in.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  @GetMapping("/downloadAffairFiles")
  public void downloadAffairFiles(HttpServletRequest request,
                                  HttpServletResponse response,
                                  @RequestParam(value="affairKeyList") List<Integer> affairKeyList){
    List<FileInfo> fileList = affairService.selectAffairFileList(affairKeyList);
    makeZipAndOut(request, response, "견문보고서 첨부파일_", fileList);
  }


  @GetMapping("/downloadMajorStatusFiles")
  public void downloadMajorStatusFiles(HttpServletRequest request,
                                  HttpServletResponse response,
                                  @RequestParam(value="majorKeyList") List<Integer> majorKeyList){
    List<FileInfo> fileList = majorStatusService.selectMajorFileList(majorKeyList);
    makeZipAndOut(request, response, "주요사건처리현황 첨부파일_", fileList);

  }

  private void makeZipAndOut(HttpServletRequest request,
                             HttpServletResponse response,
                             String fileName, List<FileInfo> fileList) {
    List<Map<String, String>> fileInfoList = new ArrayList<>();
    for(FileInfo file: fileList){
      Map<String, String> fileInfoMap = new HashMap<>();
      fileInfoMap.put("filePath", file.getSavePath()+File.separator+file.getConvNm());
      fileInfoMap.put("originalName", file.getOrigNm()+"."+file.getFileExtn());
      fileInfoList.add(fileInfoMap);
    }

    String zipFile = locationPath+affairTempPath;
    File saveFolder = new File(zipFile);

    if (!saveFolder.exists() || saveFolder.isFile()) {
      saveFolder.mkdirs();
    }
    String downloadFileName = fileName+ LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"))+".zip";
    zipFile += File.separator+downloadFileName;
    try{
      // ZipOutputStream을 FileOutputStream 으로 감쌈
      FileOutputStream fout = new FileOutputStream(zipFile);
      ZipOutputStream zout = new ZipOutputStream(fout);
      for(Map<String, String> fileMap: fileInfoList){
        //본래 파일명 유지, 경로제외 파일압축을 위해 new File로
        ZipEntry zipEntry = new ZipEntry(fileMap.get("originalName"));
        zout.putNextEntry(zipEntry);
        //경로포함 압축
        //zout.putNextEntry(new ZipEntry(sourceFiles.get(i)));

        FileInputStream fin = new FileInputStream(fileMap.get("filePath"));
        byte[] buffer = new byte[1024];
        int length;

        // input file을 1024바이트로 읽음, zip stream에 읽은 바이트를 씀
        while((length = fin.read(buffer)) > 0){
          zout.write(buffer, 0, length);
        }

        zout.closeEntry();
        fin.close();
      }

      zout.close();


      Utils.setDisposition(downloadFileName, request, response);
      BufferedInputStream in = new BufferedInputStream(new FileInputStream(zipFile));
      BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());
      FileCopyUtils.copy(in, out);
      out.flush();
      /*byte[] data=new byte[2048];
      int input=0;

      while((input=in.read(data))!=-1){
        out.write(data,0,input);
        out.flush();
      }*/
      if(out!=null) out.close();
      if(in!=null) in.close();
    } catch(IOException e){
      e.printStackTrace();
    }
  }

  private FileInfo getFileInfo(String board, Integer parentKey, Integer fileSeq){
    FileInfo downloadFile = null;
    switch (board){
      case "faRpt":
        downloadFile = faRptService.selectFaRptFile(parentKey, fileSeq);
        break;
      case "affairPlan":
        downloadFile = planService.selectPlanFile(parentKey, fileSeq);
        break;
      case "publicFile":
        downloadFile = publicBoardService.selectPublicFile(parentKey, fileSeq);
        break;
      case "affair":
        downloadFile = affairService.selectAffairFile(parentKey, fileSeq);
        break;
      case "affairResult":
        downloadFile = resultService.selectResultFile(parentKey, fileSeq);
        break;
      case "ivsgt":
        downloadFile = ivsgtService.selectIvsgtFile(parentKey, fileSeq);
        break;
      case "sailor":
        downloadFile = sailorService.selectSailorFile(parentKey, fileSeq);
        break;
      case "sri":
        downloadFile = sriService.selectFaSriFile(parentKey, fileSeq);
        break;
      case "ciWork":
        downloadFile = ciService.selectCiWorkFile(parentKey, fileSeq);
        break;
      case "MajorFile" :
        downloadFile = majorStatusService.selectMajorFile(parentKey, fileSeq);
        break;
      case "ciActivity":
          downloadFile = ciService.selectCiaForeignerFile(parentKey, fileSeq);
          break;
      case "operationPlan":
          downloadFile = inrelligenceNetworkService.selectOperationPlanFile(parentKey, fileSeq);
          break;
      case "designation":
          downloadFile = monitoringService.selectDesignationFile(parentKey, fileSeq);
          break;
      case "monitoringResult":
	      downloadFile = monitoringService.selectMonitoringResultFile(parentKey, fileSeq);
	      break;
      case "monitoringReport":
	      downloadFile = monitoringService.selectMonitoringReportFile(parentKey, fileSeq);
	      break;
    }
    return downloadFile;
  }
}