package com.dbnt.faisp.fipTarget.service;



import com.dbnt.faisp.config.BaseService;
import com.dbnt.faisp.fipTarget.mapper.FipTargetMapper;
import com.dbnt.faisp.fipTarget.model.PartInfo;
import com.dbnt.faisp.fipTarget.model.PartInfo.PartInfoId;
import com.dbnt.faisp.fipTarget.model.PartInfoFile;
import com.dbnt.faisp.fipTarget.model.PartInfoFile.PartInfoFileId;
import com.dbnt.faisp.fipTarget.model.PartWork;
import com.dbnt.faisp.fipTarget.model.PartWork.PartWorkId;
import com.dbnt.faisp.fipTarget.model.PartWorkFile;
import com.dbnt.faisp.fipTarget.model.PartWorkFile.PartWorkFileId;
import com.dbnt.faisp.fipTarget.model.VulnFile;
import com.dbnt.faisp.fipTarget.model.VulnFile.VulnFileId;
import com.dbnt.faisp.fipTarget.model.Vulnerable;
import com.dbnt.faisp.fipTarget.repository.PartInfoFileRepository;
import com.dbnt.faisp.fipTarget.repository.PartInfoRepository;
import com.dbnt.faisp.fipTarget.repository.PartWorkFileRepository;
import com.dbnt.faisp.fipTarget.repository.PartWorkRepository;
import com.dbnt.faisp.fipTarget.repository.VulnFileRepository;
import com.dbnt.faisp.fipTarget.repository.VulnRepository;
import com.dbnt.faisp.publicBoard.model.PublicFile;
import com.dbnt.faisp.util.ParamMap;

import lombok.RequiredArgsConstructor;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.util.*;

@Service
@RequiredArgsConstructor
public class FipTargetService extends BaseService {
	@Value("${spring.servlet.multipart.location}")
	  protected String locationPath;

	private final PartInfoRepository partInfoRepository;
	private final PartInfoFileRepository partInfoFileRepository;
	private final PartWorkRepository partWorkRepository;
	private final PartWorkFileRepository partWorkFileRepository;
	private final VulnRepository vulnRepository;
	private final VulnFileRepository vulnFileRepository;
	private final FipTargetMapper fipTargetMapper;
	
	@Transactional
	public void savePartInfo(PartInfo partInfo) {
		PartInfo dbPart = partInfoRepository.findFirstByOrderByPiSeqDesc();
			if(dbPart == null) {
				partInfo.setPiSeq(1);
				partInfo.setVersionNo(1);
				partInfoRepository.save(partInfo);
			} else {
				partInfo.setPiSeq(dbPart.getPiSeq()+1);
				partInfo.setVersionNo(1);
				partInfoRepository.save(partInfo);
			}
		saveUploadFiles(partInfo.getPiSeq(),partInfo.getVersionNo(), partInfo.getMultipartFileList());
	}
	
	private void saveUploadFiles(Integer piSeq,Integer versionNo, List<MultipartFile> multipartFileList) {
		PartInfoFile lastFileInfo = partInfoFileRepository.findTopByPiSeqAndVersionNoOrderByFileSeqDesc(piSeq,versionNo);
	    int fileSeq = lastFileInfo==null?1:(lastFileInfo.getFileSeq()+1);
		    if(multipartFileList == null || multipartFileList.isEmpty()) {
		    	if(lastFileInfo == null || lastFileInfo.getOrigNm() == null ) {
		    		PartInfoFile fileInfo = new PartInfoFile();
		    		fileInfo.setFileSeq(fileSeq);
		    		fileInfo.setPiSeq(piSeq);	 
		    		fileInfo.setVersionNo(versionNo);
		    		partInfoFileRepository.save(fileInfo);
		    	}
			      
		    } else {
		    	for(MultipartFile file : multipartFileList){
				      String saveName = UUID.randomUUID().toString();
				      String path = locationPath+File.separator+"publicFile"+File.separator;
				      saveFile(file, new File(path+File.separator+saveName));
			
				      String originalFilename = file.getOriginalFilename();
				      int extnIdx = originalFilename.lastIndexOf(".");
				      PartInfoFile fileInfo = new PartInfoFile();
				      fileInfo.setFileSeq(fileSeq++);
				      fileInfo.setPiSeq(piSeq);	 
				      fileInfo.setVersionNo(versionNo);
				      fileInfo.setOrigNm(originalFilename.substring(0, extnIdx));
				      fileInfo.setFileExtn(originalFilename.substring(extnIdx+1));
				      fileInfo.setConvNm(saveName);
				      fileInfo.setFileSize(calculationSize(file.getSize()));
				      fileInfo.setFilePath(path);
				      partInfoFileRepository.save(fileInfo);
				    }
		    }
		
	  }

	public List<PartInfo> selectPartInfoList(PartInfo partInfo) {
		return fipTargetMapper.selectPartInfoList(partInfo);
	}

	public Integer selectPartInfoListCnt(PartInfo partInfo) {
		return fipTargetMapper.selectPartInfoListCnt(partInfo);
	}

	public ParamMap selectWorkTypeTotal(PartInfo partInfo) {
		return fipTargetMapper.selectWorkTypeTotal(partInfo);
	}

	public PartInfo selectPartInfo(PartInfo partInfo) {
		return fipTargetMapper.selectPartInfo(partInfo);
	}

	public List<PartInfoFile> selectPartInfoFile(PartInfo partInfo) {
		return fipTargetMapper.selectPartInfoFile(partInfo);
	}
	
	@Transactional
	public void updatePartInfo(PartInfo partInfo, List<Integer> deleteFileSeq) {
		PartInfo dbPart = partInfoRepository.findById(new PartInfoId(partInfo.getPiSeq(), partInfo.getVersionNo())).orElse(null);
		PartInfo partTmp = new PartInfo();
		partTmp.setPiSeq(dbPart.getPiSeq());
		partTmp.setVersionNo(dbPart.getVersionNo()+1);
		partTmp.setMgtOrgan(partInfo.getMgtOrgan());
		partTmp.setLandPolice(partInfo.getLandPolice());
		partTmp.setPiUserSeq(partInfo.getPiUserSeq());
		partTmp.setRentType(partInfo.getRentType());
		partTmp.setRentPrice(partInfo.getRentPrice());
		partTmp.setUtilityType(partInfo.getUtilityType());
		partTmp.setUtilityPrice(partInfo.getUtilityPrice());
		partTmp.setTerminalNm(partInfo.getTerminalNm());
		partTmp.setMpWorkType(partInfo.getMpWorkType());
		partTmp.setMpPeopleCnt(partInfo.getMpPeopleCnt());
		partTmp.setMpDescription(partInfo.getMpDescription());
		partTmp.setPlWorkType(partInfo.getPlWorkType());
		partTmp.setPlPeopleCnt(partInfo.getPlPeopleCnt());
		partTmp.setPlDescription(partInfo.getPlDescription());
		partTmp.setWrtUserSeq(partInfo.getWrtUserSeq());
		partTmp.setWrtNm(partInfo.getWrtNm());
		partTmp.setWrtPart(partInfo.getWrtPart());
		partTmp.setWrtOrgan(partInfo.getWrtOrgan());
		partTmp.setWrtDt(partInfo.getWrtDt());
		partInfoRepository.save(partTmp);
		//업데이트하는 버전 파일조회
		List<PartInfoFile> fileList = partInfoFileRepository.findByPiSeqAndVersionNoOrderByFileSeqAsc(partInfo.getPiSeq(),partInfo.getVersionNo());
		if(fileList.get(0).getOrigNm() != null) {
			for(PartInfoFile fileInfo : fileList){
				PartInfoFile tmpFile = new PartInfoFile();
				tmpFile.setFileSeq(fileInfo.getFileSeq());
				tmpFile.setPiSeq(fileInfo.getPiSeq());
				tmpFile.setVersionNo(partTmp.getVersionNo());
				tmpFile.setOrigNm(fileInfo.getOrigNm());
				tmpFile.setConvNm(fileInfo.getConvNm());
				tmpFile.setFileExtn(fileInfo.getFileExtn());
				tmpFile.setFileSize(fileInfo.getFileSize());
				tmpFile.setFilePath(fileInfo.getFilePath());
				partInfoFileRepository.save(tmpFile);
			}
		}
		//수정시 삭제한 파일삭제
		if(deleteFileSeq!=null && deleteFileSeq.size()>0){
		      deletePartInfoFile(partTmp.getPiSeq(),partTmp.getVersionNo(), deleteFileSeq);
		}
		//파일업로드
			saveUploadFiles(partTmp.getPiSeq(),partTmp.getVersionNo(), partInfo.getMultipartFileList());
	}
	
	private void deletePartInfoFile(Integer piSeq,Integer versionNo, List<Integer> deleteFileSeq) {
	    List<PartInfoFile> partInfoFileList = partInfoFileRepository.findByPiSeqAndVersionNoOrderByFileSeqAsc(piSeq,versionNo);
	    for(PartInfoFile file: partInfoFileList){
	      if(deleteFileSeq.contains(file.getFileSeq())){
	        deleteStoredFile(new File(file.getFilePath(), file.getConvNm()));
	        partInfoFileRepository.deleteById(new PartInfoFileId(file.getFileSeq(),piSeq,versionNo));
	      }
	    }
	  }

	public List<PartInfo> selectPartInfoSeq(PartInfo partInfo) {
		return fipTargetMapper.selectPartInfoSeq(partInfo);
	}

	public PartInfo selectPartInfoHistoryView(PartInfo partInfo) {
		return fipTargetMapper.selectPartInfoHistoryView(partInfo);
	}

	public List<PartInfoFile> selectPartInfoFileHistoryView(PartInfo partInfo) {
		return fipTargetMapper.selectPartInfoFileHistoryView(partInfo);
	}
	
	@Transactional
	public void deletePartInfo(PartInfo partInfo) {
		//외사실적 파일,데이터삭제
		List<PartWorkFile> partWorkFileList = partWorkFileRepository.findByPiSeq(partInfo.getPiSeq());
		if(partWorkFileList != null) {
			for(PartWorkFile file: partWorkFileList){
		        deleteStoredFile(new File(file.getFilePath(), file.getConvNm()));
		        partWorkFileRepository.deleteByPwSeqAndPiSeq(file.getPwSeq(),file.getPiSeq());
			}
		}
		partWorkRepository.deleteByPiSeq(partInfo.getPiSeq());
		//외사분실운영현황파일삭제
		List<PartInfoFile> partInfoFileList= selectPartInfoFile(partInfo);
		for(PartInfoFile file: partInfoFileList){
		      if(file.getOrigNm() != null){
		        deleteStoredFile(new File(file.getFilePath(), file.getConvNm()));
		      }
		}
		partInfoFileRepository.deleteByPiSeq(partInfo.getPiSeq());
		partInfoRepository.deleteByPiSeq(partInfo.getPiSeq());
		
	}

	public PartInfoFile selectPartInfoFileDown(Integer fileSeq, Integer piSeq, Integer versionNo) {
		return partInfoFileRepository.findById(new PartInfoFileId(fileSeq, piSeq,versionNo)).orElse(null);
	}

	public String selectPartInfoFirstId(PartInfo partInfo) {
		return fipTargetMapper.selectPartInfoFirstId(partInfo.getPiSeq());
	}

	public List<ParamMap> selectTerminalName(PartWork partWork) {
		return fipTargetMapper.selectTerminalName(partWork);
	}
	
	@Transactional
	public void savePartWork(PartWork partWork) {
		PartWork dbPart = partWorkRepository.findTopByPiSeqOrderByPwSeqDesc(partWork.getPiSeq());
		if(dbPart == null) {
			partWork.setPwSeq(1);
			partWorkRepository.save(partWork);
		} else {
			partWork.setPwSeq(dbPart.getPwSeq()+1);
			partWorkRepository.save(partWork);
		}
		if(partWork.getMultipartFileList()!= null){
			saveFilesUpload(partWork.getPwSeq(),partWork.getPiSeq(), partWork.getMultipartFileList());			
		}
	}
	
	private void saveFilesUpload(Integer pwSeq,Integer piSeq, List<MultipartFile> multipartFileList) {
		PartWorkFile lastFileInfo = partWorkFileRepository.findTopByPwSeqAndPiSeqOrderByFileSeqDesc(pwSeq,piSeq);
	    int fileSeq = lastFileInfo==null?1:(lastFileInfo.getFileSeq()+1);
	    for(MultipartFile file : multipartFileList){
	        String saveName = UUID.randomUUID().toString();
	        String path = locationPath+File.separator+"publicFile"+File.separator;
	        saveFile(file, new File(path+File.separator+saveName));

	        String originalFilename = file.getOriginalFilename();
	        int extnIdx = originalFilename.lastIndexOf(".");
	        PartWorkFile fileInfo = new PartWorkFile();	        
	        fileInfo.setFileSeq(fileSeq++);
	        fileInfo.setPwSeq(pwSeq);
	        fileInfo.setPiSeq(piSeq);
	        fileInfo.setOrigNm(originalFilename.substring(0, extnIdx));
	        fileInfo.setFileExtn(originalFilename.substring(extnIdx+1));
	        fileInfo.setConvNm(saveName);
	        fileInfo.setFileSize(calculationSize(file.getSize()));
	        fileInfo.setFilePath(path);
	        partWorkFileRepository.save(fileInfo);
	      }
		
	  }

	public List<PartWork> selectPartWorkList(PartWork partWork) {
		return fipTargetMapper.selectPartWorkList(partWork);
	}

	public Integer selectPartWorkListCnt(PartWork partWork) {
		return fipTargetMapper.selectPartWorkListCnt(partWork);
	}

	public PartWork selectPartWorkInfo(PartWork partWork) {
		return fipTargetMapper.selectPartWorkInfo(partWork);
	}

	public List<PartWorkFile> selectPartWorkFile(PartWork partWork) {
		return partWorkFileRepository.findByPwSeqAndPiSeqOrderByFileSeqAsc(partWork.getPwSeq(),partWork.getPiSeq());
	}
	
	@Transactional
	public void updatePartWork(PartWork partWork, List<Integer> deleteFileSeq) {
		PartWork dbParkWork = partWorkRepository.findById(new PartWorkId(partWork.getPwSeq(),partWork.getPiSeq())).orElse(null);
		partWork.setWrtNm(dbParkWork.getWrtNm());
		partWork.setWrtOrgan(dbParkWork.getWrtOrgan());
		partWork.setWrtPart(dbParkWork.getWrtPart());
		partWork.setWrtUserSeq(dbParkWork.getWrtUserSeq());
		partWorkRepository.save(partWork);
		if(deleteFileSeq!=null && deleteFileSeq.size()>0){
		      deletePartWorkFile(partWork, deleteFileSeq);
		}
		if(partWork.getMultipartFileList()!= null){
			saveFilesUpload(partWork.getPwSeq(),partWork.getPiSeq(), partWork.getMultipartFileList());			
		}		
	}
	
    private void deletePartWorkFile(PartWork partWork, List<Integer> deleteFileSeq) {
	    List<PartWorkFile> partWorkFileList = partWorkFileRepository.findByPwSeqAndPiSeq(partWork.getPwSeq(),partWork.getPiSeq());
	    for(PartWorkFile file: partWorkFileList ){
	      if(deleteFileSeq.contains(file.getFileSeq())){
	        deleteStoredFile(new File(file.getFilePath(), file.getConvNm()));
	        partWorkFileRepository.delete(file);
	      }
	    }
	}
    
    @Transactional
	public void deletePartWork(PartWork partWork) {
		//파일삭제
		List<PartWorkFile> partWorkFileList= partWorkFileRepository.findByPwSeqAndPiSeq(partWork.getPwSeq(),partWork.getPiSeq());
		if(partWorkFileList != null) {
			for(PartWorkFile file: partWorkFileList){
			        deleteStoredFile(new File(file.getFilePath(), file.getConvNm()));
			}
		}
		partWorkFileRepository.deleteByPwSeqAndPiSeq(partWork.getPwSeq(),partWork.getPiSeq());
		partWorkRepository.deleteByPwSeqAndPiSeq(partWork.getPwSeq(),partWork.getPiSeq());									
	}

	public PartWorkFile selectPartWorkFileDown(Integer fileSeq, Integer pwSeq, Integer piSeq) {
		return partWorkFileRepository.findById(new PartWorkFileId(fileSeq, pwSeq,piSeq)).orElse(null);
	}

	public List<ParamMap> selecetVulnOrganList(Vulnerable vulnerable) {
		return fipTargetMapper.selecetVulnOrganList(vulnerable);
	}
	
	@Transactional
	public Integer saveVulnerable(Vulnerable vulnerable,  List<Integer> deleteFileSeq) {
		Integer vulnKey = vulnRepository.save(vulnerable).getVulnKey();
		if(deleteFileSeq!=null && deleteFileSeq.size()>0){
		      deleteVulnFile(vulnerable, deleteFileSeq);
		}
		if(vulnerable.getMultipartFileList()!= null){
		      saveVulnerableFiles(vulnKey, vulnerable.getMultipartFileList());
		}
		return vulnKey;
	}
	
	private void saveVulnerableFiles(Integer vulnKey, List<MultipartFile> multipartFileList) {
		VulnFile lastFileInfo = vulnFileRepository.findTopByVulnKeyOrderByFileSeqDesc(vulnKey);
	    int fileSeq = lastFileInfo==null?1:(lastFileInfo.getFileSeq()+1);
	    for(MultipartFile file : multipartFileList){
	      String saveName = UUID.randomUUID().toString();
	      String path = locationPath+File.separator+"publicFile"+File.separator;
	      saveFile(file, new File(path+File.separator+saveName));

	      String originalFilename = file.getOriginalFilename();
	      int extnIdx = originalFilename.lastIndexOf(".");
	      VulnFile fileInfo = new VulnFile();
	      fileInfo.setVulnKey(vulnKey);
	      fileInfo.setFileSeq(fileSeq++);
	      fileInfo.setOrigNm(originalFilename.substring(0, extnIdx));
	      fileInfo.setFileExtn(originalFilename.substring(extnIdx+1));
	      fileInfo.setConvNm(saveName);
	      fileInfo.setFileSize(calculationSize(file.getSize()));
	      fileInfo.setFilePath(path);
	      vulnFileRepository.save(fileInfo);
	    }
	  }
	
	private void deleteVulnFile(Vulnerable vulnerable, List<Integer> deleteFileSeq) {
	    List<VulnFile> VulnFileList = vulnFileRepository.findByVulnKey(vulnerable.getVulnKey());
	    for(VulnFile file: VulnFileList ){
	      if(deleteFileSeq.contains(file.getFileSeq())){
	        deleteStoredFile(new File(file.getFilePath(), file.getConvNm()));
	        vulnFileRepository.delete(file);
	      }
	    }
	}

	public List<ParamMap> selectVulnerableList(Vulnerable vulnerable) {
		return fipTargetMapper.selectVulnerableList(vulnerable);
	}

	public List<Vulnerable> selectVulnInfoList(Vulnerable vulnerable) {
		return fipTargetMapper.selectVulnInfoList(vulnerable);
	}

	public String selectOrganName(String mgtOrgan) {
		return fipTargetMapper.selectOrganName(mgtOrgan);
	}

	public Vulnerable selectVulnInfo(Vulnerable vulnerable) {
		return fipTargetMapper.selectVulnInfo(vulnerable);
	}

	public List<VulnFile> selectVulnFile(Integer vulnKey) {
		return vulnFileRepository.findByVulnKeyOrderByFileSeq(vulnKey);
	}

	public VulnFile selectVulnInfoFileDown(Integer fileSeq, Integer vulnKey) {
		return vulnFileRepository.findById(new VulnFileId(fileSeq, vulnKey)).orElse(null);
	}
	
	@Transactional
	public void deleteVulnerable(Vulnerable vulnerable) {
		//파일삭제
		List<VulnFile> VulnFileList = vulnFileRepository.findByVulnKey(vulnerable.getVulnKey());
		if(VulnFileList != null) {
			for(VulnFile file: VulnFileList){
			        deleteStoredFile(new File(file.getFilePath(), file.getConvNm()));
			}
		}
		vulnFileRepository.deleteByVulnKey(vulnerable.getVulnKey());
		vulnRepository.deleteById(vulnerable.getVulnKey());
	}		
	
	
	
	
	
}