export type RewardType =
  | 'ADS'
  | 'JOLI_COIN'
  | 'JOLI_COIN_ONLY'
  | 'JOLI_GEM'
  | 'JOLI_GEM_ONLY'
  | 'SUBSCRIPTION';

import { context } from '../context';
import type { AdsRewardsHandler } from './registers/use-ads';
import { IUseModalFrequencyConfig, DefaltJoliCoinUseAndCharge, DefaltLoginGuide } from './reward-emitter';

export interface RewardHandlerMap {
  ADS: AdsRewardsHandler;
  JOLI_COIN: (params?: unknown) => Promise<boolean>; // coins + ads
  JOLI_COIN_ONLY: (params?: unknown) => Promise<boolean>; // coins only
  JOLI_GEM: (params?: unknown) => Promise<boolean>; // gem + ads
  JOLI_GEM_ONLY: (params?: unknown) => Promise<boolean>; // gem only
  SUBSCRIPTION: (params?: unknown) => Promise<boolean>; // subscription
}

export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];

const isTestMode = context.testMode;
export function createRewardsHelper() {
  const rewardsHandlers = new Map<RewardType, RewardHandler<any>>();

  let rewardFetcher: ((...args: any[]) => Promise<RewardType[]>) | undefined;
  let rewardFrequencyConfigFetcher: ((...args: any[]) => Promise<IUseModalFrequencyConfig>) | undefined;

  return {
    registerRewardHandler<T extends RewardType>(type: T, handler: RewardHandler<T>) {
      rewardsHandlers.set(type, handler);
    },
    async handleReward<T extends RewardType>(rewardsTypes: T[], ...args: Parameters<RewardHandler<T>>) {
      const result = await rewardsTypes.reduce(async (prevPromise, type) => {
        const prevResult = await prevPromise;
        if (prevResult === true) return true;

        isTestMode && console.log(`handleReward ${type}`);
        const handler = rewardsHandlers.get(type);
        const nextResult = handler ? await handler(...args) : prevResult;
        isTestMode && console.log(`handleReward ${type} ${nextResult}`);
        return nextResult;
      }, Promise.resolve(false));

      return result;
    },
    async registerRewardsFetcher<T extends RewardType>(fetcher: (...args: any[]) => Promise<T[]>) {
      rewardFetcher = async (...args: unknown[]) => {
        try {
          const rewardsTypes = await fetcher(...args);
          return rewardsTypes;
        } catch (e) {
          console.error(`getRewardOptions error:`, e);
          return ['ADS'];
        }
      };
    },
    async registerRewardFrequencyConfigFetcher(
      fetcher: (...args: any[]) => Promise<IUseModalFrequencyConfig>
    ) {
      rewardFrequencyConfigFetcher = async (...args: unknown[]) => {
        try {
          const config = await fetcher(...args);
          return config;
        } catch (e) {
          console.error(`getRewardOptions error:`, e);
          return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge, loginGuide: DefaltLoginGuide };
        }
      };
    },

    async getRewardsTypes(...args: unknown[]): Promise<RewardType[]> {
      if (!rewardFetcher) {
        return ['ADS'];
      }
      return await rewardFetcher(...args);
    },
    async getRewardFrequencyConfig(...args: unknown[]): Promise<IUseModalFrequencyConfig> {
      if (!rewardFrequencyConfigFetcher) {
        return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge, loginGuide: DefaltLoginGuide };
      }
      return await rewardFrequencyConfigFetcher(...args);
    }
  };
}

export type RewardsHelper = ReturnType<typeof createRewardsHelper>;