// utils/localStorageUtils.js

/**
 * Безопасное получение данных из localStorage
 * @param {string} key - Ключ в localStorage
 * @param {any} defaultValue - Значение по умолчанию, если данных нет
 * @returns {any} - Парсенные данные или значение по умолчанию
 */
export const loadFromStorage = (key, defaultValue = null) => {
  try {
    const saved = localStorage.getItem(key);

    if (saved === null || saved === undefined) {
      return defaultValue;
    }

    // Проверяем, не является ли сохраненное значение undefined строкой
    if (saved === 'undefined') {
      return defaultValue;
    }

    return JSON.parse(saved);
  } catch (error) {
    console.error(`Error loading "${key}" from localStorage:`, error);

    // Если произошла ошибка парсинга, удаляем поврежденные данные
    if (error instanceof SyntaxError) {
      console.warn(`Removing corrupted data for key "${key}"`);
      localStorage.removeItem(key);
    }

    return defaultValue;
  }
};

/**
 * Безопасное сохранение данных в localStorage
 * @param {string} key - Ключ в localStorage
 * @param {any} value - Данные для сохранения
 * @returns {boolean} - Успех операции
 */
export const saveToStorage = (key, value) => {
  try {
    // Проверяем, не превышен ли лимит localStorage (обычно 5-10MB)
    const serialized = JSON.stringify(value);

    if (serialized.length > 5 * 1024 * 1024) {
      // 5MB лимит
      console.warn(
        `Data for key "${key}" exceeds 5MB, might cause storage issues`,
      );
    }

    localStorage.setItem(key, serialized);
    return true;
  } catch (error) {
    console.error(`Error saving "${key}" to localStorage:`, error);

    // Обработка ошибки переполнения хранилища
    if (error instanceof DOMException && error.name === 'QuotaExceededError') {
      console.error('LocalStorage quota exceeded. Consider cleaning old data.');

      // Можно предложить очистку старых данных
      handleQuotaExceeded();
    }

    return false;
  }
};

/**
 * Удаление данных из localStorage
 * @param {string} key - Ключ для удаления
 * @returns {boolean} - Успех операции
 */
export const removeFromStorage = (key) => {
  try {
    localStorage.removeItem(key);
    return true;
  } catch (error) {
    console.error(`Error removing "${key}" from localStorage:`, error);
    return false;
  }
};

/**
 * Очистка всех данных приложения из localStorage
 * @param {string[]} keysToKeep - Массив ключей, которые нужно сохранить
 */
export const clearAppStorage = (keysToKeep = []) => {
  try {
    const allKeys = Object.keys(localStorage);
    const keysToDelete = allKeys.filter((key) => !keysToKeep.includes(key));

    keysToDelete.forEach((key) => localStorage.removeItem(key));

    console.log(`Cleared ${keysToDelete.length} items from localStorage`);
    return true;
  } catch (error) {
    console.error('Error clearing localStorage:', error);
    return false;
  }
};

/**
 * Получение информации о размере localStorage
 * @returns {object} - Информация о размере
 */
export const getStorageInfo = () => {
  try {
    let totalSize = 0;
    const items = {};

    for (let i = 0; i < localStorage.length; i++) {
      const key = localStorage.key(i);
      const value = localStorage.getItem(key);
      const size = new Blob([value]).size;

      totalSize += size;
      items[key] = {
        size: size,
        sizeInKB: (size / 1024).toFixed(2),
      };
    }

    return {
      totalSize: totalSize,
      totalSizeInKB: (totalSize / 1024).toFixed(2),
      totalSizeInMB: (totalSize / (1024 * 1024)).toFixed(2),
      itemsCount: localStorage.length,
      items,
    };
  } catch (error) {
    console.error('Error getting storage info:', error);
    return null;
  }
};

/**
 * Обработка переполнения localStorage
 */
const handleQuotaExceeded = () => {
  // Получаем информацию о текущем хранилище
  const info = getStorageInfo();

  if (info) {
    console.warn('Storage usage:', info);

    // Если есть старые данные колонок, можно их очистить
    const columnKeys = Object.keys(info.items).filter(
      (key) =>
        key.includes('column') ||
        key.includes('pinning') ||
        key.includes('sizing'),
    );

    if (columnKeys.length > 3) {
      // Оставляем только последние 3 настройки колонок
      const sortedKeys = columnKeys.sort((a, b) => {
        const timeA = localStorage.getItem(`${a}_timestamp`) || 0;
        const timeB = localStorage.getItem(`${b}_timestamp`) || 0;
        return timeA - timeB;
      });

      const keysToRemove = sortedKeys.slice(0, -3);
      keysToRemove.forEach((key) => {
        console.log(`Removing old column data: ${key}`);
        localStorage.removeItem(key);
        localStorage.removeItem(`${key}_timestamp`);
      });
    }
  }
};

/**
 * Сохранение с временной меткой (для отслеживания старых данных)
 * @param {string} key - Ключ
 * @param {any} value - Значение
 */
export const saveToStorageWithTimestamp = (key, value) => {
  const result = saveToStorage(key, value);

  if (result) {
    saveToStorage(`${key}_timestamp`, Date.now());
  }

  return result;
};

/**
 * Миграция данных из старого ключа в новый
 * @param {string} oldKey - Старый ключ
 * @param {string} newKey - Новый ключ
 * @returns {boolean} - Успех миграции
 */
export const migrateStorageKey = (oldKey, newKey) => {
  try {
    const oldData = loadFromStorage(oldKey);

    if (oldData !== null) {
      saveToStorage(newKey, oldData);
      removeFromStorage(oldKey);
      console.log(`Migrated data from "${oldKey}" to "${newKey}"`);
      return true;
    }

    return false;
  } catch (error) {
    console.error(`Error migrating from "${oldKey}" to "${newKey}":`, error);
    return false;
  }
};
