package incheon.res.rdm.dp.review.web;


import incheon.com.cmm.api.DefaultApiResponse;
import incheon.com.security.vo.LoginVO;
import incheon.res.rdm.com.attachfile.service.RdmComAttachfileService;
import incheon.res.rdm.com.attachfile.service.RdmFileMngUtil;
import incheon.res.rdm.com.attachfile.vo.RdmComAttachfileVO;
import incheon.res.rdm.com.code.service.RdmComCodeService;
import incheon.res.rdm.com.digplan.service.RdmComDigplanService;
import incheon.res.rdm.com.digplan.vo.RdmComDigplanVO;
import incheon.res.rdm.com.msgnlog.service.RdmComMsgnlogService;
import incheon.res.rdm.com.msgnlog.vo.RdmComMsgnlog;
import incheon.res.rdm.com.msgnlog.vo.RdmComMsgnlogVO;
import incheon.res.rdm.com.onnara.OnnaraDocBuilder;
import incheon.res.rdm.com.peracc.service.RdmComPeraccService;
import incheon.res.rdm.com.peracc.vo.RdmComPeraccVO;
import incheon.res.rdm.com.perinfo.service.RdmComPerinfoService;
import incheon.res.rdm.com.perinfo.vo.RdmComPerinfo;
import incheon.res.rdm.com.perinfo.vo.RdmComPerinfoVO;
import incheon.res.rdm.dp.review.service.RdmDpReviewService;
import incheon.res.rdm.dp.review.vo.RdmDpReview;
import incheon.res.rdm.dp.review.vo.RdmDpReviewVO;
import incheon.res.rdm.oe.doc.service.RdmOeDocService;
import incheon.res.rdm.oe.doc.vo.RdmOeDocVO;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.egovframe.rte.ptl.mvc.tags.ui.pagination.PaginationInfo;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.File;
import java.io.FileOutputStream;
import java.nio.charset.StandardCharsets;
import java.util.*;

@Controller
@RequestMapping("${api.rps-path}")
public class RdmDpReviewController {

	protected Log log = LogFactory.getLog(this.getClass());

	@Resource
    private RdmDpReviewService rdmDpReviewService;
	@Resource
    private RdmComPeraccService rdmComPeraccService;
	@Resource
    private RdmComCodeService rdmComCodeService;
	@Resource
    private RdmComPerinfoService rdmComPerinfoService;
	@Resource
    private RdmComAttachfileService rdmComAttachfileService;
	@Resource
    private RdmComDigplanService rdmComDigplanService;
	@Resource
	private RdmComMsgnlogService rdmComMsgnlogService;
	@Resource
	private RdmOeDocService rdmOeDocService;
	@Resource(name="RdmFileMngUtil")
	private RdmFileMngUtil fileUtil;
	@Resource
	private OnnaraDocBuilder onnaraDocBuilder;


	/**
	 * @MethodDESC : 허가신청서 검토 리스트
	 */
	@RequestMapping(value = "/RdmDpReviewL010.do")
	public String selectReviewList(
			@ModelAttribute("loginUser") LoginVO loginVO,
			@ModelAttribute RdmDpReviewVO vo,
			@RequestParam(defaultValue = "1") int pageIndex,
			ModelMap model
	) throws Exception{

		RdmComPeraccVO rdmComPeraccVO = new RdmComPeraccVO();
		String[] arrStr ={"RDH201", "RDH700"};
		rdmComPeraccVO.setRoadDggPrcsSttsArray(arrStr);
		rdmComPeraccVO.setInCheck("Y");
		rdmComPeraccVO.setMngInstCdSe(loginVO.getRoadMngInstCd());
		rdmComPeraccVO.setRegDtSe(vo.getRegDtSe());
		rdmComPeraccVO.setExseStpoDngCd(vo.getStdgEmdCdSe());
		rdmComPeraccVO.setCstrnNmSe(vo.getCstrnNmSe());
		rdmComPeraccVO.setBzentyNmSe(vo.getBzentyNmSe());

		rdmComPeraccVO.setPageIndex(pageIndex);

		/*페이징*/
		PaginationInfo paginationInfo = new PaginationInfo();
		paginationInfo.setCurrentPageNo(pageIndex);
		paginationInfo.setRecordCountPerPage(rdmComPeraccVO.getRecordCountPerPage());
		paginationInfo.setPageSize(rdmComPeraccVO.getPageSize());

		rdmComPeraccVO.setFirstIndex(paginationInfo.getFirstRecordIndex());
		rdmComPeraccVO.setLastIndex(paginationInfo.getLastRecordIndex());
		rdmComPeraccVO.setRecordCountPerPage(paginationInfo.getRecordCountPerPage());

        Map map = rdmComPeraccService.selectPeraccList(rdmComPeraccVO);

        int totCnt = Integer.parseInt(map.get("resultCnt").toString());
        paginationInfo.setTotalRecordCount(totCnt);

        List yearList = rdmComCodeService.getYearList("Y");
        List bjdCdeList = rdmComCodeService.selectDocdList("Y");

		model.addAttribute("resultList", map.get("resultList"));
        model.addAttribute("paginationInfo", paginationInfo);
        model.addAttribute("searchVo", vo);
        model.addAttribute("yearList", yearList);
        model.addAttribute("bjdCdeList", bjdCdeList);

		return "res/rdm/dp/review/RdmDpReviewL010";
	}


	/**
	 * @MethodDESC : 허가신청서 검토 정보
	 */
	@RequestMapping(value = "/RdmDpReviewR010.do")
	public String selectReview(
			@ModelAttribute("loginUser") LoginVO loginVO,
			@ModelAttribute RdmDpReviewVO vo,
			ModelMap model
	) throws Exception{
		
		//공사개요
		RdmComPerinfoVO perInfoVO = new RdmComPerinfoVO();
		perInfoVO.setRoadDggMngNo(vo.getRoadDggMngNo());
		perInfoVO.setUserAcntMngNo(loginVO.getUserUnqId());
		RdmComPerinfo perInfo = rdmComPerinfoService.selectPerinfo(perInfoVO);

		if( !loginVO.getRoadMngInstCd().equals(perInfo.getMngInstCd())
			|| !perInfo.getRoadDggPrcsStts().equals(vo.getRoadDggPrcsStts()) ){
			return "redirect:/rps/RdmDpReviewL010.do";
		}

		String rdiIdn = vo.getRoadDggMngNo();
		
		RdmComDigplanVO digplanVO = new RdmComDigplanVO();
		digplanVO.setRoadDggMngNo(rdiIdn);
		ArrayList digplanList = (ArrayList)rdmComDigplanService.selectDigplanList(digplanVO);
		
		model.addAttribute("perInfo", perInfo);
		model.addAttribute("digplanList", digplanList);
		model.addAttribute("searchVo", vo);

		return "res/rdm/dp/review/RdmDpReviewR010";
	}


	/**
	 * @MethodDESC : 검토완료 뷰
	 */
	@RequestMapping(value = "/LayerPopRdmDpReviewU020.do")
	public String updatePermissionView(@ModelAttribute RdmDpReviewVO vo, ModelMap model)
	  throws Exception{

		//공사개요
		RdmComPerinfoVO perInfoVO = new RdmComPerinfoVO();
		perInfoVO.setRoadDggMngNo(vo.getRoadDggMngNo());
		RdmComPerinfo perInfo = rdmComPerinfoService.selectPerinfo(perInfoVO);

		model.addAttribute("perInfo", perInfo);
		model.addAttribute("searchVo", vo);

		return "res/rdm/dp/review/LayerPopRdmDpReviewU020";
	}

	/**
	 * @MethodDESC : 검토완료
	 */
	@RequestMapping(value = "/RdmDpReviewU021.do")
	public ResponseEntity<DefaultApiResponse<Map<String, Object>>> updatePermission(
			HttpServletRequest request,
			final MultipartHttpServletRequest multiRequest,
			@ModelAttribute RdmDpReviewVO vo
	) throws Exception{

		try {
			RdmDpReview rdmDpReview = rdmDpReviewService.selectRdpidn(vo);

			vo.setRoadDggPrmsnNo(rdmDpReview.getRoadDggPrmsnNo());
			vo.setRoadDggPrcsStts("RDH206");

			String message = rdmDpReviewService.updatePermission(vo);

			//첨부파일 삭제
			RdmComAttachfileVO attachFileVO = new RdmComAttachfileVO();
			attachFileVO.setDatSeq(vo.getRoadDggMngNo());
			attachFileVO.setTblNam("RMT_RDIG_MT");
			String atfCde[] = {"ATF210"};
			for(int i=0; i<atfCde.length; i++){
				attachFileVO.setAtfCde(atfCde[i]);
				rdmComAttachfileService.deleteAttachfileCde(attachFileVO);
			}
			String rdiIdn = vo.getRoadDggMngNo();

			// 첨부파일 관련 첨부파일ID 생성
			List<RdmComAttachfileVO> _result = null;
			String[] atfCodeList = {"ATF210"};

			final Map<String, MultipartFile> files = multiRequest.getFileMap();
			if(!files.isEmpty()){
				_result = fileUtil.parseFileInf(request, files, rdiIdn, "RMT_RDIG_MT", atfCodeList);

				Iterator iter = _result.iterator();
				while (iter.hasNext()) {
					rdmComAttachfileService.insertAttachfile((RdmComAttachfileVO)iter.next());
				}
			}

			Map<String, Object> resultMap = new HashMap<String, Object>();
			if(message.equals("succ")){
				resultMap.put("result","succ");
			}else{
				return ResponseEntity.badRequest().build();
			}
			return ResponseEntity.ok(DefaultApiResponse.success(resultMap));
		}catch (IllegalStateException e) {
			log.error("검토완료 중 오류가 발생했습니다.");
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
		}
	}

	/**
	 * @MethodDESC : 불허 수정 뷰
	 */
	@RequestMapping(value = "/LayerPopRdmDpReviewU030.do")
	public String updateNonPermissionView(@ModelAttribute RdmDpReviewVO vo, ModelMap model)
	  throws Exception{

		//공사개요
		RdmComPerinfoVO perInfoVO = new RdmComPerinfoVO();
		perInfoVO.setRoadDggMngNo(vo.getRoadDggMngNo());
		RdmComPerinfo perInfo = rdmComPerinfoService.selectPerinfo(perInfoVO);

		model.addAttribute("perInfo", perInfo);
		model.addAttribute("searchVo", vo);

		return "res/rdm/dp/review/LayerPopRdmDpReviewU030";
	}

	/**
	 * @MethodDESC : 불허
	 */
	@RequestMapping(value = "/RdmDpReviewU031.do")
	public ResponseEntity<DefaultApiResponse<Map<String, Object>>> updateNonPermission(
			HttpServletRequest request,
			final MultipartHttpServletRequest multiRequest,
			@ModelAttribute RdmDpReviewVO vo
	) throws Exception{

		try {
			String message = rdmDpReviewService.updateNonPermission(vo);

			//첨부파일 삭제
			RdmComAttachfileVO attachFileVO = new RdmComAttachfileVO();
			attachFileVO.setDatSeq(vo.getRoadDggMngNo());
			attachFileVO.setTblNam("RMT_RDIG_MT");
			String atfCde[] = {"ATF211"};
			for(int i=0; i<atfCde.length; i++){
				attachFileVO.setAtfCde(atfCde[i]);
				rdmComAttachfileService.deleteAttachfileCde(attachFileVO);
			}
			String rdiIdn = vo.getRoadDggMngNo();

			// 첨부파일 관련 첨부파일ID 생성
			List<RdmComAttachfileVO> _result = null;

			final Map<String, MultipartFile> files = multiRequest.getFileMap();
			if(!files.isEmpty()){
				_result = fileUtil.parseFileInf(request, files, rdiIdn, "RMT_RDIG_MT", null);

				Iterator iter = _result.iterator();
				while (iter.hasNext()) {
					rdmComAttachfileService.insertAttachfile((RdmComAttachfileVO)iter.next());
				}
			}

			Map<String, Object> resultMap = new HashMap<String, Object>();
			if(message.equals("succ")){
				resultMap.put("result","succ");
			}else{
				return ResponseEntity.badRequest().build();
			}
			return ResponseEntity.ok(DefaultApiResponse.success(resultMap));
		}catch (IllegalStateException e) {
			log.error("불허 처리 중 오류가 발생했습니다.");
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
		}
	}

	/**
	 * @MethodDESC : 현장조사서 등록 파일
	 */
	@RequestMapping(value = "/RdmDpReviewU041.do")
	public ResponseEntity<DefaultApiResponse<Map<String, Object>>> updateCondition(
			HttpServletRequest request,
			final MultipartHttpServletRequest multiRequest,
			@ModelAttribute RdmDpReviewVO vo
	) throws Exception{

		try {
			String message ="succ";
			String atfCde[] = {"ATF213"};
			String rdiIdn = vo.getRoadDggMngNo();

			final Map<String, MultipartFile> files = multiRequest.getFileMap();
			//파일삭제 현장조사서
			RdmComAttachfileVO rdmComAttachFileVO = new RdmComAttachfileVO();
			rdmComAttachFileVO.setTblNam("RMT_RDIG_MT");
			rdmComAttachFileVO.setDatSeq(rdiIdn);
			for(int i=0; i<atfCde.length; i++){
				rdmComAttachFileVO.setAtfCde(atfCde[i]);
				rdmComAttachfileService.deleteAttachfileCde(rdmComAttachFileVO);
			}

			// 첨부파일 관련 첨부파일ID 생성
			List<RdmComAttachfileVO> _result = null;

			if(!files.isEmpty()){
				_result = fileUtil.parseFileInf(request, files, rdiIdn, "RMT_RDIG_MT", atfCde);

				Iterator iter = _result.iterator();
				while (iter.hasNext()) {
					rdmComAttachfileService.insertAttachfile((RdmComAttachfileVO)iter.next());
				}

				message = "succ";
			}
			Map<String, Object> resultMap = new HashMap<String, Object>();
			if(message.equals("succ")){
				resultMap.put("result","succ");
			}else{
				return ResponseEntity.badRequest().build();
			}
			return ResponseEntity.ok(DefaultApiResponse.success(resultMap));
		}catch (IllegalStateException e) {
			log.error("현장조사서 파일 등록 중 오류가 발생했습니다.");
			return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
		}
	}


	/**
	 * @MethodDESC : 현장조사서 파일 조회
	 */
	@RequestMapping(value = "/LayerPopRdmDpReviewU040.do")
	public String selectCondition(@ModelAttribute RdmDpReviewVO vo, ModelMap model) throws Exception{

		model.addAttribute("vo", vo);

		return "res/rdm/dp/review/LayerPopRdmDpReviewU040";
	}


	/**
	 * @MethodDESC : 전자결재 팝업 뷰
	 */
	@RequestMapping(value = "/LayerPopRdmDpReviewU050.do")
	public String layerPopRdmDpReviewU050(@ModelAttribute RdmComPerinfoVO vo, ModelMap model) throws Exception{

		model.addAttribute("vo", vo);

		return "res/rdm/dp/review/LayerPopRdmDpReviewU050";
	}


	/**
	 * @MethodDESC : 전자결재 > 온나라 민원 연계
	 */
	@RequestMapping(value = "/RdmDpReviewU051.do")
	public ResponseEntity<DefaultApiResponse<Map<String, Object>>> rdmDpReviewU051(
			@ModelAttribute("loginUser") LoginVO loginVO,
			HttpServletRequest request,
			final MultipartHttpServletRequest multiRequest,
			@ModelAttribute RdmDpReviewVO vo
	) throws Exception{

		Map<String, Object> resultMap = new HashMap<String, Object>();

		String roadDggMngNo = vo.getRoadDggMngNo();
		String docTtl = vo.getDocTtl();
		String docMtxt = vo.getDocMtxt();

		final Map<String, MultipartFile> files = multiRequest.getFileMap();

		Map<String, String> userInfo = new HashMap<>();
		userInfo.put("userId", loginVO.getUserId());
		userInfo.put("userNm", loginVO.getUserNm());
		userInfo.put("roadMngInstCd", loginVO.getRoadMngInstCd());
		userInfo.put("roadMngInstNm", loginVO.getRoadMngInstNm());
		userInfo.put("deptCd", loginVO.getDeptCd());
		userInfo.put("deptNm", loginVO.getDeptNm());
		userInfo.put("jbpsNm", loginVO.getJbpsNm());
		userInfo.put("emlAddr", loginVO.getEmlAddr());

		// 연계문서 생성
		boolean result = onnaraDocBuilder.createDoc(userInfo, roadDggMngNo, docTtl, docMtxt, files);
		if(!result) {
			return ResponseEntity.badRequest()
					.body(DefaultApiResponse.error(500, "연계문서 생성 오류", ""));
		}

		// 상태 없데이트
		RdmComMsgnlogVO rdmComMsgnlogVO = new RdmComMsgnlogVO();
		rdmComMsgnlogVO.setRoadDggMngNo(roadDggMngNo);
		RdmComMsgnlog rdmComMsgnlog =  rdmComMsgnlogService.selectDigInfo(rdmComMsgnlogVO);

		RdmComPerinfoVO perinfoVO = new RdmComPerinfoVO();
		perinfoVO.setRoadDggMngNo(roadDggMngNo);
		perinfoVO.setUserAcntMngNo(loginVO.getUserUnqId());
		perinfoVO.setRoadDggPrcsStts("RDH700");
		perinfoVO.setTmpRoadDggPrcsStts(rdmComMsgnlog.getRoadDggPrcsStts());

		int updateRdhcdeCnt = rdmComPerinfoService.updateRdhcde(perinfoVO);
		if(updateRdhcdeCnt < 1) {
			return ResponseEntity.badRequest()
					.body(DefaultApiResponse.error(500, "상태 없데이트 오류", ""));
		}

		// 전자문서결재송신정보 저장
		RdmOeDocVO docVO = new RdmOeDocVO();
		docVO.setRoadDggMngNo(roadDggMngNo);
		docVO.setLinkPnttmCd("-");
		docVO.setAtrzTrsmSn("1");
		docVO.setDsptchInstId(loginVO.getUserId());
		docVO.setSndptyId(loginVO.getUserId());
		docVO.setSndptyEml(loginVO.getEmlAddr());
		docVO.setRcptnInstId(loginVO.getUserId());
		docVO.setRcptnId(loginVO.getUserId());
		docVO.setRcvrEml(loginVO.getEmlAddr());
		docVO.setDocTtl(docTtl);
		docVO.setDocMtxt(docMtxt);

		int insertEdocCnt = rdmOeDocService.insertEdoc(docVO);
		if(insertEdocCnt < 1) {
			return ResponseEntity.badRequest()
					.body(DefaultApiResponse.error(500, "전자문서결재송신정보 저장 오류", ""));
		}

		resultMap.put("result","succ");
		return ResponseEntity.ok(DefaultApiResponse.success(resultMap));
	}

	/**
	 * @MethodDESC : 전자결재 > 온나라 민원 연계 > 읍답 xml 변환
	 * TODO 테스트
	 */
	@RequestMapping(value = "/xmlDecode.do")
	public ResponseEntity<DefaultApiResponse<Map<String, Object>>> xmlDecode(
			@ModelAttribute RdmDpReviewVO vo
	) throws Exception{

		Map<String, Object> resultMap = new HashMap<String, Object>();

		// XML 파일 로드
		File xmlFile = new File("C:\\idc01/suda1211DOC628000002ADM6280000962026010216534516126.xml");
		DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
		dbFactory.setValidating(false);
		dbFactory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
		DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
		Document doc = dBuilder.parse(xmlFile);
		doc.getDocumentElement().normalize();

		// 모든 <content> 태그 가져오기
		NodeList contentNodes = doc.getElementsByTagName("content");

		for (int i = 0; i < contentNodes.getLength(); i++) {
			Element contentElement = (Element) contentNodes.item(i);

			// filename 속성(Base64 인코딩된 파일명)
			String encodedFilename = contentElement.getAttribute("filename");
			String filename = new String(Base64.getDecoder().decode(encodedFilename), StandardCharsets.UTF_8);

			// Base64 데이터 (태그 안의 텍스트)
			String base64Data = contentElement.getTextContent().replaceAll("\\s+", ""); // 공백/개행 제거
			byte[] decodedBytes = Base64.getDecoder().decode(base64Data);

			File decodeFile = new File("C:\\idc01/decode/" + filename);

			// 파일 저장
			try (FileOutputStream fos = new FileOutputStream(decodeFile)) {
				fos.write(decodedBytes);
				System.out.println("저장 완료: " + filename);
			}
		}

		resultMap.put("result","succ");
		return ResponseEntity.ok(DefaultApiResponse.success(resultMap));
	}
}