import { Campaign, ChoiceRequest, PrebidResult, requestHasPrebid } from "../../models";
import { StepResult } from "../stepResult";
import CategoryService from "../../services/category.service";
import { CategoryProviderType, BrandSafetySeverity } from "../../categories/categoryProvider";
import { AbstractStep } from "../abstractStep";
import { CampaignModel } from "../../models/CampaignModel";
import _ from "lodash";

export default abstract class AbstractPrebidStep extends AbstractStep {
  categoryService: CategoryService;
  defaultBrandSafetyThreshold = BrandSafetySeverity.High;
  prebidName: string;

  constructor(
    name: string,
    protected campaignModel: CampaignModel,
    protected categoryProviderType: CategoryProviderType,
    protected enableInApp: boolean,
    customMetrics: string[] = []
  ) {
    super(name + "_" + categoryProviderType, [
      "is_web_mobile",
      "provider",
      "bypassed",
      "passed_" + name,
      ...customMetrics,
    ]);
    this.metricName = name;
    this.prebidName = name.replace(/_/gi, "-");
    this.categoryService = CategoryService.getInstance();
    this.categoryProviderType = categoryProviderType;
    this.enableInApp = enableInApp;
  }
  fillStepResult(
    request: ChoiceRequest,
    result: StepResult,
    isWebMobile: boolean,
    passed: boolean,
    bypassed: boolean = false,
    metric?: Map<string, string>
  ) {
    this.fillStepResultMetric(result, isWebMobile, passed, bypassed, metric);
    if (bypassed) {
      result.ignoreCampaigns(...request.campaigns);
    } else {
      const campaigns = _.partition(request.campaigns, (campaign) =>
        CampaignModel.hasPrebid(
          request.campaignData[campaign.id],
          this.prebidName,
          this.categoryProviderType
        )
      );
      if (passed) {
        result.passCampaigns(...campaigns[0]);
      }
      result.ignoreCampaigns(...campaigns[1]);
    }
  }

  fillStepResultMetric(
    result: StepResult,
    isWebMobile: boolean,
    passed: boolean,
    bypassed: boolean = false,
    metric?: Map<string, string>
  ) {
    result.setMetricLabel("is_web_mobile", isWebMobile);
    result.setMetricLabel("provider", this.categoryProviderType);
    result.setMetricLabel("passed_" + this.metricName, passed);
    result.setMetricLabel("bypassed", bypassed);
    if (metric) {
      metric.forEach((value: string, key: string) => {
        result.setMetricLabel(key, value);
      });
    }
  }

  isBypassed(request: ChoiceRequest, result: StepResult): boolean {
    const isWebMobile = request.environment_type === "web";
    if (!isWebMobile && !this.enableInApp) {
      this.fillStepResult(request, result, isWebMobile, true, true);
      return true;
    }
    const hasPrebid = requestHasPrebid(request, this.prebidName, this.categoryProviderType);
    if (!hasPrebid) {
      this.fillStepResult(request, result, isWebMobile, true, true);
      return true;
    }
    return false;
  }
  addMetadataResult(request: ChoiceRequest, result: string) {
    if (!request.metadata.prebid_result) {
      request.metadata.prebid_result = [];
    }
    const prebidResult: PrebidResult = {
      provider: this.categoryProviderType,
      result: result,
      step: this.getMetricName(),
    };
    request.metadata.prebid_result.push(prebidResult);
  }
}