/**
 * 학습 경로 설정
 * 공통 모듈 활용 (ErrorHandler, Utils, ConfigManager)
 */
const LEARNING_CONFIG = {
  // 마커 설정 - 챕터별로 그룹화
  chapters: [
    {
      id: 1,
      code: "CA200C01",
      name: "개인정보보호",
      type: "chapter",
      pathPercent: 0.108,
      pathPercentMo: 0.108, // PC와 동일 순서
      gaugePercent: 0.108,
      gaugePercentMo: 0.108,
      url: "ddILV5cbdQo",
      completed: false, // 하위 lessons가 모두 완료되면 자동으로 true
      lessons: [
        {
          pathPercent: 0.137,
          pathPercentMo: 0.137,
          gaugePercent: 0.137,
          gaugePercentMo: 0.137,
          type: "normal",
          label: "개인정보보호 1",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.159,
          pathPercentMo: 0.159,
          gaugePercent: 0.156,
          gaugePercentMo: 0.156,
          type: "normal",
          label: "개인정보보호 2",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.182,
          pathPercentMo: 0.182,
          gaugePercent: 0.178,
          gaugePercentMo: 0.178,
          type: "normal",
          label: "개인정보보호 3",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.205,
          pathPercentMo: 0.205,
          gaugePercent: 0.202,
          gaugePercentMo: 0.202,
          type: "normal",
          label: "개인정보보호 4",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.228,
          pathPercentMo: 0.228,
          gaugePercent: 0.226,
          gaugePercentMo: 0.226,
          type: "normal",
          label: "개인정보보호 5",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.25,
          pathPercentMo: 0.25,
          gaugePercent: 0.246,
          gaugePercentMo: 0.246,
          type: "normal",
          label: "개인정보보호 6",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.272,
          pathPercentMo: 0.272,
          gaugePercent: 0.268,
          gaugePercentMo: 0.268,
          type: "normal",
          label: "개인정보보호 7",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.298,
          pathPercentMo: 0.298,
          gaugePercent: 0.296,
          gaugePercentMo: 0.296,
          type: "normal",
          label: "개인정보보호 8",
          url: "ddILV5cbdQo",
          completed: false,
        },
      ],
    },
    {
      id: 2,
      code: "CA200C02",
      name: "직장내 괴롭힘 예방",
      type: "chapter",
      pathPercent: 0.325,
      pathPercentMo: 0.325,
      gaugePercent: 0.325,
      gaugePercentMo: 0.325,
      url: "ddILV5cbdQo",
      completed: false,
      lessons: [
        {
          pathPercent: 0.367,
          pathPercentMo: 0.367,
          gaugePercent: 0.358,
          gaugePercentMo: 0.358,
          type: "normal",
          label: "직장내 괴롭힘 예방 1",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.41,
          pathPercentMo: 0.41,
          gaugePercent: 0.40,
          gaugePercentMo: 0.40,
          type: "normal",
          label: "직장내 괴롭힘 예방 2",
          url: "ddILV5cbdQo",
          completed: false,
        },
      ],
    },
    {
      id: 3,
      code: "CA200C03",
      name: "성희롱 예방 교육",
      type: "chapter",
      pathPercent: 0.442,
      pathPercentMo: 0.442,
      gaugePercent: 0.442,
      gaugePercentMo: 0.442,
      url: "ddILV5cbdQo",
      completed: false,
      lessons: [
        {
          pathPercent: 0.486,
          pathPercentMo: 0.486,
          gaugePercent: 0.476,
          gaugePercentMo: 0.476,
          type: "normal",
          label: "성희롱 예방 교육 1",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.531,
          pathPercentMo: 0.531,
          gaugePercent: 0.526,
          gaugePercentMo: 0.526,
          type: "normal",
          label: "성희롱 예방 교육 2",
          url: "ddILV5cbdQo",
          completed: false,
        },
      ],
    },
    {
      id: 4,
      code: "CA200C04",
      name: "산업안전 보건",
      type: "chapter",
      pathPercent: 0.555,
      pathPercentMo: 0.555,
      gaugePercent: 0.555,
      gaugePercentMo: 0.555,
      url: "ddILV5cbdQo",
      completed: false,
      lessons: [
        {
          pathPercent: 0.585,
          pathPercentMo: 0.585,
          gaugePercent: 0.582,
          gaugePercentMo: 0.582,
          type: "normal",
          label: "산업안전 보건 1",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.635,
          pathPercentMo: 0.635,
          gaugePercent: 0.632,
          gaugePercentMo: 0.632,
          type: "normal",
          label: "산업안전 보건 2",
          url: "ddILV5cbdQo",
          completed: false,
        },
      ],
    },
    {
      id: 5,
      code: "CA200C05",
      name: "장애인 인식 개선",
      type: "chapter",
      pathPercent: 0.67,
      pathPercentMo: 0.67,
      gaugePercent: 0.67,
      gaugePercentMo: 0.67,
      url: "ddILV5cbdQo",
      completed: false,
      lessons: [
        {
          pathPercent: 0.69,
          pathPercentMo: 0.69,
          gaugePercent: 0.686,
          gaugePercentMo: 0.686,
          type: "normal",
          label: "장애인 인식 개선 1",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.718,
          pathPercentMo: 0.718,
          gaugePercent: 0.71,
          gaugePercentMo: 0.71,
          type: "normal",
          label: "장애인 인식 개선 2",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.736,
          pathPercentMo: 0.736,
          gaugePercent: 0.728,
          gaugePercentMo: 0.728,
          type: "normal",
          label: "장애인 인식 개선 3",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.785,
          pathPercentMo: 0.785,
          gaugePercent: 0.778,
          gaugePercentMo: 0.778,
          type: "normal",
          label: "장애인 인식 개선 4",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.82,
          pathPercentMo: 0.82,
          gaugePercent: 0.812,
          gaugePercentMo: 0.812,
          type: "normal",
          label: "장애인 인식 개선 5",
          url: "ddILV5cbdQo",
          completed: false,
        },
        {
          pathPercent: 0.86,
          pathPercentMo: 0.86,
          gaugePercent: 0.85,
          gaugePercentMo: 0.85,
          type: "normal",
          label: "장애인 인식 개선 6",
          url: "ddILV5cbdQo",
          completed: false,
        },
      ],
    },
  ],

  // 평균 학습량 설정 (전체 학습 항목 대비 %)
  averageProgress: {
    threshold: 60, // 평균 학습량: 전체의 60% 
  }, 

  // 마커 이미지 경로
  markerImages: {
    normal: {
      base: "/img/learning/mark_base.png",
      current: "/img/learning/mark_current.png",
      completed: "/img/learning/mark_completed.png",
    },
    chapter: {
      base: "/img/learning/mark_chapter_base.png",
      current: "/img/learning/mark_chapter_current.png",
      completed: "/img/learning/mark_chapter_completed.png",
    },
  },

  // 상태 이미지 경로
  stateImages: {
    below: "/img/learning/img_state_01.svg", // 평균 이하
    average: "/img/learning/img_state_02.svg", // 평균
    above: "/img/learning/img_state_03.svg", // 평균 이상
  },

  // 모달 경로
  modalPath: "./_modal/video-learning.php",

  // 비활성 마커 클릭 설정
  settings: {
    allowDisabledClick: true, // true: 비활성 마커도 클릭 가능, false: 비활성 마커 클릭 불가
    disabledClickMessage: "이전 학습을 먼저 완료해주세요.", // 비활성 마커 클릭 시 메시지
    showDisabledAlert: false, // true: 알림 표시, false: 콘솔 로그만
    showStateIndicator: {
      pc: true, // PC에서 상태 인디케이터 표시
      mo: false, // 모바일에서도 상태 인디케이터 표시 (PC와 동일)
    },
  },

  /**
   * 챕터의 완료 상태 자동 업데이트
   * 하위 lessons가 모두 완료되면 챕터도 completed = true로 변경
   */
  updateChapterCompletionStatus() {
    try {
      if (!this.chapters || !Array.isArray(this.chapters)) {
        this._handleError(new Error('chapters가 배열이 아닙니다.'), 'updateChapterCompletionStatus');
        return;
      }

      this.chapters.forEach((chapter, index) => {
        try {
          if (!chapter || !chapter.lessons || !Array.isArray(chapter.lessons)) {
            console.warn(`[LEARNING_CONFIG] 챕터 ${index}의 lessons가 유효하지 않습니다.`);
            return;
          }

          const allLessonsCompleted = chapter.lessons.every(
            (lesson) => lesson && lesson.completed === true
          );
          chapter.completed = allLessonsCompleted;
        } catch (error) {
          this._handleError(error, 'updateChapterCompletionStatus.chapter', { chapterIndex: index });
        }
      });
    } catch (error) {
      this._handleError(error, 'updateChapterCompletionStatus');
    }
  },

  /**
   * 전체 마커 배열 반환 (챕터 + lessons flat)
   * @returns {Array}
   */
  getAllMarkers() {
    try {
      // 챕터 완료 상태 업데이트
      this.updateChapterCompletionStatus();

      if (!this.chapters || !Array.isArray(this.chapters)) {
        this._handleError(new Error('chapters가 배열이 아닙니다.'), 'getAllMarkers');
        return [];
      }

      const markers = [];
      this.chapters.forEach((chapter, chapterIndex) => {
        try {
          if (!chapter) {
            console.warn(`[LEARNING_CONFIG] 챕터 ${chapterIndex}가 null입니다.`);
            return;
          }

          // 챕터 자체를 마커로 추가 (시작점 표시용, 클릭 불가)
          markers.push({
            pathPercent: chapter.pathPercent || 0,
            pathPercentMo: chapter.pathPercentMo,
            gaugePercent: chapter.gaugePercent !== undefined ? chapter.gaugePercent : (chapter.pathPercent || 0),
            gaugePercentMo: chapter.gaugePercentMo,
            type: chapter.type || 'chapter',
            label: chapter.name || `챕터 ${chapterIndex + 1}`,
            url: chapter.url || '',
            completed: chapter.completed === true,
            chapterId: chapter.id || chapterIndex + 1,
            isChapterMarker: true,
            isLearningContent: false, // 강의 아님
            isClickable: false, // 클릭 불가
          });

          // 하위 lessons 추가 (실제 강의)
          if (chapter.lessons && Array.isArray(chapter.lessons)) {
            chapter.lessons.forEach((lesson, lessonIndex) => {
              try {
                if (!lesson) {
                  console.warn(`[LEARNING_CONFIG] 챕터 ${chapterIndex}의 레슨 ${lessonIndex}가 null입니다.`);
                  return;
                }

                markers.push({
                  pathPercent: lesson.pathPercent || 0,
                  pathPercentMo: lesson.pathPercentMo,
                  gaugePercent: lesson.gaugePercent !== undefined ? lesson.gaugePercent : (lesson.pathPercent || 0),
                  gaugePercentMo: lesson.gaugePercentMo,
                  type: lesson.type || 'normal',
                  label: lesson.label || `레슨 ${lessonIndex + 1}`,
                  url: lesson.url || '',
                  content_id: lesson.content_id || '',
                  watch_tm: Math.max(0, Number.parseInt(lesson.watch_tm ?? 0, 10) || 0),
                  content_tm: Math.max(0, Number.parseInt(lesson.content_tm ?? 0, 10) || 0),
                  all_tm: Math.max(0, Number.parseInt(lesson.all_tm ?? 0, 10) || 0),
                  completed: lesson.completed === true,
                  chapterId: chapter.id || chapterIndex + 1,
                  isChapterMarker: false,
                  isLearningContent: true, // 실제 강의
                  isClickable: true, // 클릭 가능
                });
              } catch (error) {
                this._handleError(error, 'getAllMarkers.lesson', { chapterIndex, lessonIndex });
              }
            });
          }
        } catch (error) {
          this._handleError(error, 'getAllMarkers.chapter', { chapterIndex });
        }
      });

      return markers;
    } catch (error) {
      this._handleError(error, 'getAllMarkers');
      return [];
    }
  },

  /**
   * 특정 인덱스의 챕터 정보 반환
   * @param {number} globalIndex - 전체 마커 기준 인덱스
   * @returns {Object|null} { chapterIndex, chapterData, lessonIndex, lessonData, isChapterMarker }
   */
  getChapterByGlobalIndex(globalIndex) {
    try {
      if (typeof globalIndex !== 'number' || globalIndex < 0) {
        this._handleError(new Error(`유효하지 않은 globalIndex: ${globalIndex}`), 'getChapterByGlobalIndex');
        return null;
      }

      const allMarkers = this.getAllMarkers();
      
      if (!Array.isArray(allMarkers) || globalIndex >= allMarkers.length) {
        console.warn(`[LEARNING_CONFIG] globalIndex ${globalIndex}가 범위를 벗어났습니다. (총 ${allMarkers.length}개)`);
        return null;
      }

      const marker = allMarkers[globalIndex];
      if (!marker) {
        console.warn(`[LEARNING_CONFIG] globalIndex ${globalIndex}의 마커를 찾을 수 없습니다.`);
        return null;
      }

      const chapterIndex = this.chapters.findIndex(
        (ch) => ch && ch.id === marker.chapterId
      );

      if (chapterIndex === -1) {
        console.warn(`[LEARNING_CONFIG] chapterId ${marker.chapterId}에 해당하는 챕터를 찾을 수 없습니다.`);
        return null;
      }

      const chapter = this.chapters[chapterIndex];
      if (!chapter) {
        console.warn(`[LEARNING_CONFIG] 챕터 인덱스 ${chapterIndex}의 데이터가 없습니다.`);
        return null;
      }

      if (marker.isChapterMarker) {
        // 챕터 마커인 경우
        return {
          chapterIndex,
          chapterData: chapter,
          lessonIndex: -1, // 챕터 자체이므로 -1
          lessonData: marker,
          isChapterMarker: true,
        };
      } else {
        // 일반 레슨인 경우
        if (!chapter.lessons || !Array.isArray(chapter.lessons)) {
          console.warn(`[LEARNING_CONFIG] 챕터 ${chapterIndex}의 lessons가 유효하지 않습니다.`);
          return null;
        }

        const lessonIndex = chapter.lessons.findIndex(
          (lesson) => lesson && lesson.pathPercent === marker.pathPercent
        );

        if (lessonIndex === -1) {
          console.warn(`[LEARNING_CONFIG] pathPercent ${marker.pathPercent}에 해당하는 레슨을 찾을 수 없습니다.`);
          return null;
        }

        return {
          chapterIndex,
          chapterData: chapter,
          lessonIndex,
          lessonData: marker,
          isChapterMarker: false,
        };
      }
    } catch (error) {
      this._handleError(error, 'getChapterByGlobalIndex', { globalIndex });
      return null;
    }
  },

  /**
   * 로컬 인덱스를 글로벌 인덱스로 변환
   * @param {number} chapterIndex - 챕터 인덱스
   * @param {number} lessonIndex - 챕터 내 학습 인덱스 (-1이면 챕터 자체)
   * @returns {number|null}
   */
  toGlobalIndex(chapterIndex, lessonIndex) {
    try {
      if (typeof chapterIndex !== 'number' || chapterIndex < 0) {
        this._handleError(new Error(`유효하지 않은 chapterIndex: ${chapterIndex}`), 'toGlobalIndex');
        return null;
      }

      if (typeof lessonIndex !== 'number') {
        this._handleError(new Error(`유효하지 않은 lessonIndex: ${lessonIndex}`), 'toGlobalIndex');
        return null;
      }

      if (!this.chapters || !Array.isArray(this.chapters)) {
        this._handleError(new Error('chapters가 배열이 아닙니다.'), 'toGlobalIndex');
        return null;
      }

      if (chapterIndex >= this.chapters.length) {
        console.warn(`[LEARNING_CONFIG] chapterIndex ${chapterIndex}가 범위를 벗어났습니다. (총 ${this.chapters.length}개)`);
        return null;
      }

      let globalIndex = 0;

      for (let i = 0; i < chapterIndex; i++) {
        const chapter = this.chapters[i];
        if (!chapter) {
          console.warn(`[LEARNING_CONFIG] 챕터 인덱스 ${i}가 null입니다.`);
          continue;
        }

        globalIndex += 1; // 챕터 마커
        
        if (chapter.lessons && Array.isArray(chapter.lessons)) {
          globalIndex += chapter.lessons.length; // 하위 lessons
        }
      }

      if (lessonIndex === -1) {
        // 챕터 마커 자체
        return globalIndex;
      } else {
        // 하위 lesson
        const chapter = this.chapters[chapterIndex];
        if (!chapter || !chapter.lessons || !Array.isArray(chapter.lessons)) {
          console.warn(`[LEARNING_CONFIG] 챕터 ${chapterIndex}의 lessons가 유효하지 않습니다.`);
          return null;
        }

        if (lessonIndex >= chapter.lessons.length) {
          console.warn(`[LEARNING_CONFIG] lessonIndex ${lessonIndex}가 범위를 벗어났습니다. (총 ${chapter.lessons.length}개)`);
          return null;
        }

        return globalIndex + 1 + lessonIndex;
      }
    } catch (error) {
      this._handleError(error, 'toGlobalIndex', { chapterIndex, lessonIndex });
      return null;
    }
  },

  /**
   * 에러 처리 헬퍼
   * @private
   */
  _handleError(error, context, additionalInfo = {}) {
    if (typeof ErrorHandler !== 'undefined' && ErrorHandler) {
      ErrorHandler.handle(error, {
        context: `LEARNING_CONFIG.${context}`,
        component: 'LEARNING_CONFIG',
        ...additionalInfo
      }, false);
    } else {
      console.error(`[LEARNING_CONFIG] ${context}:`, error, additionalInfo);
    }
  },

  /**
   * 설정 유효성 검증
   * @returns {boolean}
   */
  validate() {
    try {
      if (!this.chapters || !Array.isArray(this.chapters)) {
        this._handleError(new Error('chapters가 배열이 아닙니다.'), 'validate');
        return false;
      }

      let isValid = true;
      this.chapters.forEach((chapter, index) => {
        if (!chapter) {
          console.warn(`[LEARNING_CONFIG] 챕터 ${index}가 null입니다.`);
          isValid = false;
          return;
        }

        if (!chapter.id) {
          console.warn(`[LEARNING_CONFIG] 챕터 ${index}에 id가 없습니다.`);
          isValid = false;
        }

        if (!chapter.name) {
          console.warn(`[LEARNING_CONFIG] 챕터 ${index}에 name이 없습니다.`);
          isValid = false;
        }

        if (!chapter.lessons || !Array.isArray(chapter.lessons)) {
          console.warn(`[LEARNING_CONFIG] 챕터 ${index}의 lessons가 유효하지 않습니다.`);
          isValid = false;
        } else {
          chapter.lessons.forEach((lesson, lessonIndex) => {
            if (!lesson) {
              console.warn(`[LEARNING_CONFIG] 챕터 ${index}의 레슨 ${lessonIndex}가 null입니다.`);
              isValid = false;
            } else {
              if (!lesson.label) {
                console.warn(`[LEARNING_CONFIG] 챕터 ${index}의 레슨 ${lessonIndex}에 label이 없습니다.`);
                isValid = false;
              }
              if (typeof lesson.pathPercent !== 'number') {
                console.warn(`[LEARNING_CONFIG] 챕터 ${index}의 레슨 ${lessonIndex}에 pathPercent가 없거나 숫자가 아닙니다.`);
                isValid = false;
              }
            }
          });
        }
      });

      return isValid;
    } catch (error) {
      this._handleError(error, 'validate');
      return false;
    }
  },
};

/**
 * HTML에서 내려준 learningChapterData를 코드 기준으로 반영
 * - category_group(code) 기준 챕터 매핑
 * - lesson title/url/completed 동기화
 */
if (typeof window !== "undefined" && Array.isArray(window.learningChapterData)) {
  try {
    const serverChapters = window.learningChapterData;
    const chapterByCode = new Map(
      serverChapters
        .filter((ch) => ch && typeof ch === 'object' && ch.code)
        .map((ch) => [String(ch.code), ch])
    );

    LEARNING_CONFIG.chapters.forEach((chapter, chapterIndex) => {
      const serverChapter = chapterByCode.get(String(chapter.code || ''))
        || serverChapters.find((ch) => Number(ch?.id) === Number(chapter.id));

      if (!serverChapter) {
        return;
      }

      if (serverChapter.name) {
        chapter.name = String(serverChapter.name);
      }

      const serverLessons = Array.isArray(serverChapter.lessons) ? serverChapter.lessons : [];
      if (serverLessons.length === 0) {
        chapter.completed = false;
        chapter.lessons.forEach((lesson) => {
          lesson.completed = false;
        });
        return;
      }

      const applyCount = Math.min(chapter.lessons.length, serverLessons.length);
      for (let i = 0; i < applyCount; i++) {
        const localLesson = chapter.lessons[i];
        const serverLesson = serverLessons[i] || {};

        if (serverLesson.title) {
          localLesson.label = String(serverLesson.title);
        }
        if (serverLesson.url) {
          localLesson.url = String(serverLesson.url);
        }
        if (serverLesson.content_id) {
          localLesson.content_id = String(serverLesson.content_id);
        }
        if (serverLesson.watch_tm !== undefined) {
          localLesson.watch_tm = Math.max(0, Number.parseInt(serverLesson.watch_tm, 10) || 0);
        }
        if (serverLesson.content_tm !== undefined) {
          localLesson.content_tm = Math.max(0, Number.parseInt(serverLesson.content_tm, 10) || 0);
        }
        if (serverLesson.all_tm !== undefined) {
          localLesson.all_tm = Math.max(0, Number.parseInt(serverLesson.all_tm, 10) || 0);
        }
        if (serverLesson.completed !== undefined) {
          localLesson.completed = serverLesson.completed === true;
        }
      }

      for (let i = applyCount; i < chapter.lessons.length; i++) {
        chapter.lessons[i].completed = false;
      }

      chapter.completed = chapter.lessons.length > 0
        && chapter.lessons.every((lesson) => lesson && lesson.completed === true);

      if (serverLessons.length !== chapter.lessons.length) {
        console.warn(
          `[LEARNING_CONFIG] 챕터 ${chapterIndex + 1}(${chapter.code}) 차시 수 불일치: local=${chapter.lessons.length}, server=${serverLessons.length}`
        );
      }
    });
  } catch (error) {
    if (typeof ErrorHandler !== 'undefined' && ErrorHandler) {
      ErrorHandler.handle(error, {
        context: 'LEARNING_CONFIG.applyLearningChapterData'
      }, false);
    } else {
      console.error('[LEARNING_CONFIG] learningChapterData 적용 에러:', error);
    }
  }
}

/**
 * HTML에서 설정된 learningConfigData를 LEARNING_CONFIG에 적용
 * window.learningConfigData가 있으면 completed 상태를 업데이트
 */
if (typeof window !== "undefined" && window.learningConfigData) {
  try {
    const configData = window.learningConfigData;

    if (!configData || typeof configData !== 'object') {
      console.warn('[LEARNING_CONFIG] learningConfigData가 유효하지 않습니다.');
    } else {
      LEARNING_CONFIG.chapters.forEach((chapter, chapterIndex) => {
        try {
          if (!chapter || !chapter.id) {
            console.warn(`[LEARNING_CONFIG] 챕터 ${chapterIndex}가 유효하지 않습니다.`);
            return;
          }

          const chapterData = configData[chapter.code] ?? configData[chapter.id];

          if (chapterData) {
            // 챕터 완료 상태 업데이트
            if (chapterData.completed !== undefined) {
              chapter.completed = chapterData.completed === true;
            }

            // 레슨 완료 상태 업데이트
            if (chapterData.lessons && Array.isArray(chapterData.lessons)) {
              if (!chapter.lessons || !Array.isArray(chapter.lessons)) {
                console.warn(`[LEARNING_CONFIG] 챕터 ${chapterIndex}의 lessons가 유효하지 않습니다.`);
                return;
              }

              chapterData.lessons.forEach((lessonData, index) => {
                try {
                  if (chapter.lessons[index] && lessonData && lessonData.completed !== undefined) {
                    chapter.lessons[index].completed = lessonData.completed === true;
                  }
                } catch (error) {
                  console.error(`[LEARNING_CONFIG] 레슨 ${index} 업데이트 에러:`, error);
                }
              });
            }
          }
        } catch (error) {
          if (typeof ErrorHandler !== 'undefined' && ErrorHandler) {
            ErrorHandler.handle(error, {
              context: 'LEARNING_CONFIG.loadFromHTML.chapter',
              chapterIndex
            }, false);
          } else {
            console.error(`[LEARNING_CONFIG] 챕터 ${chapterIndex} 업데이트 에러:`, error);
          }
        }
      });

      console.log(
        "[LEARNING_CONFIG] learningConfigData 적용 완료:",
        LEARNING_CONFIG
      );

      // 설정 유효성 검증
      if (LEARNING_CONFIG.validate) {
        const isValid = LEARNING_CONFIG.validate();
        if (!isValid) {
          console.warn('[LEARNING_CONFIG] 설정 유효성 검증 실패');
        }
      }
    }
  } catch (error) {
    if (typeof ErrorHandler !== 'undefined' && ErrorHandler) {
      ErrorHandler.handle(error, {
        context: 'LEARNING_CONFIG.loadFromHTML'
      }, false);
    } else {
      console.error('[LEARNING_CONFIG] learningConfigData 적용 에러:', error);
    }
  }
}