package incheon.ags.ias.srvy.srvyResult.service.impl;

import incheon.ags.ias.srvy.srvyResult.mapper.SrvyResultMapper;
import incheon.ags.ias.srvy.srvyResult.service.SrvyResultService;
import incheon.ags.ias.srvy.srvyResult.vo.SrvyResultSearchVO;
import incheon.ags.ias.srvy.srvyResult.vo.SrvyResultVO;
import incheon.ags.ias.srvy.srvyResult.vo.SrvyResultDetailVO;
import incheon.ags.ias.srvy.srvyResult.vo.SrvyQitemResultVO;
import incheon.ags.ias.srvy.srvyResult.vo.SrvyQitemArtclResultVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 설문 결과 Service 구현
 */
@Service
public class SrvyResultServiceImpl implements SrvyResultService {

    @Autowired
    private SrvyResultMapper srvyResultMapper;

    @Override
    public List<SrvyResultVO> selectSrvyResultList(SrvyResultSearchVO searchVO) throws Exception {
        return srvyResultMapper.selectSrvyResultList(searchVO);
    }

    @Override
    public int selectSrvyResultListCnt(SrvyResultSearchVO searchVO) throws Exception {
        return srvyResultMapper.selectSrvyResultListCnt(searchVO);
    }

    @Override
    public SrvyResultDetailVO selectSrvyResultDetail(Integer srvySn) throws Exception {
        SrvyResultDetailVO detailVO = srvyResultMapper.selectSrvyResultDetail(srvySn);
        
        if (detailVO != null) {
            List<SrvyQitemResultVO> qitemList = srvyResultMapper.selectSrvyQitemResultList(srvySn);
            List<SrvyQitemArtclResultVO> artclList = srvyResultMapper.selectSrvyQitemArtclResultList(srvySn);
            
            // 객관식 문항의 선택지 매핑
            Map<Integer, List<SrvyQitemArtclResultVO>> artclMap = artclList.stream()
                    .collect(Collectors.groupingBy(SrvyQitemArtclResultVO::getQitemSn));
            
            // 주관식 문항 ID 수집
            List<Integer> subjectiveQitemIds = qitemList.stream()
                    .filter(this::isSubjectiveQuestion)
                    .map(SrvyQitemResultVO::getSrvyQitemSn)
                    .collect(Collectors.toList());
            
            // 주관식 답변을 한 번에 조회 (N+1 문제 해결)
            Map<Integer, List<String>> subjectiveAnswersMap = new HashMap<>();
            if (!subjectiveQitemIds.isEmpty()) {
                List<Map<String, Object>> batchResults = srvyResultMapper.selectSubjectiveAnswersBatch(subjectiveQitemIds);
                
                // Map으로 변환
                for (Map<String, Object> result : batchResults) {
                    Object qitemSnObj = result.get("qitem_sn");
                    String rspnsCn = (String) result.get("rspns_cn");
                    
                    Integer qitemSn = null;
                    if (qitemSnObj instanceof java.math.BigDecimal) {
                        qitemSn = ((java.math.BigDecimal) qitemSnObj).intValue();
                    } else if (qitemSnObj instanceof Integer) {
                        qitemSn = (Integer) qitemSnObj;
                    } else if (qitemSnObj instanceof Long) {
                        qitemSn = ((Long) qitemSnObj).intValue();
                    }
                    
                    if (qitemSn != null && rspnsCn != null) {
                        subjectiveAnswersMap.computeIfAbsent(qitemSn, k -> new ArrayList<>()).add(rspnsCn);
                    }
                }
            }
            
            // 문항별 데이터 설정
            for (SrvyQitemResultVO qitem : qitemList) {
                if (isObjectiveQuestion(qitem)) {
                    List<SrvyQitemArtclResultVO> filteredArtclList = artclMap.get(qitem.getSrvyQitemSn());
                    if (filteredArtclList != null && !filteredArtclList.isEmpty()) {
                        qitem.setArtclList(filteredArtclList);
                    }
                } else if (isSubjectiveQuestion(qitem)) {
                    List<String> answers = subjectiveAnswersMap.get(qitem.getSrvyQitemSn());
                    if (answers != null && !answers.isEmpty()) {
                        qitem.setSubjectiveAnswers(answers);
                    } else {
                        // 주관식 답변이 없는 경우 빈 리스트 설정
                        qitem.setSubjectiveAnswers(new ArrayList<>());
                    }
                }
            }
            
            detailVO.setQitemList(qitemList);
        }
        
        return detailVO;
    }
    
    /**
     * 객관식 문항 여부 확인
     */
    private boolean isObjectiveQuestion(SrvyQitemResultVO qitem) {
        return "QITEMTY001".equals(qitem.getQitemTypeCd()) || 
               "1".equals(qitem.getQitemTypeCd());
    }
    
    /**
     * 주관식 문항 여부 확인
     */
    private boolean isSubjectiveQuestion(SrvyQitemResultVO qitem) {
        return "QITEMTY002".equals(qitem.getQitemTypeCd()) || 
               "2".equals(qitem.getQitemTypeCd());
    }
    
}