import deviceFingerprint from '@/utils/deviceFingerprint';

/**
 * Сервис для работы с блокировкой устройств на клиентской стороне
 */
class DeviceSecurityService {
  constructor() {
    this.currentFingerprint = null;
    this.isBlocked = false;
    this.lastCheck = null;
    this.checkInterval = 5 * 60 * 1000; // 5 минут
    this.blockCheckCallbacks = [];
  }

  /**
   * Инициализация сервиса безопасности устройств
   */
  async initialize() {
    try {
      console.log('[DeviceSecurity] Инициализация системы безопасности устройств');
      
      // Генерируем fingerprint устройства
      this.currentFingerprint = await deviceFingerprint.getDeviceFingerprint();
      deviceFingerprint.saveFingerprint(this.currentFingerprint);
      
      console.log('[DeviceSecurity] Device fingerprint создан:', this.currentFingerprint.substring(0, 16) + '...');
      
      // Проверяем, изменился ли fingerprint с последнего визита
      const hasChanged = await deviceFingerprint.hasChanged();
      if (hasChanged) {
        console.log('[DeviceSecurity] Device fingerprint изменился с последнего визита');
        this.handleFingerprintChange();
      }
      
      // Устанавливаем периодическую проверку
      this.startPeriodicCheck();
      
      return true;
    } catch (error) {
      console.error('[DeviceSecurity] Ошибка инициализации:', error);
      return false;
    }
  }

  /**
   * Получает текущий fingerprint устройства
   */
  getCurrentFingerprint() {
    return this.currentFingerprint;
  }

  /**
   * Проверяет, заблокировано ли текущее устройство
   */
  async checkDeviceBlock() {
    try {
      if (!this.currentFingerprint) {
        await this.initialize();
      }

      // Отправляем запрос на сервер для проверки блокировки
      const response = await fetch('/api/security/check-device', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'X-Device-Fingerprint': this.currentFingerprint
        },
        body: JSON.stringify({
          fingerprint: this.currentFingerprint,
          deviceInfo: await this.getDeviceInfo()
        })
      });

      const result = await response.json();
      
      if (response.status === 403 && result.blocked) {
        this.isBlocked = true;
        this.handleDeviceBlock(result);
        return { blocked: true, reason: result.reason };
      }

      this.isBlocked = false;
      this.lastCheck = Date.now();
      return { blocked: false };
      
    } catch (error) {
      console.error('[DeviceSecurity] Ошибка при проверке блокировки устройства:', error);
      return { blocked: false, error: true };
    }
  }

  /**
   * Получает дополнительную информацию об устройстве
   */
  async getDeviceInfo() {
    try {
      const basicFingerprint = await deviceFingerprint.getBasicFingerprint();
      
      return {
        userAgent: navigator.userAgent,
        screenResolution: `${screen.width}x${screen.height}`,
        platform: navigator.platform,
        language: navigator.language,
        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
        timestamp: Date.now(),
        visitCount: deviceFingerprint.getVisitCount(),
        // Дополнительные метрики для анализа
        connection: basicFingerprint.connection,
        webgl: basicFingerprint.webgl?.renderer || 'unknown',
        canvas: basicFingerprint.canvas ? 'available' : 'unavailable'
      };
    } catch (error) {
      console.error('[DeviceSecurity] Ошибка при получении информации об устройстве:', error);
      return {};
    }
  }

  /**
   * Обрабатывает блокировку устройства
   */
  handleDeviceBlock(blockInfo) {
    console.log('[DeviceSecurity] Устройство заблокировано:', blockInfo);
    
    // Сохраняем информацию о блокировке
    localStorage.setItem('deviceBlocked', JSON.stringify({
      blocked: true,
      reason: blockInfo.reason,
      blockedAt: blockInfo.blockedAt,
      fingerprint: this.currentFingerprint,
      timestamp: Date.now()
    }));

    // Очищаем чувствительные данные
    this.clearSensitiveData();

    // Уведомляем подписчиков о блокировке
    this.notifyBlockCallbacks(blockInfo);

    // Перенаправляем на страницу блокировки
    this.redirectToBlockedPage(blockInfo);
  }

  /**
   * Обрабатывает изменение fingerprint устройства
   */
  handleFingerprintChange() {
    console.log('[DeviceSecurity] Device fingerprint изменился - возможна попытка обхода');
    
    // Логируем подозрительную активность
    const suspiciousActivity = {
      type: 'fingerprint_change',
      oldFingerprint: deviceFingerprint.loadFingerprint()?.fingerprint,
      newFingerprint: this.currentFingerprint,
      timestamp: Date.now(),
      userAgent: navigator.userAgent
    };
    
    // Сохраняем в localStorage для отправки на сервер
    const existing = JSON.parse(localStorage.getItem('suspiciousActivity') || '[]');
    existing.push(suspiciousActivity);
    localStorage.setItem('suspiciousActivity', JSON.stringify(existing.slice(-10))); // Последние 10 событий
  }

  /**
   * Очищает чувствительные данные при блокировке
   */
  clearSensitiveData() {
    try {
      // Очищаем пользовательские данные
      localStorage.removeItem('userToken');
      localStorage.removeItem('userSettings');
      localStorage.removeItem('userPreferences');
      
      // Очищаем кеши
      if ('caches' in window) {
        caches.keys().then(names => {
          names.forEach(name => {
            if (name.includes('user-data') || name.includes('api-cache')) {
              caches.delete(name);
            }
          });
        });
      }
      
      // Очищаем IndexedDB (если используется)
      if ('indexedDB' in window) {
        // Здесь можно добавить очистку IndexedDB
      }
      
      console.log('[DeviceSecurity] Чувствительные данные очищены');
    } catch (error) {
      console.error('[DeviceSecurity] Ошибка при очистке данных:', error);
    }
  }

  /**
   * Добавляет fingerprint в заголовки запросов
   */
  injectFingerprintHeaders(headers = {}) {
    if (this.currentFingerprint) {
      headers['X-Device-Fingerprint'] = this.currentFingerprint;
      headers['X-Screen-Resolution'] = `${screen.width}x${screen.height}`;
      headers['X-Platform'] = navigator.platform;
      headers['X-Language'] = navigator.language;
      headers['X-Timezone'] = Intl.DateTimeFormat().resolvedOptions().timeZone;
    }
    return headers;
  }

  /**
   * Запускает периодическую проверку блокировки
   */
  startPeriodicCheck() {
    setInterval(async () => {
      if (!this.isBlocked && this.currentFingerprint) {
        await this.checkDeviceBlock();
      }
    }, this.checkInterval);
  }

  /**
   * Добавляет callback для уведомления о блокировке
   */
  onDeviceBlock(callback) {
    this.blockCheckCallbacks.push(callback);
  }

  /**
   * Уведомляет подписчиков о блокировке
   */
  notifyBlockCallbacks(blockInfo) {
    this.blockCheckCallbacks.forEach(callback => {
      try {
        callback(blockInfo);
      } catch (error) {
        console.error('[DeviceSecurity] Ошибка в callback блокировки:', error);
      }
    });
  }

  /**
   * Перенаправляет на страницу блокировки
   */
  redirectToBlockedPage(blockInfo) {
    const params = new URLSearchParams({
      blocked: 'true',
      reason: blockInfo.reason || 'Устройство заблокировано',
      type: 'device'
    });
    
    // Используем window.location для принудительного перенаправления
    window.location.href = `/login?${params.toString()}`;
  }

  /**
   * Проверяет, заблокировано ли устройство (синхронная проверка)
   */
  isDeviceBlocked() {
    const stored = localStorage.getItem('deviceBlocked');
    if (stored) {
      try {
        const blockInfo = JSON.parse(stored);
        return blockInfo.blocked === true;
      } catch (e) {
        return false;
      }
    }
    return this.isBlocked;
  }

  /**
   * Отправляет подозрительную активность на сервер
   */
  async reportSuspiciousActivity() {
    try {
      const activities = JSON.parse(localStorage.getItem('suspiciousActivity') || '[]');
      if (activities.length === 0) return;

      const response = await fetch('/api/security/report-suspicious', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          ...this.injectFingerprintHeaders()
        },
        body: JSON.stringify({
          activities,
          deviceInfo: await this.getDeviceInfo()
        })
      });

      if (response.ok) {
        localStorage.removeItem('suspiciousActivity');
        console.log('[DeviceSecurity] Подозрительная активность отправлена на сервер');
      }
    } catch (error) {
      console.error('[DeviceSecurity] Ошибка при отправке подозрительной активности:', error);
    }
  }

  /**
   * Проверяет целостность fingerprint
   */
  async verifyFingerprintIntegrity() {
    try {
      const currentFingerprint = await deviceFingerprint.getDeviceFingerprint();
      
      if (this.currentFingerprint !== currentFingerprint) {
        console.warn('[DeviceSecurity] Обнаружено изменение fingerprint во время сессии');
        this.handleFingerprintChange();
        this.currentFingerprint = currentFingerprint;
        return false;
      }
      
      return true;
    } catch (error) {
      console.error('[DeviceSecurity] Ошибка при проверке целостности fingerprint:', error);
      return false;
    }
  }

  /**
   * Получает метрики безопасности для отправки на сервер
   */
  getSecurityMetrics() {
    return {
      fingerprintStability: this.lastCheck ? Date.now() - this.lastCheck : 0,
      visitCount: deviceFingerprint.getVisitCount(),
      blockStatus: this.isBlocked,
      lastFingerprintCheck: this.lastCheck,
      suspiciousActivityCount: JSON.parse(localStorage.getItem('suspiciousActivity') || '[]').length
    };
  }
}

// Создаем единственный экземпляр сервиса
const deviceSecurityService = new DeviceSecurityService();

export default deviceSecurityService;