import {
  type NormalizedPlatformPlacementConfig,
  type NormalizedRewardedAdsConfig,
  type PlatformPlacementConfig,
  type RewardedAdsConfig,
  type RewardedAdTargetPlatform,
} from './types.ts';

export class ConfigValidationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = 'ConfigValidationError';
  }
}

function assertString(value: unknown, message: string) {
  if (typeof value !== 'string' || value.trim().length === 0) {
    throw new ConfigValidationError(message);
  }
  return value;
}

function normalizePlacement(
  placement: string,
  platform: RewardedAdTargetPlatform,
  config: PlatformPlacementConfig,
): NormalizedPlatformPlacementConfig {
  const adUnitId = assertString(config.adUnitId, `${placement}.${platform}.adUnitId is required`);

  switch (config.provider) {
  case 'admob':
    return {
      placement,
      platform,
      provider: 'admob',
      appId: assertString(config.appId, `${placement}.${platform}.appId is required`),
      adUnitId,
    };
  case 'wechat':
    return {
      placement,
      platform,
      provider: 'wechat',
      adUnitId,
    };
  case 'douyin':
    return {
      placement,
      platform,
      provider: 'douyin',
      adUnitId,
    };
  case 'max':
    return {
      placement,
      platform,
      provider: 'max',
      sdkKey: assertString(config.sdkKey, `${placement}.${platform}.sdkKey is required`),
      adUnitId,
    };
  case 'topon':
    return {
      placement,
      platform,
      provider: 'topon',
      appId: assertString(config.appId, `${placement}.${platform}.appId is required`),
      appKey: assertString(config.appKey, `${placement}.${platform}.appKey is required`),
      adUnitId,
    };
  default:
    throw new ConfigValidationError(`${placement}.${platform}.provider is invalid`);
  }
}

export function normalizeRewardedAdsConfig(options: {
  platform: RewardedAdTargetPlatform;
  config: RewardedAdsConfig;
}): NormalizedRewardedAdsConfig {
  const { platform, config } = options;
  if (!config || config.version !== 1) {
    throw new ConfigValidationError('config.version must be 1');
  }
  if (!config.placements || typeof config.placements !== 'object') {
    throw new ConfigValidationError('config.placements is required');
  }

  const placements: Record<string, NormalizedPlatformPlacementConfig> = {};
  for (const [placement, placementConfig] of Object.entries(config.placements)) {
    const platformConfig = placementConfig?.[platform];
    if (!platformConfig) {
      continue;
    }
    placements[placement] = normalizePlacement(placement, platform, platformConfig);
  }

  return {
    version: 1,
    platform,
    defaults: {
      preloadOnInit: Array.isArray(config.defaults?.preloadOnInit)
        ? config.defaults?.preloadOnInit.filter((item) => typeof item === 'string')
        : [],
    },
    placements,
  };
}