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.fpiMgt.sri.service.SriService;
import com.dbnt.faisp.main.ivsgtMgt.boardInvestigation.service.BoardInvestigationService;
import com.dbnt.faisp.main.ivsgtMgt.majorStatus.service.MajorStatusService;
import com.dbnt.faisp.main.publicBoard.service.PublicBoardService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Value;
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.ServletOutputStream;
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.LocalDate;
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 BoardInvestigationService boardInvestigationService;
  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());

      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);
    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 = "견문보고서 첨부파일_"+ 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();


      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 = boardInvestigationService.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;
  }
  private void setDisposition(String filename, HttpServletRequest request, HttpServletResponse response) throws IOException {
    String browser = getBrowser(request);

    String dispositionPrefix = "attachment; filename=";
    String encodedFilename = null;

    if (browser.equals("MSIE")) {
      encodedFilename = URLEncoder.encode(filename, "UTF-8").replaceAll("\\+", "%20");
    } else if (browser.equals("Trident")) { // IE11 문자열 깨짐 방지
      encodedFilename = URLEncoder.encode(filename, "UTF-8").replaceAll("\\+", "%20");
    } else if (browser.equals("Firefox")) {
      encodedFilename = "\"" + new String(filename.getBytes("UTF-8"), "8859_1") + "\"";
    } else if (browser.equals("Opera")) {
      encodedFilename = "\"" + new String(filename.getBytes("UTF-8"), "8859_1") + "\"";
    } else if (browser.equals("Chrome")) {
      StringBuffer sb = new StringBuffer();
      for (int i = 0; i < filename.length(); i++) {
        char c = filename.charAt(i);
        if(c==','){
          sb.append(URLEncoder.encode("，", "UTF-8"));
        } else if (c > '~') {
          sb.append(URLEncoder.encode("" + c, "UTF-8"));
        } else {
          sb.append(c);
        }
      }
      encodedFilename = sb.toString();
    } else {
      throw new IOException("Not supported browser");
    }

    response.setHeader("Content-Disposition", dispositionPrefix + encodedFilename);

    if ("Opera".equals(browser)) {
      response.setContentType("application/octet-stream;charset=UTF-8");
    }
    if(filename.contains("zip")){
      response.setContentType("application/zip");
    }
  }

  private String getBrowser(HttpServletRequest request) {
    String header = request.getHeader("User-Agent");
    if (header.indexOf("MSIE") > -1) {
      return "MSIE";
    } else if (header.indexOf("Trident") > -1) { // IE11 문자열 깨짐 방지
      return "Trident";
    } else if (header.indexOf("Chrome") > -1) {
      return "Chrome";
    } else if (header.indexOf("Opera") > -1) {
      return "Opera";
    }
    return "Firefox";
  }
}