import type {
  CompatiblePlaceholderArgument,
  ContactResult,
  ImageResponse,
  Location,
  PermissionAccess,
  PermissionName,
  PermissionStatus,
} from '@apps-in-toss/types';
import type { AppsInTossSignTossCertParams } from './native-modules/appsInTossSignTossCert';
import type { CheckoutPaymentOptions, CheckoutPaymentResult } from './native-modules/checkoutPayment';
import type { GetAnonymousKeyResponse } from './native-modules/getAnonymousKey';
import type { GameCenterGameProfileResponse } from './native-modules/getGameCenterGameProfile';
import type { GetUserKeyForGameResponse } from './native-modules/getUserKeyForGame';
import type { GrantPromotionRewardForGameResponse } from './native-modules/grantPromotionRewardForGame';
import type { IapCreateOneTimePurchaseOrderResult, IapSubscriptionInfoResult } from './native-modules/iap';
import type { SaveBase64DataParams } from './native-modules/saveBase64Data';
import type { SubmitGameCenterLeaderBoardScoreResponse } from './native-modules/submitGameCenterLeaderBoardScore';
import { MiniAppModule } from '../spec/MiniAppModule.brick';

/**
 * Async Methods Map
 * Type definitions for all async methods accessed via postMessage
 */
export interface AsyncMethodsMap {
  // Storage (4)
  getStorageItem: (params: { key: string }) => Promise<string | null>;
  setStorageItem: (params: { key: string; value: string }) => Promise<void>;
  removeStorageItem: (params: { key: string }) => Promise<void>;
  clearStorage: (params: CompatiblePlaceholderArgument) => Promise<void>;

  // Permissions (2)
  getPermission: (params: { name: PermissionName; access: PermissionAccess }) => Promise<PermissionStatus>;
  openPermissionDialog: (params: { name: PermissionName; access: PermissionAccess }) => Promise<'allowed' | 'denied'>;

  // Clipboard (2)
  getClipboardText: (params: CompatiblePlaceholderArgument) => Promise<string>;
  setClipboardText: (params: { text: string }) => Promise<void>;

  // Contacts & Photos (3)
  fetchContacts: (params: { size: number; offset: number; query?: { contains?: string } }) => Promise<ContactResult>;
  fetchAlbumPhotos: (params: { base64?: boolean; maxCount?: number; maxWidth?: number }) => Promise<ImageResponse[]>;
  openCamera: (params: { base64?: boolean; maxWidth?: number }) => Promise<ImageResponse>;

  // Location (1)
  startUpdateLocation: (params: { accuracy: number; timeInterval: number; distanceInterval: number }) => Promise<void>;
  getCurrentLocation: (params: { accuracy: number }) => Promise<Location>;

  // IAP (7)
  iapCreateOneTimePurchaseOrder: (params: { productId: string }) => Promise<IapCreateOneTimePurchaseOrderResult>;
  processProductGrant: (params: { orderId: string; isProductGranted: boolean }) => Promise<void>;
  iapGetProductItemList: (params: CompatiblePlaceholderArgument) => Promise<{ products: any[] }>;
  getPendingOrders: (
    params: CompatiblePlaceholderArgument
  ) => Promise<{ orders: Array<{ orderId: string; sku: string }> }>;
  getCompletedOrRefundedOrders: (params: { key?: string | null }) => Promise<any>;
  completeProductGrant: (params: { orderId: string }) => Promise<boolean>;
  getSubscriptionInfo: (params: {
    params: { orderId: string };
  }) => Promise<{ subscription: IapSubscriptionInfoResult }>;

  // Other (9)
  eventLog: (params: { log_name: string; log_type: string; params: Record<string, string> }) => Promise<void>;
  getTossShareLink: (params: CompatiblePlaceholderArgument) => Promise<{ shareLink: string }>;
  appLogin: (
    params: CompatiblePlaceholderArgument
  ) => Promise<{ authorizationCode: string; referrer: 'DEFAULT' | 'SANDBOX' }>;
  checkoutPayment: (params: CheckoutPaymentOptions) => Promise<CheckoutPaymentResult>;
  setDeviceOrientation: (params: { type: 'portrait' | 'landscape' }) => Promise<void>;
  saveBase64Data: (params: SaveBase64DataParams) => Promise<void>;
  appsInTossSignTossCert: (params: AppsInTossSignTossCertParams) => Promise<void>;
  getGameCenterGameProfile: (
    params: CompatiblePlaceholderArgument
  ) => Promise<GameCenterGameProfileResponse | undefined>;
  getUserKeyForGame: (params: CompatiblePlaceholderArgument) => Promise<GetUserKeyForGameResponse | undefined>;
  getUserKey: (params: CompatiblePlaceholderArgument) => Promise<GetAnonymousKeyResponse | undefined>;
  grantPromotionRewardForGame: (params: {
    promotionCode: string;
    amount: number;
  }) => Promise<GrantPromotionRewardForGameResponse | undefined>;
  submitGameCenterLeaderBoardScore: (params: {
    score: string;
  }) => Promise<SubmitGameCenterLeaderBoardScoreResponse | undefined>;

  // INTERNAL__appBridgeHandler methods (9)
  requestOneTimePurchase: (params: { sku: string }) => Promise<void>;
  contactsViral: (params: { moduleId: string }) => Promise<void>;
  getMiniAppsSupportContact: (params: object) => Promise<void>;
  loadAdMobInterstitialAd: (params: { adUnitId: string }) => Promise<void>;
  showAdMobInterstitialAd: (params: { adUnitId: string }) => Promise<void>;
  loadAdMobRewardedAd: (params: { adUnitId: string }) => Promise<void>;
  showAdMobRewardedAd: (params: { adUnitId: string }) => Promise<void>;
  loadAppsInTossAdmob: (params: { adGroupId: string; referrer: string }) => Promise<void>;
  showAppsInTossAdmob: (params: { adGroupId: string; referrer: string }) => Promise<void>;
  getIsTossLoginIntegratedService: (params: object) => Promise<boolean | undefined>;

  getServerTime: (params: CompatiblePlaceholderArgument) => Promise<{ serverTime: number }>;
  shareWithScheme: (params: { schemeURL: string }) => Promise<void>;
  requestMiniAppReview: (params: { title: string }) => Promise<void>;
}

/**
 * Sync Methods Map
 * Type definitions for all sync methods accessed via postMessageSync
 */
export interface SyncMethodsMap {
  getWebBundleURL: (params: CompatiblePlaceholderArgument) => { url: string };
  stopUpdateLocation: (params: object) => void;
}

/**
 * Type-safe postMessage wrapper
 * Provides type inference for async method calls without requiring 'as unknown' casts
 */
export function safePostMessage<K extends keyof AsyncMethodsMap>(
  method: K,
  params: Parameters<AsyncMethodsMap[K]>[0]
): ReturnType<AsyncMethodsMap[K]> {
  return MiniAppModule.postMessage(method, params, {}) as ReturnType<AsyncMethodsMap[K]>;
}

/**
 * Type-safe postMessageSync wrapper
 * Provides type inference for sync method calls without requiring 'as unknown' casts
 */
export function safeSyncPostMessage<K extends keyof SyncMethodsMap>(
  method: K,
  params: Parameters<SyncMethodsMap[K]>[0]
): ReturnType<SyncMethodsMap[K]> {
  return MiniAppModule.postMessageSync(method, params, {}) as ReturnType<SyncMethodsMap[K]>;
}