/**
 * 后台同步管理器
 * 
 * 整合前台服务、后台同步、消息状态管理
 * 参考 Element Android 的 BackgroundSyncStarter 设计
 */

import { AppState, AppStateStatus, Platform } from 'react-native';
import { ForegroundServiceModule } from './ForegroundServiceModule';
import { wsService } from '../core/wsService';
import AsyncStorage from '@react-native-async-storage/async-storage';

/**
 * 后台同步模式
 */
export enum BackgroundSyncMode {
  /** 省电模式：使用 expo-background-task（最小15分钟间隔） */
  BATTERY_SAVER = 'battery_saver',
  
  /** 实时模式：前台服务保活 + 持续同步 */
  REALTIME = 'realtime',
  
  /** 禁用后台同步 */
  DISABLED = 'disabled',
}

const STORAGE_KEY = 'background_sync_mode';
const SYNC_INTERVAL_MS = 30 * 1000; // 30 秒同步间隔

class BackgroundSyncManager {
  private mode: BackgroundSyncMode = BackgroundSyncMode.BATTERY_SAVER;
  private appStateSubscription: ReturnType<typeof AppState.addEventListener> | null = null;
  private syncInterval: ReturnType<typeof setInterval> | null = null;
  private isInitialized: boolean = false;
  private lastSyncAt: number = 0;
  private syncMessagesCallback: (() => Promise<void>) | null = null;

  /**
   * 设置消息同步回调函数
   * 由外部注入，避免循环依赖
   */
  setSyncMessagesCallback(callback: () => Promise<void>): void {
    this.syncMessagesCallback = callback;
  }

  /**
   * 初始化后台同步
   */
  async initialize(): Promise<void> {
    if (this.isInitialized) return;

    // 加载保存的模式
    const savedMode = await this.loadMode();
    this.mode = savedMode;

    // 监听 AppState 变化
    this.appStateSubscription = AppState.addEventListener(
      'change',
      this.handleAppStateChange
    );

    // 监听 WebSocket 断开
    this.setupWSDisconnectListener();

    this.isInitialized = true;
    console.log('[BackgroundSyncManager] 初始化完成, 模式:', this.mode);
  }

  /**
   * 切换后台同步模式
   */
  async setMode(mode: BackgroundSyncMode): Promise<void> {
    // 如果当前在后台，先停止旧模式的保活
    if (AppState.currentState !== 'active') {
      this.stopPeriodicSync();
      if (this.mode === BackgroundSyncMode.REALTIME) {
        await ForegroundServiceModule.stop();
      }
    }

    // 更新模式
    this.mode = mode;
    await this.saveMode(mode);

    // 根据新模式立即执行相应操作
    if (mode === BackgroundSyncMode.REALTIME) {
      // 切换到实时模式：立即启动前台服务（无论前台还是后台）
      const started = await ForegroundServiceModule.start({
        title: '萝卜社区',
        body: '正在后台同步消息',
      });
      if (started) {
        this.startPeriodicSync();
      }
    } else {
      // 切换到其他模式：立即停止前台服务和定时同步
      this.stopPeriodicSync();
      await ForegroundServiceModule.stop();
    }

    console.log('[BackgroundSyncManager] 模式已切换为:', mode);
  }

  /**
   * 获取当前模式
   */
  getMode(): BackgroundSyncMode {
    return this.mode;
  }

  /**
   * AppState 变化处理
   */
  private handleAppStateChange = async (nextState: AppStateStatus) => {
    console.log('[BackgroundSyncManager] AppState 变化:', nextState);

    if (nextState === 'background' || nextState === 'inactive') {
      // 进入后台
      await this.startForBackground();
    } else if (nextState === 'active') {
      // 回到前台
      await this.stopForForeground();
    }
  };

  /**
   * 进入后台时的处理
   */
  private async startForBackground(): Promise<void> {
    if (this.mode === BackgroundSyncMode.DISABLED) return;

    console.log('[BackgroundSyncManager] 进入后台');

    if (this.mode === BackgroundSyncMode.REALTIME) {
      // 确保前台服务正在运行
      await ForegroundServiceModule.start({
        title: '萝卜社区',
        body: '正在后台同步消息',
      });

      // 启动定时同步
      this.startPeriodicSync();
    }
  }

  /**
   * 回到前台时的处理
   */
  private async stopForForeground(): Promise<void> {
    console.log('[BackgroundSyncManager] 回到前台');

    // 停止定时同步（前台通过 WebSocket 实时同步，不需要轮询）
    this.stopPeriodicSync();

    // 实时模式下：前台服务保持运行，只更新通知文字
    if (this.mode === BackgroundSyncMode.REALTIME) {
      await ForegroundServiceModule.update('萝卜社区', '正在后台同步消息');
    }

    // 立即同步一次（获取离线消息）
    await this.syncMessages();
  }

  /**
   * 启动定时同步
   */
  private startPeriodicSync(): void {
    this.stopPeriodicSync();

    // 立即同步一次
    this.syncMessages();

    // 启动定时器
    this.syncInterval = setInterval(() => {
      this.syncMessages();
    }, SYNC_INTERVAL_MS);

    console.log('[BackgroundSyncManager] 定时同步已启动');
  }

  /**
   * 停止定时同步
   */
  private stopPeriodicSync(): void {
    if (this.syncInterval) {
      clearInterval(this.syncInterval);
      this.syncInterval = null;
      console.log('[BackgroundSyncManager] 定时同步已停止');
    }
  }

  /**
   * 设置 WebSocket 断开监听
   */
  private setupWSDisconnectListener(): void {
    // 监听 WebSocket 断开事件
    wsService.onDisconnect(() => {
      if (AppState.currentState !== 'active' && this.mode === BackgroundSyncMode.REALTIME) {
        console.log('[BackgroundSyncManager] WebSocket 断开，尝试重连');
        wsService.connect().catch((e) => {
          console.error('[BackgroundSyncManager] WebSocket 重连失败:', e);
        });
      }
    });
  }

  /**
   * 执行消息同步
   */
  async syncMessages(): Promise<void> {
    const now = Date.now();

    // 防止短时间内重复同步（最小 10 秒间隔）
    if (now - this.lastSyncAt < 10000) {
      return;
    }

    this.lastSyncAt = now;

    // 调用外部注入的同步回调
    if (this.syncMessagesCallback) {
      try {
        await this.syncMessagesCallback();
      } catch (error) {
        console.error('[BackgroundSyncManager] 同步失败:', error);
      }
    }
  }

  /**
   * 更新前台服务通知内容
   */
  async updateNotification(totalUnread: number): Promise<void> {
    if (this.mode !== BackgroundSyncMode.REALTIME) return;

    if (totalUnread > 0) {
      await ForegroundServiceModule.update(
        '萝卜社区',
        `您有 ${totalUnread} 条未读消息`
      );
    } else {
      await ForegroundServiceModule.update(
        '萝卜社区',
        '正在后台同步消息'
      );
    }
  }

  /**
   * 保存模式到存储
   */
  private async saveMode(mode: BackgroundSyncMode): Promise<void> {
    try {
      await AsyncStorage.setItem(STORAGE_KEY, mode);
    } catch (error) {
      console.error('[BackgroundSyncManager] 保存模式失败:', error);
    }
  }

  /**
   * 从存储加载模式
   */
  private async loadMode(): Promise<BackgroundSyncMode> {
    try {
      const saved = await AsyncStorage.getItem(STORAGE_KEY);
      return (saved as BackgroundSyncMode) || BackgroundSyncMode.BATTERY_SAVER;
    } catch (error) {
      return BackgroundSyncMode.BATTERY_SAVER;
    }
  }

  /**
   * 清理资源
   */
  async cleanup(): Promise<void> {
    this.stopPeriodicSync();
    this.appStateSubscription?.remove();
    this.appStateSubscription = null;
    await ForegroundServiceModule.stop();
    this.isInitialized = false;
  }
}

export const backgroundSyncManager = new BackgroundSyncManager();
