import { Campaign, ChoiceRequest } from "../../models";
import { StepResult } from "../stepResult";
import {
  CategoryProviderType,
  CategoryRating,
  BrandSafetySeverity,
  stringToBrandSafetySeverity,
} from "../../categories/categoryProvider";
import { CampaignModel } from "../../models/CampaignModel";
import AbstractPrebidStep from "./abstractPrebid.step";

export default class BrandSafetyStep extends AbstractPrebidStep {
  defaultBrandSafetyThreshold = BrandSafetySeverity.High;

  constructor(
    campaignModel: CampaignModel,
    categoryProviderType: CategoryProviderType,
    enableInApp: boolean
  ) {
    super("brand_safety", campaignModel, categoryProviderType, enableInApp, [
      "brand_safety_high",
      "brand_safety_medium",
      "brand_safety_low",
    ]);
  }

  async run(request: ChoiceRequest): Promise<StepResult> {
    const fillCache: number = this.featureConfigService.getFloatValue(
      request,
      "ms-choices.brand-safety.fill-cache." + this.categoryProviderType,
      0
    );
    const result: StepResult = new StepResult();
    if (this.isBypassed(request, result)) {
      if (fillCache !== 0 && Math.random() < fillCache) {
        // force caching even if no campaign are elligible
        this.categoryService.getPublisherCategoryValue(request, this.categoryProviderType);
      }
      return result;
    }

    const passUnknown: boolean = this.featureConfigService.getBooleanValue(
      request,
      "ms-choices.brand-safety.allow-unknown." + this.categoryProviderType,
      false
    );
    const brandSafetySeverityName: string = this.featureConfigService.getStringValue(
      request,
      "ms-choices.brand-safety.severity." + this.categoryProviderType,
      this.defaultBrandSafetyThreshold
    );
    const brandSafetyCustomFilters: string = this.featureConfigService.getStringValue(
      request,
      "ms-choices.brand-safety.custom-filtering." + this.categoryProviderType,
      ""
    );
    const brandSafetySeverityThreshold = stringToBrandSafetySeverity(
      brandSafetySeverityName,
      this.defaultBrandSafetyThreshold
    );

    const bsValues = await this.categoryService.getPublisherCategoryValue(
      request,
      this.categoryProviderType
    );
    let bsValue: CategoryRating =
      bsValues.getBrandSafety(brandSafetySeverityThreshold) || CategoryRating.Safe;
    if (brandSafetyCustomFilters.length > 0) {
      for (const segment of brandSafetyCustomFilters.split(",")) {
        if (bsValues.isBlockedBySegment(segment.trim())) {
          bsValue = CategoryRating.Unsafe;
          break;
        }
      }
    }
    const brandSafe: boolean =
      bsValue === CategoryRating.Safe || (bsValue === CategoryRating.Unknown && passUnknown);
    const metrics = new Map<string, string>([
      ["brand_safety_high", bsValues.getBrandSafety(BrandSafetySeverity.High)],
      ["brand_safety_medium", bsValues.getBrandSafety(BrandSafetySeverity.Medium)],
      ["brand_safety_low", bsValues.getBrandSafety(BrandSafetySeverity.Low)],
    ]);
    this.addMetadataResult(request, bsValue);
    this.fillStepResult(
      request,
      result,
      request.environment_type === "web",
      brandSafe,
      false,
      metrics
    );
    return result;
  }
}