import AsyncStorage from '@/utils/kvStore';
import { logger } from '@/utils/logger';
import { api } from './api';

// 设备令牌存储键
const DEVICE_TOKEN_KEY = '@device_token';
const TOKEN_REGISTERED_KEY = '@token_registered';

// 设备令牌注册请求参数
export interface DeviceTokenRequest {
  deviceToken: string;
  deviceType: 'IOS' | 'ANDROID';
  appVersion: string;
  osVersion: string;
  deviceName: string;
}

// 设备令牌更新请求参数
export interface UpdateTokenRequest {
  currentDeviceToken: string;
  newDeviceToken: string;
  appVersion: string;
  osVersion: string;
}

// 设备令牌注销请求参数
export interface UnregisterTokenRequest {
  deviceToken: string;
}

// API响应类型
export interface PushNotificationResponse {
  success: boolean;
  tokenId: string;
}

// API错误响应类型
export interface PushNotificationError {
  code: number;
  message: string;
  data?: any;
}

/**
 * 推送通知API服务类
 */
export class PushNotificationService {
  private static instance: PushNotificationService;

  private constructor() { }

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

  /**
   * 注册设备令牌
   */
  async registerDeviceToken(request: DeviceTokenRequest): Promise<PushNotificationResponse> {
    try {
      logger.info('注册设备令牌:', request.deviceToken.substring(0, 20) + '...');

      const response = await api.post<PushNotificationResponse>(
        '/push-notifications/register-token',
        request
      );

      // 保存设备令牌到本地存储
      await AsyncStorage.setItem(DEVICE_TOKEN_KEY, request.deviceToken);
      await AsyncStorage.setItem(TOKEN_REGISTERED_KEY, 'true');

      logger.info('设备令牌注册成功:', response.tokenId);
      return response;
    } catch (error) {
      logger.error('设备令牌注册失败:', error);
      throw error;
    }
  }

  /**
   * 更新设备令牌
   */
  async updateDeviceToken(request: UpdateTokenRequest): Promise<PushNotificationResponse> {
    try {
      console.log('更新设备令牌:', request.newDeviceToken.substring(0, 20) + '...');

      const response = await api.put<PushNotificationResponse>(
        '/push-notifications/update-token',
        request
      );

      // 更新本地存储的设备令牌
      await AsyncStorage.setItem(DEVICE_TOKEN_KEY, request.newDeviceToken);

      console.log('设备令牌更新成功:', response.tokenId);
      return response;
    } catch (error) {
      console.error('设备令牌更新失败:', error);
      throw error;
    }
  }

  /**
   * 注销设备令牌
   */
  async unregisterDeviceToken(deviceToken: string): Promise<void> {
    try {
      console.log('注销设备令牌:', deviceToken.substring(0, 20) + '...');

      await api.delete<void>('/push-notifications/unregister-token', {
        body: { deviceToken }
      });

      // 清除本地存储
      await AsyncStorage.removeItem(DEVICE_TOKEN_KEY);
      await AsyncStorage.removeItem(TOKEN_REGISTERED_KEY);

      console.log('设备令牌注销成功');
    } catch (error) {
      console.error('设备令牌注销失败:', error);
      throw error;
    }
  }

  /**
   * 获取本地存储的设备令牌
   */
  async getStoredDeviceToken(): Promise<string | null> {
    try {
      return await AsyncStorage.getItem(DEVICE_TOKEN_KEY);
    } catch (error) {
      console.error('获取本地设备令牌失败:', error);
      return null;
    }
  }

  /**
   * 检查设备令牌是否已注册
   */
  async isTokenRegistered(): Promise<boolean> {
    try {
      const registered = await AsyncStorage.getItem(TOKEN_REGISTERED_KEY);
      return registered === 'true';
    } catch (error) {
      console.error('检查令牌注册状态失败:', error);
      return false;
    }
  }

  /**
   * 清除本地设备令牌数据
   */
  async clearLocalTokenData(): Promise<void> {
    try {
      await AsyncStorage.removeItem(DEVICE_TOKEN_KEY);
      await AsyncStorage.removeItem(TOKEN_REGISTERED_KEY);
      console.log('本地设备令牌数据已清除');
    } catch (error) {
      console.error('清除本地令牌数据失败:', error);
    }
  }
}

// 导出单例实例
export const pushNotificationService = PushNotificationService.getInstance();