const xpath = require('xpath');
const { DOMParser } = require('xmldom');
const _ = require('lodash');

const findSimilarString = require('./findSimilarString');

module.exports = getGpdpScore;

function parseColorToHex(colorString) {
  // 정규식을 사용하여 B, G, R, A 값 추출
  const regex = /B:\s*(\d+),\s*G:\s*(\d+),\s*R:\s*(\d+),\s*A:\s*(\d+)/;
  const matches = colorString.match(regex);

  if (!matches) {
    throw new Error('Invalid color string format');
  }

  // matches[1]은 B, matches[2]는 G, matches[3]은 R, matches[4]는 A
  const [_, b, g, r, a] = matches;

  // 각 값을 16진수로 변환하고 2자리로 패딩
  const rHex = parseInt(r).toString(16).padStart(2, '0');
  const gHex = parseInt(g).toString(16).padStart(2, '0');
  const bHex = parseInt(b).toString(16).padStart(2, '0');
  const aHex = parseInt(a).toString(16).padStart(2, '0');

  // #RRGGBBAA 형식으로 반환
  return `${rHex}${gHex}${bHex}`;
}

/**
 * /Document/Layers/Layer/Shapes/Shape/draw_type 속성값
 * > Interior: 내부 채우기 / Outline: 외곽선
 * /Document/Layers/Layer/Shapes/Shape/interior_type 속성값
 * > Fill: 채우기 / Gradient: 그라데이션
 * @param {*} gpdpData 
 * @param {*} scoringJson 
 * @param {*} index 
 * @returns 
 */

// xml 형식의 GPDP 파일을 읽어서 점수를 계산
// scoring.json 파일 내에 있는 ele 요소는 xpath 형식으로 접근하여 요소를 탐색하고 나오는 값을 value와 비교하여 점수를 계산
// scoring.json 파일 내에 있는 type은 비교할 값의 타입을 의미하며, boolean, array 등이 있음
// scoring.json 파일 내에 있는 type에 따라 비교하는 방식이 달라짐
// 채점 결과를 scoringResultList 배열에 저장
function getGpdpScore(gpdpData, scoringJson, index) {
  function compareAndScore(user, right, point, key, scoringResult, options = {}) {
    let score = 0;
    let isEqual = false;

    const {
      tolerance = 0,  // 숫자 비교 시 허용 오차
      type = 'auto',  // 'auto' | 'number[]' | 'string[]' | 'object' | 'primitive'
      partial = false,
    } = options;

    if (type === 'force-correct') {
      score = point;
    }
    // 객체 비교
    else if (
      (type === 'object' || (type === 'auto' && typeof right === 'object' && typeof user === 'object'))
      && !Array.isArray(right)
    ) {
      if (partial) {
        const keys = Object.keys(right);
        const partialPoint = point / keys.length;
        for (const k of keys) {
          if (_.isEqual(user[k], right[k])) {
            score += partialPoint;
          }
        }
      } else {
        if (_.isEqual(user, right)) {
          score = point;
        }
      }
    }

    // 배열 비교
    else if (Array.isArray(right) && Array.isArray(user)) {
      if (right.length === user.length) {
        if (type === 'number[]' || (type === 'auto' && typeof right[0] === 'number')) {
          if (right.every((val, idx) => val === user[idx])) {
            score = point;
          }
        } else if (type === 'string[]' || (type === 'auto' && typeof right[0] === 'string')) {
          if (right.every((val, idx) => val === user[idx])) {
            score = point;
          }
        }
      }
    }

    // 원시값 비교
    else {
      if (user == right) {
        score = point;
      }
    }

    console.log(`▶ 작성답안:`, user);
    if (score > 0) {
      if (partial)
        console.log('⭕부분정답:', right, `(${score}/${point})`);
      else
        console.log('⭕  정답 : ', right, `(${score}/${point})`);
    }
    else {
      console.log(`❌  오답:`, right);
    }

    scoringResult[key] = score;
    return score;
  }

  const gpdpXmlDoc = gpdpData;
  const scoringResult = {};

  const scoringData = scoringJson[index];
  // console.log(scoringData);

  const layerList = xpath.select('/Document/Layers/Layer', gpdpXmlDoc);

  layerList.forEach((layer, layerIndex) => {
    const childNodes = Array.from(layer.childNodes);
    childNodes.forEach(child => {
      // console.log("🚀 ~ child node:", child);
    });
  });

  let totalScore = 0;

  // 채점기준표 문항별 분류
  for (const key in scoringData) {
    console.log(`❔❔ 문제번호 : [${index}-${key}]`)

    let ele = scoringData[key].ele;
    let ele2 = scoringData[key].ele2;
    const rightAnswer = scoringData[key].value;
    const point = scoringData[key].point;
    const type = scoringData[key].type;
    let search = scoringData[key].search;

    let userAnswer = null;

    const layer = scoringData[key].layer;
    const option = scoringData[key].option;
    const style = scoringData[key].style;

    ele = typeof ele === 'string' ? ele.replace(/{layer}/g, layer) : ele;
    ele = typeof ele === 'string' ? ele.replace(/{option}/g, option) : ele;
    ele = typeof ele === 'string' ? ele.replace(/{style}/g, style) : ele;

    // search 값이 undefined 아니면 ele의 {search}부분을 search로 치환
    /**
     * JSON파일 곰믹스 5번문항/22번 문항
     * type : "video" 인 항목들
     * GPString태그 VID7속성 찾는 xpath구문
     * CRCUnitArr태그 Name속성 찾는 구문으로 변환
     * > 멀티라인 텍스트 유사도 판별하기 어려움
     */
    if (search !== undefined) {
      let result = findSimilarString(gpdpXmlDoc, search, 0.8);
      if (result !== null) {
        result = result.replace(/"/g, "'");
        search = result;
        ele = ele?.replace(/{search}/g, search);
      }
      else {
        ele = ele?.includes('{search}') ? null : ele;
      }
    }

    if (type === "none") {
      console.log("⚠️ 채점하지 않음");
      scoringResult[key] = "확인필요";
      continue;
    }

    else if (type === "canvas.Size") {
      const result = xpath.select(ele, gpdpXmlDoc);
      const width = result[0].value;
      const height = result[1].value;

      userAnswer = [width, height];
      totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult, { type: 'number[]' });

      continue;
    }

    // [1-4] 사진1 > 조정
    else if (type === "layer.Effects") {
      const effects = ele ? xpath.select(ele, gpdpXmlDoc) : [];

      let isMatched = false;
      for (const item of effects) {
        const name = xpath.select1('Name/@value', item)?.value;
        const effectData = xpath.select1(`EffectData`, item);

        // 동일한 이펙트 요소만 검사
        if (rightAnswer['name'] !== name) {
          continue;
        }

        userAnswer = {
          name: name,
          option: {},
        }
        const optionKeys = Object.keys(rightAnswer['option']);
        if (name === '흑백') {
          const Intensity = xpath.select1('Intensity/@value', effectData)?.value;
          if (optionKeys.includes('강도')) userAnswer['option']['강도'] = Intensity;
        }
        else if (name === '밝기/대비') {
          const brightness = xpath.select1('brightness/@value', effectData)?.value;
          const contrast = xpath.select1('contrast/@value', effectData)?.value;
          if (optionKeys.includes('밝기')) userAnswer['option']['밝기'] = brightness;
          if (optionKeys.includes('대비')) userAnswer['option']['대비'] = contrast;
        }
        else if (name === '노출') {
          const ExposureValue = xpath.select1('ExposureValue/@value', effectData)?.value;
          if (optionKeys.includes('노출')) userAnswer['option']['노출'] = ExposureValue;
        }
        else if (name === '색조/채도') {
          const hue = xpath.select1('hue/@value', effectData)?.value;
          const saturation = xpath.select1('saturation/@value', effectData)?.value;
          const lightness = xpath.select1('lightness/@value', effectData)?.value;
          if (optionKeys.includes('색조')) userAnswer['option']['색조'] = hue;
          if (optionKeys.includes('채도')) userAnswer['option']['채도'] = saturation;
          if (optionKeys.includes('명도')) userAnswer['option']['명도'] = lightness;
        }
        else if (name === '감마') {
          const lift = xpath.select1('Lift/@value', effectData)?.value;
          const gamma = xpath.select1('Gamma/@value', effectData)?.value;
          const gain = xpath.select1('Gain/@value', effectData)?.value;
          if (optionKeys.includes('리프트')) userAnswer['option']['리프트'] = lift;
          if (optionKeys.includes('감마')) userAnswer['option']['감마'] = gamma;
          if (optionKeys.includes('게인')) userAnswer['option']['게인'] = gain;
        }
        else if (name === '세피아') {
          const u = xpath.select1('U/@value', effectData)?.value;
          const v = xpath.select1('V/@value', effectData)?.value;

          const optionKeys = Object.keys(rightAnswer['option']).map(key => key.toUpperCase());
          if (optionKeys.includes('U')) userAnswer['option']['U'] = u;
          if (optionKeys.includes('V')) userAnswer['option']['V'] = v;
        }
        else if (name === '생동감') {
          const vibranceValue = xpath.select1('VibranceValue/@value', effectData)?.value;
          // 생동감 옵션값이 프로그램에서 적용한 값에 오차가 발생하는 경우가 있음
          // 곰픽>XML / 30>29 / 40>39 
          // 설정한 값 그대로 적용되는 경우도 있어서 오차범위 2로 설정
          const userValue = parseInt(vibranceValue, 10);
          const rightValue = parseInt(rightAnswer.option['생동감'], 10);
          if (Math.abs(rightValue - userValue) <= 2) {
            if (optionKeys.includes('생동감')) {
              userAnswer['option']['생동감'] = rightValue.toString();
            }
          }
        }
        else if (name === '흐리게') {
          const radius = xpath.select1('radius/@value', effectData)?.value;
          if (optionKeys.includes('반경')) userAnswer['option']['반경'] = radius;
        }
        else if (name === '글로우') {
          const radius = xpath.select1('radius/@value', effectData)?.value;
          const brightness = xpath.select1('brightness/@value', effectData)?.value;
          const contrast = xpath.select1('contrast/@value', effectData)?.value;
          if (optionKeys.includes('반경')) userAnswer['option']['반경'] = radius;
          if (optionKeys.includes('밝기')) userAnswer['option']['밝기'] = brightness;
          if (optionKeys.includes('대비')) userAnswer['option']['대비'] = contrast;
        }
        else if (name === '픽셀효과') {
          const cellSize = xpath.select1('cellSize/@value', effectData)?.value;
          if (optionKeys.includes('셀크기')) userAnswer['option']['셀크기'] = cellSize;
        }
        else if (name === '선명하게') {
          const amount = xpath.select1('amount/@value', effectData)?.value;
          if (optionKeys.includes('양')) userAnswer['option']['양'] = amount;
        }

        for (const key in rightAnswer.option) {
          // 속성값이 정답과 다른 경우가 있으면 오답처리
          if (rightAnswer.option[key] !== userAnswer.option[key]) {
            isMatched = false;
            break;
          }
          else {
            isMatched = true;
          }
        }

        // 속성값이 하나라도 일치하지 않으면 오답
        if (isMatched === false) {
          break;
        }
      }
      totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult);
      continue;
    }

    // 
    // else if (type === "exists") {
    else if (type.includes("exists")) {
      const existsValues = xpath.select(ele, gpdpXmlDoc);
      let isMatched = false;

      for (const v of existsValues) {
        userAnswer = v.value;

        if (type.includes('layer') || type.includes('text')) {

          // 공백, 대소문자 무시
          const cleanUserAnswer = userAnswer.replace(/\s+/g, '').toLowerCase();
          const cleanRightAnswer = rightAnswer.replace(/\s+/g, '').toLowerCase();

          // 하나라도 일치하면 정답
          if (cleanUserAnswer === cleanRightAnswer) {
            isMatched = true;
            break;
          }
        }
        else {
          if (userAnswer === rightAnswer) {
            isMatched = true;
            break;
          }
        }
      }
      if (isMatched) {
        totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult, {
          type: 'force-correct'
        });
      }
      else {
        totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult);
      }

    }


    // else if (type === "shape.size") {
    else if (type.includes("size")) {
      const items = xpath.select(ele, gpdpXmlDoc);
      let isMatched = false;

      // 각 Item 요소별 x,y 좌표 시작점과 끝점의 거리를 계산해 정답과 비교
      for (const item of items) {
        const x1 = Number(xpath.select1('Item[1]/X/@value', item)?.value);
        const y1 = Number(xpath.select1('Item[1]/Y/@value', item)?.value);

        const x2 = Number(xpath.select1('Item[last()]/X/@value', item)?.value);
        const y2 = Number(xpath.select1('Item[last()]/Y/@value', item)?.value);

        const width = Math.round(Math.abs(x2 - x1));
        const height = Math.round(Math.abs(y2 - y1));

        userAnswer = {
          width: width,
          height: height,
        };

        // 하나라도 일치하면 정답
        if (JSON.stringify(userAnswer) == JSON.stringify(rightAnswer)) {
          isMatched = true;
          break;
        }
      }

      totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult);
      continue;
    }

    // [1-8]
    else if (type.includes("color")) {
      const items = xpath.select(ele, gpdpXmlDoc);
      let normalizedAnswer = null;
      let isMatched = false;

      const isGradient = type.includes("gradient");
      const isSingleColor =
        type.includes("shape") || type.includes("text") || type.includes("clipping");

      // 정답 색상 정규화
      if (isGradient) {
        normalizedAnswer = {
          startColor: rightAnswer.startColor.toLowerCase(),
          endColor: rightAnswer.endColor.toLowerCase(),
        };
      } else if (isSingleColor) {
        normalizedAnswer = rightAnswer.toLowerCase?.();
      }

      // 각 항목 비교
      for (const item of items) {
        // 그라데이션 컬러의 채점
        if (isGradient) {
          // 시작점과 끝점의 컬러를 구할 xpath구문 
          const startColorXpath = scoringData[key].startColor;
          const endColorXpath = scoringData[key].endColor;

          // 해당 xpath를 이용 RGB값 추출
          const startColorRGB = xpath.select1(startColorXpath, item)?.value;
          const endColorRGB = xpath.select1(endColorXpath, item)?.value;

          // RGB to HEX
          const userStartColor = parseColorToHex(startColorRGB);
          const userEndColor = parseColorToHex(endColorRGB);

          userAnswer = {
            startColor: userStartColor,
            endColor: userEndColor,
          };

          if (JSON.stringify(userAnswer) === JSON.stringify(normalizedAnswer)) {
            isMatched = true;
            break;
          }
        }

        if (isSingleColor) {
          const color = parseColorToHex(item.value);
          userAnswer = color;

          if (userAnswer === normalizedAnswer) {
            isMatched = true;
            break;
          }
        }
      }

      totalScore += compareAndScore(userAnswer, normalizedAnswer, point, key, scoringResult);
    }

    else if (type === 'layer.blend.opacity') {
      const layers = xpath.select(ele, gpdpXmlDoc);
      let isMatched = false;

      for (const layer of layers) {
        const blendop = xpath.select1('BlendOp/@value', layer).value;
        const opacity = xpath.select1('Opacity/@value', layer).value;

        userAnswer = {
          BlendOp: blendop,
          Opacity: opacity,
        }

        // 하나라도 일치하면 정답
        if (JSON.stringify(userAnswer) == JSON.stringify(rightAnswer)) {
          isMatched = true;
          break;
        }
      }

      totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult);
      continue;
    }

    // [5-20] 
    else if (type === 'shadow') {
      const shapes = xpath.select(ele, gpdpXmlDoc);
      if (!(shapes?.length)) {
        userAnswer = {
          shadow: null,
          width: null,
          distance: null,
          blur: null,
          angle: null,
        }
      }
      for (const shape of shapes) {
        // 그림자 설정 여부
        const shadowExists = xpath.select1('contains(draw_type/@value, "Shadow")', shape);
        // Shadow 옵션이 있다면
        if (shadowExists) {
          // 두께
          const width = xpath.select1('shadow_width/@value', shape).value;
          // 거리
          const distance = xpath.select1('shadow_distance/@value', shape).value;
          // 분산도
          const blur = xpath.select1('shadow_blur/@value', shape).value;
          // 각도
          const angle = xpath.select1('shadow_angle/@value', shape).value;

          userAnswer = {
            shadow: shadowExists,
            width: width,
            distance: distance,
            blur: blur,
            angle: angle,
          }
        }
        else {
          userAnswer = {
            shadow: shadowExists,
            width: null,
            distance: null,
            blur: null,
            angle: null,
          }
        }
      }
      // console.log("🚀 ~ userAnswer:", userAnswer);
      // console.log("🚀 ~ rightAnswer : ", rightAnswer)
      totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult, {
        partial: true
      })
      continue;
    }

    else if (type == "boolean") {
      const items = xpath.select(ele, gpdpXmlDoc);

      // xpath 결과값을 반환하는 요소가 없을 경우
      if (!items) {
        scoringResult[key] = 0;
        console.log("❌ 찾는 요소 없음");
      }
      else {
        totalScore += point;
        scoringResult[key] = point;
        console.log("✅ 찾는 요소 존재함");
      }
    }

    // 이펙트 효과의 이름과 속성값을 비교
    else if (type == "effects") {
      const items = xpath.select(ele, gpdpXmlDoc);
      let matched = false;

      // 각 Item 요소별 이름과 속성값을 구하고 정답과 비교
      for (const item of items) {
        const name = xpath.select1('Name/@value', item)?.value;
        const attr = xpath.select1(`EffectData/${option?.replace(/"/g, '')}/@value`, item)?.value;

        if (name === rightAnswer[0] && attr === rightAnswer[1]) {
          totalScore += point;
          scoringResult[key] = point;
          matched = true;
          console.log("✅ 정답 일치:", rightAnswer);
          break;
        }
      }

      if (!matched) {
        scoringResult[key] = 0;
        console.log("❌ 정답 없음:", rightAnswer);
      }
    }

    else if (type == "multiValue") {
      if (Array.isArray(rightAnswer)) {
        const result = ele ? xpath.select(ele, gpdpXmlDoc) : [];
        const resultValues = Array.isArray(result) ? result.map(r => (typeof r === 'object' ? r.value : r)) : [result];
        console.log("🚀 ~ getGpdpScore ~ resultValues:", resultValues)

        const groupSize = rightAnswer.length;
        const groupedResult = [];
        for (let i = 0; i < resultValues.length; i += groupSize) {
          groupedResult.push(resultValues.slice(i, i + groupSize));
        }
        console.log("🚀 ~ getGpdpScore ~ groupedResult:", groupedResult)

        // 배열 비교 함수
        function arraysEqual(arr1, arr2) {
          if (arr1.length !== arr2.length) return false;
          return arr1.every((value, index) => value === arr2[index]);
        }

        // groupedResult 내부 배열에서 rightAnswer와 일치하는 배열이 있는지 확인
        const isMatch = groupedResult.some(group => arraysEqual(group, rightAnswer));

        if (isMatch) {
          totalScore += point;
          scoringResult[key] = point;
          console.log("🚀 ~ 정답 포함");
        } else {
          scoringResult[key] = 0;
          console.log("🚀 ~ 오답");
        }
      }
    }

    else if (type == "exact") {
      let result = xpath.select(ele, gpdpXmlDoc);
      if (result.length == 0) {
        scoringResult[key] = 0;
        console.log('ele not found');
        continue;
      }
      if (result[0].value === rightAnswer) {
        totalScore += point;
        scoringResult[key] = point;
      } else {
        scoringResult[key] = 0;
        console.log('ele not matched, ' + result[0].value);
      }
    }


    else if (type == "multi") {
      try {
        const result = xpath.select(ele, gpdpXmlDoc);
        let isSame = true;
        // console.log(`ele: ${ele}, value: ${value}   result: ${result}`);

        if (result.length == 0) {
          console.log('result length 0');
          scoringResult[key] = 0;
          continue;
        }

        result.forEach((v, i) => {
          // value[i] 값이 정수형인 경우에는 float로 변환하여 비교
          // 정수형 v값을 float 형으로 변환하고 소수점 3자리까지 버림
          let temp = v.value;
          let answer = rightAnswer[i];

          if (Number.isFinite(rightAnswer[i]) && !Number.isInteger(rightAnswer[i])) {
            temp = parseFloat(v.value);
            answer = parseFloat(rightAnswer[i]);
            // 소수점 3자리까지 버림
            temp = Math.floor(temp * 1000) / 1000;
          }
          // answer 문자열 중 : 가 포함되어 있다면 각각 분리하고 그 값의 차이를 구함
          if (typeof answer == "string" && answer.indexOf(':') > -1) {
            const [answerStart, answerEnd] = answer.split(':').map(Number);
            const [tempStart, tempEnd] = temp.split(':').map(Number);
            answer = answerEnd - answerStart;
            temp = tempEnd - tempStart;
          }

          console.log(`temp: ${temp}  answer: ${answer}`);
          if (answer !== temp) {
            console.log(`answer !== temp`);
            isSame = false;
          }
        });
        totalScore += isSame ? point : 0;
        scoringResult[key] = isSame ? point : 0;
      } catch (e) {
        console.log('err :', e);
        scoringResult[key] = 0;
      }
    }
    else if (type == "gradient") {
      const items = xpath.select(ele, gpdpXmlDoc);
      const startColorXpath = scoringData[key].startColor;
      const endColorXpath = scoringData[key].endColor;
      let matched = false;

      for (const item of items) {
        const startColor = parseColorToHex(xpath.select1(startColorXpath, item)?.value);
        const endColor = parseColorToHex(xpath.select1(endColorXpath, item)?.value);

        console.log(startColor + ":" + rightAnswer["startColor"], endColor + ":" + rightAnswer["endColor"]);

        if (startColor === rightAnswer["startColor"] && endColor === rightAnswer["endColor"]) {
          totalScore += point;
          scoringResult[key] = point;
          matched = true;
          console.log("✅ 정답 일치:", rightAnswer);
          break;
        }
      }
      if (!matched) {
        scoringResult[key] = 0;
        console.log("❌ 정답 없음:", rightAnswer);
      }
    }
    // 그림자 속성이 있는지 여부 파악해서 그림자 속성 별로 점수 1 점씩 부여
    else if (type == "shadow") {

      const result = xpath.select(ele["shadow"], gpdpXmlDoc);
      let shadowScore = 0;
      if (result.length == 0) {
        scoringResult[key] = 0;
        console.log('shadow not found');
        continue;
      }

      shadowScore += 1;
      const width = xpath.select(ele["width"], gpdpXmlDoc);
      const distance = xpath.select(ele["distance"], gpdpXmlDoc);
      const blur = xpath.select(ele["blur"], gpdpXmlDoc);
      const angle = xpath.select(ele["angle"], gpdpXmlDoc);

      if (width.length !== 0 && width[0].value == rightAnswer["width"]) {
        shadowScore += 1;
        console.log('width matched');
      }
      if (distance.length !== 0 && distance[0].value == rightAnswer["distance"]) {
        shadowScore += 1;
        console.log('distance matched');
      }
      if (blur.length !== 0 && blur[0].value == rightAnswer["blur"]) {
        shadowScore += 1;
        console.log('blur matched');
      }
      if (angle.length !== 0 && angle[0].value == rightAnswer["angle"]) {
        shadowScore += 1;
        console.log('angle matched');
      }
      totalScore += shadowScore;
      scoringResult[key] = shadowScore;
    }
    else {
      const result = xpath.select(ele, gpdpXmlDoc);
      const result2 = null;
      let isCheck = false;

      if (result.length == 0) {
        isCheck = true;
      }
      if (isCheck && ele2) {
        result2 = xpath.select(ele2, gpdpXmlDoc);

        if (result2.length == 0) {
          scoringResult[key] = 0;
          continue;
        }
        result = result2;
        // console.log(`1st isChecked: ${isCheck}, result: ${result}`)
      }
      // value와 result[0].value를 비교하여 같으면 점수 point 부여
      // console.log(`${(value === result[0].value)}, ${result.length > 0 && value === result[0].value} `)
      // console.log(`2nd isChecked: ${isCheck}, result: ${result}`)
      totalScore += result.length > 0 ? point : 0;
      scoringResult[key] = result.length > 0 ? point : 0;
    }
  }
  scoringResult['총점'] = totalScore;
  return scoringResult;
}
