import AsyncStorage from '@/utils/kvStore';
import { BackgroundTaskManager } from './backgroundTaskManagerV2';

/**
 * 后台任务调试工具
 * 提供简单的调试和测试功能
 */
export class BackgroundTaskDebugger {
  private static instance: BackgroundTaskDebugger;

  static getInstance(): BackgroundTaskDebugger {
    if (!BackgroundTaskDebugger.instance) {
      BackgroundTaskDebugger.instance = new BackgroundTaskDebugger();
    }
    return BackgroundTaskDebugger.instance;
  }

  /**
   * 获取后台任务诊断信息
   */
  async getDiagnosticInfo(): Promise<{
    taskManager: any;
    storage: any;
  }> {
    const taskManager = BackgroundTaskManager.getInstance();

    return {
      taskManager: {
        isInitialized: await this.getTaskManagerInitStatus(),
        status: await taskManager.getStatus(),
        statusText: await taskManager.checkStatus(),
      },
      storage: await this.getRelevantStorageValues(),
    };
  }

  /**
   * 手动测试后台任务
   */
  async testBackgroundTask(): Promise<{
    success: boolean;
    error?: string;
    executionTime: number;
  }> {
    const startTime = Date.now();

    try {
      const taskManager = BackgroundTaskManager.getInstance();
      await taskManager.testBackgroundTask();

      const executionTime = Date.now() - startTime;

      return {
        success: true,
        executionTime
      };
    } catch (error) {
      const executionTime = Date.now() - startTime;

      return {
        success: false,
        error: error instanceof Error ? error.message : String(error),
        executionTime
      };
    }
  }

  /**
   * 清理后台任务相关数据
   */
  async clearBackgroundTaskData(): Promise<void> {
    const keys = [
      '@last_background_water_check',
      '@last_background_test_notification',
    ];

    for (const key of keys) {
      try {
        await AsyncStorage.removeItem(key);
        console.log(`已清理存储键: ${key}`);
      } catch (error) {
        console.error(`清理存储键失败 ${key}:`, error);
      }
    }
  }

  /**
   * 重置后台任务管理器
   */
  async resetBackgroundTaskManager(): Promise<void> {
    try {
      const taskManager = BackgroundTaskManager.getInstance();
      await taskManager.stop();
      await this.clearBackgroundTaskData();

      // 重新初始化
      await taskManager.initialize();

      console.log('后台任务管理器已重置');
    } catch (error) {
      console.error('重置后台任务管理器失败:', error);
      throw error;
    }
  }

  /**
   * 启用测试通知
   */
  async enableTestNotification(): Promise<void> {
    try {
      await AsyncStorage.setItem('@enable_test_notification', 'true');
      console.log('已启用测试通知');
    } catch (error) {
      console.error('启用测试通知失败:', error);
    }
  }

  /**
   * 禁用测试通知
   */
  async disableTestNotification(): Promise<void> {
    try {
      await AsyncStorage.removeItem('@enable_test_notification');
      console.log('已禁用测试通知');
    } catch (error) {
      console.error('禁用测试通知失败:', error);
    }
  }

  /**
   * 检查是否启用了测试通知
   */
  async isTestNotificationEnabled(): Promise<boolean> {
    try {
      const enabled = await AsyncStorage.getItem('@enable_test_notification');
      return enabled === 'true';
    } catch (error) {
      console.error('检查测试通知状态失败:', error);
      return false;
    }
  }

  private async getTaskManagerInitStatus(): Promise<boolean> {
    try {
      const taskManager = BackgroundTaskManager.getInstance();
      const status = await taskManager.getStatus();
      const statusText = await taskManager.checkStatus();
      return statusText !== '受限制';
    } catch (error) {
      console.error('获取任务管理器状态失败:', error);
      return false;
    }
  }

  private async getRelevantStorageValues(): Promise<Record<string, any>> {
    const keys = [
      '@last_background_water_check',
      '@last_background_test_notification',
      '@enable_test_notification',
    ];

    const values: Record<string, any> = {};

    for (const key of keys) {
      try {
        const value = await AsyncStorage.getItem(key);
        values[key] = value;
      } catch (error) {
        values[key] = `Error: ${error}`;
      }
    }

    return values;
  }
}

export const backgroundTaskDebugger = BackgroundTaskDebugger.getInstance();