import { track } from '../report';
import { createCommands, EventEmitter, platform } from '@jolibox/common';
import { httpClientManager } from '../http';
import { notifyCustomEvent } from '@/common/utils';
import {
  createAdsRewardHandler,
  rewardsHelper,
  createJolicoinRewardHandler,
  createJolicoinOnlyRewardHandler,
  createSubscriptionRewardHandler
} from '@/common/rewards';
import {
  JoliboxAdsForGame,
  type IAdsContext,
  type IAdsInitParams,
  type IAdBreakParams,
  type IAdConfigParams,
  type IAdUnitParams
} from '@jolibox/ads';
import { context, SDKEnvironment } from '@/common/context';
import '../rewards';
import DlightekAdsHandler from './platformAdsHandle/DlightekAdsHandler';
import HuaweiQuickAdsHandler from './platformAdsHandle/HuaweiQuickAdsHandler';
import GamedistributionAdsHandler from './platformAdsHandle/GamedistributionAdsHandler';
import FunmaxAdsHandler from './platformAdsHandle/FunmaxAdsHandler';
import JoliboxAdsHandler from './platformAdsHandle/JoliboxAdsHandler';
import { warmupRewardCache } from '@/common/rewards/fetch-reward';
import { warmupBalanceCache } from '@/common/rewards';

declare global {
  interface Window {
    // 传音sdk
    h5sdk: JoliboxAdsForGame;
    // 华为快应用
    system: {
      postMessage: (params: string) => void;
    };
  }
}
export interface IAdsHandler {
  init(config?: IAdsInitParams): void;
  adConfig(params: IAdConfigParams): void;
  adBreak(params: IAdBreakParams): Promise<void> | void;
  adUnit(params: IAdUnitParams): void;
  getAdsInstance(): JoliboxAdsForGame;
}
class H5AdsManager {
  private context: IAdsContext<'GAME'>;
  private cacheHandler: IAdsHandler | null = null;

  constructor(context: IAdsContext<'GAME'>) {
    this.context = context;
  }

  private createAdsHandler(sdkEnvironment: SDKEnvironment): IAdsHandler {
    if (this.cacheHandler) {
      return this.cacheHandler;
    }

    switch (sdkEnvironment) {
      case SDKEnvironment.dlightek: {
        this.cacheHandler = new DlightekAdsHandler(window.h5sdk);
        break;
      }
      case SDKEnvironment.huaweiQuick: {
        this.cacheHandler = HuaweiQuickAdsHandler.getInstance();
        break;
      }
      case SDKEnvironment.gamedistribution: {
        this.cacheHandler = GamedistributionAdsHandler.getInstance();
        break;
      }
      case SDKEnvironment.funmax: {
        const joliboxAds = new JoliboxAdsForGame(this.context);
        this.cacheHandler = new FunmaxAdsHandler(joliboxAds, httpClient);
        break;
      }
      default: {
        const joliboxAds = new JoliboxAdsForGame(this.context);
        this.cacheHandler = new JoliboxAdsHandler(joliboxAds, httpClient);
        break;
      }
    }
    return this.cacheHandler;
  }

  getAdsHandler(sdkEnvironment: SDKEnvironment): IAdsHandler {
    return this.createAdsHandler(sdkEnvironment);
  }
}

const commands = createCommands();
const adEventEmitter = new EventEmitter<{
  isAdShowing: [boolean];
}>();

const httpClient = httpClientManager.create();

const adsContext: IAdsContext<'GAME'> = {
  httpClient,
  checkNetwork: () => httpClientManager.getNetworkStatus(),
  track,
  eventEmitter: adEventEmitter,
  getWindowInfo: () => ({
    width: window.innerWidth * window.devicePixelRatio,
    height: window.innerHeight * window.devicePixelRatio,
    statusBarHeight: 0
  }),
  handleLinkClicked: (link) => {
    window.open(link, '_blank');
  },
  getContextInfo: () => {
    return {
      hostAppId: context.hostInfo?.aid ?? '1',
      deviceId: context.deviceInfo.did ?? '',
      adId: context.deviceInfo.adId ?? '',
      sessionId: context.sessionId ?? '',
      userId: context.hostUserInfo?.uid ?? '',
      objectType: 'GAME',
      objectId: context.mpId,
      testAdsMode: context.testAdsMode,
      channel: context.joliSource ?? '',
      deviceBrand: context.deviceInfo.brand,
      deviceModel: context.deviceInfo.model,
      osType: platform.isAndroid ? 'ANDROID' : platform.isiOS ? 'IOS' : 'PC',
      runtimeType: 'WEB',
      platform: 1000, // WebSDK
      joliSource: context.joliSource ?? '',
      deviceInfo: {
        platform: 'h5',
        nativeSDKVersionCode: 0 // not support in h5
      }
    };
  }
};

const handleUnlockSuccess = (params: { quantity: number; balance: number }) => {
  notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
    JOLI_COIN: params
  });
  track('jolicoin_unlock_success', {
    quantity: params.quantity
  });
};

const handleUnlockWithSubscriptionSuccess = () => {
  track('subscription_unlock_success', {});
};

const adsManager = new H5AdsManager(adsContext);
const adsHandler = adsManager.getAdsHandler(context.sdkEnvironment);

rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(adsHandler.getAdsInstance()));
rewardsHelper.registerRewardHandler(
  'JOLI_COIN',
  createJolicoinRewardHandler(httpClient, {
    onUnlockSuccess: handleUnlockSuccess.bind(this),
    hasSubscription: () => true
  }) as unknown as (params?: unknown) => Promise<boolean>
);

rewardsHelper.registerRewardHandler(
  'JOLI_COIN_ONLY',
  createJolicoinOnlyRewardHandler(httpClient, {
    onUnlockSuccess: handleUnlockSuccess.bind(this),
    hasSubscription: () => true
  }) as unknown as (params?: unknown) => Promise<boolean>
);

rewardsHelper.registerRewardHandler(
  'SUBSCRIPTION',
  createSubscriptionRewardHandler(httpClient, {
    onSubSuccess: handleUnlockWithSubscriptionSuccess.bind(this),
    hasSubscription: () => true
  }) as unknown as (params?: unknown) => Promise<boolean>
);

warmupRewardCache(httpClient);
warmupBalanceCache(httpClient);

adEventEmitter.on('isAdShowing', (isAdShowing) => {
  notifyCustomEvent('JOLIBOX_ADS_EVENT', { isAdShowing });
});

commands.registerCommand('AdsSDK.init', (params?: IAdsInitParams) => {
  adsHandler.init(params);
});

commands.registerCommand('AdsSDK.adConfig', (params: IAdConfigParams) => {
  adsHandler.adConfig(params);
});

commands.registerCommand('AdsSDK.adBreak', (params: IAdBreakParams) => {
  adsHandler.adBreak(params);
});

commands.registerCommand('AdsSDK.adUnit', (params: IAdUnitParams) => {
  adsHandler.adUnit(params);
});