// 기능정의서 뱃지 로컬 파일 저장/로드 유틸리티
// localStorage 대신 JSON 파일로 관리하여 브라우저 독립적으로 동작

const STORAGE_FILE_PATH = './public/data/featureBadges.json';
const BACKUP_FOLDER_PATH = './public/data/backups/';

/**
 * 로컬 JSON 파일에서 기능정의서 뱃지 데이터 로드
 * @returns {Promise<Object>} 뱃지 데이터 객체
 */
export const loadFeatureBadges = async () => {
  try {
    const response = await fetch('/data/featureBadges.json');
    if (!response.ok) {
      console.warn('기능정의서 데이터 파일이 없습니다. 빈 객체로 초기화합니다.');
      return { badges: {}, metadata: { version: '1.0.0', lastModified: null } };
    }
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('기능정의서 데이터 로드 실패:', error);
    return { badges: {}, metadata: { version: '1.0.0', lastModified: null } };
  }
};

/**
 * 로컬 JSON 파일에 기능정의서 뱃지 데이터 저장
 * @param {Object} badgeData - 저장할 뱃지 데이터
 * @param {Object} metadata - 메타데이터 (버전, 수정일시 등)
 * @returns {Promise<boolean>} 저장 성공 여부
 */
export const saveFeatureBadges = async (badgeData, metadata = {}) => {
  try {
    const dataToSave = {
      badges: badgeData,
      metadata: {
        version: metadata.version || '1.0.0',
        lastModified: new Date().toISOString(),
        author: metadata.author || 'system',
        description: metadata.description || ''
      }
    };

    // JSON 파일 다운로드 방식으로 저장
    const blob = new Blob([JSON.stringify(dataToSave, null, 2)], { type: 'application/json' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = 'featureBadges.json';
    a.click();
    URL.revokeObjectURL(url);

    console.log('✅ 기능정의서 데이터가 다운로드되었습니다. public/data/ 폴더에 저장하세요.');
    return true;
  } catch (error) {
    console.error('기능정의서 데이터 저장 실패:', error);
    return false;
  }
};

/**
 * 어드민 전용 뱃지 필터링 (파란색/연두색 뱃지 제외)
 * @param {Object} badgeData - 전체 뱃지 데이터
 * @returns {Object} 일반 사용자용 뱃지 데이터
 */
export const filterAdminBadges = (badgeData) => {
  const filteredBadges = {};

  Object.keys(badgeData).forEach(screenKey => {
    const screenBadges = badgeData[screenKey];
    if (Array.isArray(screenBadges)) {
      // 파란색(blue), 연두색(green) 뱃지 제외
      filteredBadges[screenKey] = screenBadges.filter(
        badge => badge.color !== 'blue' && badge.color !== 'green'
      );
    }
  });

  return filteredBadges;
};

/**
 * 백업 파일 생성
 * @param {Object} badgeData - 백업할 뱃지 데이터
 * @param {string} backupType - 백업 타입 ('auto' | 'manual')
 * @returns {Promise<boolean>} 백업 성공 여부
 */
export const createBackup = async (badgeData, backupType = 'manual') => {
  try {
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const backupData = {
      badges: badgeData,
      metadata: {
        backupType,
        backupDate: new Date().toISOString(),
        version: '1.0.0'
      }
    };

    const blob = new Blob([JSON.stringify(backupData, null, 2)], { type: 'application/json' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = `featureBadges_backup_${backupType}_${timestamp}.json`;
    a.click();
    URL.revokeObjectURL(url);

    console.log(`✅ ${backupType} 백업이 생성되었습니다.`);
    return true;
  } catch (error) {
    console.error('백업 생성 실패:', error);
    return false;
  }
};

/**
 * JSON 파일에서 데이터 가져오기 (import)
 * @param {File} file - 업로드된 JSON 파일
 * @returns {Promise<Object>} 파싱된 뱃지 데이터
 */
export const importFromFile = async (file) => {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = (e) => {
      try {
        const data = JSON.parse(e.target.result);
        resolve(data);
      } catch (error) {
        reject(new Error('JSON 파일 파싱 실패'));
      }
    };
    reader.onerror = () => reject(new Error('파일 읽기 실패'));
    reader.readAsText(file);
  });
};

/**
 * 전체/메뉴별/화면별 데이터 추출
 * @param {Object} badgeData - 전체 뱃지 데이터
 * @param {string} filterType - 필터 타입 ('all' | 'menu' | 'screen')
 * @param {string} filterValue - 필터 값 (메뉴명 또는 화면 키)
 * @returns {Object} 필터링된 뱃지 데이터
 */
export const extractBadgesByFilter = (badgeData, filterType = 'all', filterValue = null) => {
  if (filterType === 'all') {
    return badgeData;
  }

  const filteredBadges = {};

  if (filterType === 'screen' && filterValue) {
    // 특정 화면만 추출
    if (badgeData[filterValue]) {
      filteredBadges[filterValue] = badgeData[filterValue];
    }
    return filteredBadges;
  }

  if (filterType === 'menu' && filterValue) {
    // 특정 메뉴의 모든 화면 추출
    Object.keys(badgeData).forEach(screenKey => {
      // screenKey 형식: "quote_list", "order_form" 등
      // filterValue와 매칭 (예: "견적관리" 메뉴)
      if (screenKey.startsWith(filterValue.toLowerCase())) {
        filteredBadges[screenKey] = badgeData[screenKey];
      }
    });
    return filteredBadges;
  }

  return badgeData;
};

/**
 * 뱃지 데이터 통계 생성
 * @param {Object} badgeData - 뱃지 데이터
 * @returns {Object} 통계 정보
 */
export const generateBadgeStatistics = (badgeData) => {
  let totalBadges = 0;
  let screenCount = 0;
  const colorStats = {};

  Object.keys(badgeData).forEach(screenKey => {
    const badges = badgeData[screenKey];
    if (Array.isArray(badges) && badges.length > 0) {
      screenCount++;
      totalBadges += badges.length;

      badges.forEach(badge => {
        const color = badge.color || 'red';
        colorStats[color] = (colorStats[color] || 0) + 1;
      });
    }
  });

  return {
    totalBadges,
    screenCount,
    colorStats,
    averageBadgesPerScreen: screenCount > 0 ? (totalBadges / screenCount).toFixed(1) : 0
  };
};
