import _ from "lodash";
import { Campaign } from "./campaign.model";
import { App } from "./app.model";
import { Site } from "./site.model";
import { Context } from "./context.model";
import { User } from "./user.model";
import { Device } from "./device.model";
import { CategoryProviderType, ICategoryValue } from "../categories/categoryProvider";
import { CampaignData, CampaignModel } from "./CampaignModel";
import IStepStatus = ogury.delivery.monitoring.DeliveryMonitoringMessage.IStepStatus;
import { ogury } from "../protos/protos";
import { EnvironmentType } from "../utils/RequestUtils";
import { LabelValues } from "../services/metric.service";

export enum CampaignGroup {
  None = 0,
  Managed = 1 << 0,
  Programmatic = 1 << 1,
  Marketplace = 1 << 2,
  Fallback = 1 << 3,
  All = 0xffffffff,
}

export interface ChoiceRequest {
  // some old fields
  id: string;
  request_id?: string;
  type?: RequestType;
  app?: App;
  site?: Site;
  device?: Device;
  context?: Context;
  user?: User;
  campaigns: Campaign[];
  campaignData: Record<string, CampaignData>;
  excluded?: Campaign[];
  dvHashes?: DVHashes;
  deviceCategories?: Map<CategoryProviderType, ICategoryValue>;
  categories?: Map<CategoryProviderType, ICategoryValue>;
  decodedRequest?: any;
  inventory_source: RequestInventorySource;
  environment_type: EnvironmentType;
  bidfloor?: number | null;
  size?: number;
  tMax?: number;
  headerBiddingType?: HeaderBiddingType;

  stepsStatuses: IStepStatus[];
  isWeb: boolean;
  metadata: RequestMetadata;
  metadataTmp: { [key: string]: any }; // Metadata that doesn't need to be logged
  allMetricsLabels: LabelValues;
  globalRequestLabels: LabelValues;

  groupedCampaignIds: {
    managed: Set<string>;
    programmatic: Set<string>;
    marketplace: Set<string>;
    fallback: Set<string>;
  };
}
export type PrebidResult = {
  provider: CategoryProviderType;
  result: string;
  step: string;
};

export type RequestMetadata = {
  prebid_result?: PrebidResult[];
  composite_score_strategy?: string;
  sort_strategy?: string;

  ogury_bidfloor?: number | null;

  // yield
  difference?: number;
  bound_lower?: number;
  bound_upper?: number;
  app_eecpm?: number;
  app_ecpm?: number;

  supply_obj_prio_score?: number | null;
  supply_obj_delay?: number | null;
  context_level?: number;
};

export enum RequestInventorySource {
  INTERNAL = "INTERNAL",
  EXTERNAL = "EXTERNAL",
  HEADER_BIDDING = "HEADER_BIDDING",
}

export enum RequestType {
  AD = "ad",
  AFTER_AD = "afterAd",
}

export enum HeaderBiddingType {
  MAX = "MAX",
  PreBidJS = "PreBid",
  AmazonTAM = "Amazon TAM",
}

export interface DVHashes {
  [key: string]: string;
}
export function requestHasPrebid(request: ChoiceRequest, type: string, provider: string): boolean {
  return (
    request.campaigns.find((campaign) =>
      CampaignModel.hasPrebid(request.campaignData[campaign.id], type, provider)
    ) !== undefined
  );
}

export const splitReqCampaignGroups = (
  request: ChoiceRequest,
  firstGroupTypes: CampaignGroup
): [Campaign[], Campaign[]] => {
  if (firstGroupTypes === CampaignGroup.None) {
    return [[], [...request.campaigns]];
  } else if (firstGroupTypes === CampaignGroup.All) {
    return [[...request.campaigns], []];
  }

  const keepManaged = (firstGroupTypes & CampaignGroup.Managed) !== 0;
  const keepProgrammatic = (firstGroupTypes & CampaignGroup.Programmatic) !== 0;
  const keepMarketplace = (firstGroupTypes & CampaignGroup.Marketplace) !== 0;
  const keepFallback = (firstGroupTypes & CampaignGroup.Fallback) !== 0;

  const campaignIds = request.groupedCampaignIds;

  return _.partition(request.campaigns, (c) => {
    return (
      (keepManaged && campaignIds.managed.has(c.id)) ||
      (keepProgrammatic && campaignIds.programmatic.has(c.id)) ||
      (keepMarketplace && campaignIds.marketplace.has(c.id)) ||
      (keepFallback && campaignIds.fallback.has(c.id))
    );
  });
};