import { RequestCacheService, RequestAdapter } from '@jolibox/common';
import { IHttpClient } from '@/common/http';
import { StandardResponse } from '@jolibox/types';

interface GemBalanceRequest {
  endpoint: string;
  query?: Record<string, unknown>;
  method?: 'GET' | 'POST';
}

// 定义宝石余额响应类型
interface GemBalanceResponse {
  balance: number;
}

interface GemBalanceCacheData {
  balance: number;
  timestamp: number;
}

class GemBalanceRequestAdapter
  implements
    RequestAdapter<GemBalanceRequest, StandardResponse<GemBalanceResponse>, GemBalanceCacheData, undefined>
{
  constructor(private httpClient: IHttpClient) {}

  async execute(
    endpoint: string,
    options?: GemBalanceRequest
  ): Promise<StandardResponse<GemBalanceResponse>> {
    const method = options?.method || 'GET';
    const query = options?.query || {};

    if (method === 'GET') {
      return await this.httpClient.get<StandardResponse<GemBalanceResponse>>(endpoint, {
        query: query as Record<string, string>
      });
    } else {
      return await this.httpClient.post<StandardResponse<GemBalanceResponse>>(endpoint, {
        query: query as Record<string, string>
      });
    }
  }

  extractCacheableData(response: StandardResponse<GemBalanceResponse>): GemBalanceCacheData {
    return {
      balance: response.data?.balance || 0,
      timestamp: Date.now()
    };
  }

  // 宝石余额使用纯缓存模式
  extractRealTimeData?: undefined;
  mergeData?: undefined;

  processCachedData(cached: GemBalanceCacheData): StandardResponse<GemBalanceResponse> {
    return {
      code: 'SUCCESS',
      message: 'success from cache',
      data: {
        balance: cached.balance
      }
    };
  }
}

// 缓存宝石余额服务
export class CachedGemBalanceService {
  private gemBalanceService: RequestCacheService<
    GemBalanceRequest,
    StandardResponse<GemBalanceResponse>,
    GemBalanceCacheData,
    undefined
  >;

  constructor(httpClient: IHttpClient) {
    this.gemBalanceService = new (RequestCacheService as new (...args: unknown[]) => RequestCacheService<
      GemBalanceRequest,
      StandardResponse<GemBalanceResponse>,
      GemBalanceCacheData,
      undefined
    >)(new GemBalanceRequestAdapter(httpClient), {
      duration: 20 * 60 * 1000, // 20分钟缓存（宝石余额变化较少）
      timeout: 1000, // 1s timeout for request
      keyGenerator: (endpoint: string, params?: GemBalanceRequest) => {
        const queryStr = params?.query ? JSON.stringify(params.query) : '';
        return `${endpoint}:${queryStr}`;
      }
    });
  }

  async getGemBalance(type = 'GEM'): Promise<GemBalanceResponse | undefined> {
    const response = await this.gemBalanceService.request('/api/joli-gem/balance', {
      endpoint: '/api/joli-gem/balance',
      query: { type },
      method: 'GET'
    });
    return response.data;
  }

  async refreshGemBalance(type = 'GEM'): Promise<GemBalanceResponse | undefined> {
    const response = await this.gemBalanceService.forceRequest('/api/joli-gem/balance', {
      endpoint: '/api/joli-gem/balance',
      query: { type },
      method: 'GET'
    });
    return response.data;
  }

  async warmupGemBalance(type = 'GEM'): Promise<void> {
    await this.gemBalanceService.warmupCache('/api/joli-gem/balance', {
      endpoint: '/api/joli-gem/balance',
      query: { type },
      method: 'GET'
    });
  }

  clearGemBalanceCache(): void {
    this.gemBalanceService.clearCache();
  }

  getGemBalanceCacheStats() {
    return this.gemBalanceService.getCacheStats();
  }

  clearExpiredCache(): void {
    this.gemBalanceService.clearExpiredCache();
  }
}

// create instance
let cachedGemBalanceServiceInstance: CachedGemBalanceService | null = null;

function getCachedGemBalanceService(httpClient: IHttpClient): CachedGemBalanceService {
  if (!cachedGemBalanceServiceInstance) {
    cachedGemBalanceServiceInstance = new CachedGemBalanceService(httpClient);
  }
  return cachedGemBalanceServiceInstance;
}

/**
 * 缓存版本的 fetchGemBalance 函数
 */
export const fetchGemBalanceCached = async (httpClient: IHttpClient, type = 'GEM') => {
  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
  return await cachedGemBalanceService.getGemBalance(type);
};

/**
 * 强制刷新宝石余额缓存
 */
export const refreshGemBalanceCache = async (httpClient: IHttpClient, type = 'GEM') => {
  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
  const result = await cachedGemBalanceService.refreshGemBalance(type);
  console.log(`Gem balance cache refreshed for type: ${type}`);
  return result;
};

/**
 * 预热宝石余额缓存
 */
export const warmupGemBalanceCache = async (httpClient: IHttpClient, type = 'GEM') => {
  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
  await cachedGemBalanceService.warmupGemBalance(type);
  console.log(`Gem balance cache warmed up for type: ${type}`);
};

export const clearGemBalanceCache = (httpClient: IHttpClient) => {
  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
  cachedGemBalanceService.clearGemBalanceCache();
  console.log('Gem balance cache cleared');
};

export const getGemBalanceCacheStats = (httpClient: IHttpClient) => {
  const cachedGemBalanceService = getCachedGemBalanceService(httpClient);
  return cachedGemBalanceService.getGemBalanceCacheStats();
};

export const getGemBalanceCacheService = (httpClient: IHttpClient): CachedGemBalanceService => {
  return getCachedGemBalanceService(httpClient);
};