import { ConstructorClientOptions, NetworkParameters } from '.';

export default Searchandising;

export interface RetrieveCampaignsParameters {
  section?: string;
  id?: number | number[];
  refinedFilters?: Record<string, string | string[]>;
  numResultsPerPage?: number;
  page?: number;
  offset?: number;
  refinedRecommendationContexts?: RefinedRecommendationContext;
  refinedQueries?: string[];
}

export interface RefinedRecommendationContext {
  pod_id?: string[];
  condition_type?: ('attribute' | 'item' | 'expression')[];
}

export interface RetrieveCampaignParameters {
  id: number;
  section?: string;
}

/* fields shared by create and update campaign requests */
export interface CampaignParametersBase {
  section?: string;
  name?: string;
  description?: string;
  requestTagName?: RequestTag;
  requestTagValue?: string;
  startTime?: string;
  endTime?: string;
  refinedQueries?: RefinedQuery[];
  refinedFilters?: RefinedFilter[];
  refinedRecommendationContexts?: RecommendationContext[];
  boostRules?: CampaignRuleInput[];
  blacklistRules?: CampaignRuleInput[];
  slotRules?: CampaignRuleInput[];
  contentRules?: CampaignRuleInput[];
  filtersSlotRules?: CampaignRuleInput[];
  whitelistRule?: CampaignRuleInput | null;
  variationSlicingRule?: CampaignRuleInput | null;
  metadataJson?: CampaignMetadata;
}

export interface CreateCampaignParameters extends CampaignParametersBase {
  name: string;
}

export interface UpdateCampaignParameters extends CampaignParametersBase {
  id: number;
}

export interface DeleteCampaignParameters {
  id: number;
  section?: string;
}

export interface Campaigns {
  options: ConstructorClientOptions;

  retrieveCampaigns(
    parameters?: RetrieveCampaignsParameters,
    networkParameters?: NetworkParameters
  ): Promise<CampaignListGetResponse>;

  retrieveCampaign(
    parameters: RetrieveCampaignParameters,
    networkParameters?: NetworkParameters
  ): Promise<CampaignGetResponse>;

  createCampaign(
    parameters: CreateCampaignParameters,
    networkParameters?: NetworkParameters
  ): Promise<CampaignPostResponse>;

  updateCampaign(
    parameters: UpdateCampaignParameters,
    networkParameters?: NetworkParameters
  ): Promise<CampaignPatchResponse>;

  deleteCampaign(
    parameters: DeleteCampaignParameters,
    networkParameters?: NetworkParameters
  ): Promise<void>;
}

declare class Searchandising {
  constructor(options: ConstructorClientOptions);

  options: ConstructorClientOptions;

  campaigns: Campaigns;
}

export type RequestTag =
  | 'client_ip'
  | 'client_version'
  | 'geo_city'
  | 'geo_country'
  | 'geo_country_iso_code'
  | 'geo_region'
  | 'dt_weekday'
  | 'dt_timeofday'
  | 'user_segment'
  | 'autogenerated_user_segment'
  | 'dynamic_segment';

export interface RefinedQuery {
  query: string;
}

export interface RefinedFilter {
  filter_name: string;
  filter_value: string;
}

export interface RecommendationContext {
  pod_id: string;
  condition: RecommendationContextCondition;
}

export type RecommendationContextCondition =
  | RecommendationContextItemCondition
  | RecommendationContextAttributeCondition
  | RecommendationContextExpressionCondition;

export interface RecommendationContextItemCondition {
  type: 'item';
  item_id?: string;
}

export interface RecommendationContextAttributeCondition {
  type: 'attribute';
  filter_name?: string;
  filter_value?: string;
}

export interface RecommendationContextExpressionCondition {
  type: 'expression';
  expression: Record<string, string[]>;
}

export type FiltersObj = Record<string, string[]>;

export interface PositionRange {
  start: number;
  end: number;
}

export interface BoostRuleParameters {
  filters?: FiltersObj;
  item_ids?: string[];
  boost: number;
}

export interface BlacklistRuleParameters {
  filters?: FiltersObj;
  item_ids?: string[];
}

export interface SlotRuleParameters {
  item_id: string;
  position: number;
  variation_slice?: Record<string, string[]>;
  fuzzy_match?: boolean;
  labels?: Record<string, any>;
}

export interface ContentRuleParameters {
  data: Record<string, any>;
}

export interface FiltersSlotRuleParameters {
  position_ranges: PositionRange[];
  filters?: FiltersObj;
  filter_expression?: Record<string, any> | string;
  labels?: Record<string, any>;
}

export interface WhitelistRuleParameters {
  filters: FiltersObj;
}

export interface VariationSlicingRuleParameters {
  facet_names: string[];
  filter_expression?: Record<string, any> | string;
}

/* shared fields present on every campaign rule */
export interface RuleObjBase {
  id: number;
  request_tag_name?: RequestTag;
  request_tag_value?: string;
  active?: boolean;
  start_time?: string;
  end_time?: string;
  campaign_id?: number;
  automatically_generated?: boolean;
  created_at?: string;
  updated_at?: string;
}

export interface BoostRule extends RuleObjBase {
  rule_type: 'boost';
  rule: BoostRuleParameters;
}

export interface BlacklistRule extends RuleObjBase {
  rule_type: 'blacklist';
  rule: BlacklistRuleParameters;
}

export interface SlotRule extends RuleObjBase {
  rule_type: 'slot';
  rule: SlotRuleParameters;
  request_filters?: Record<string, string[]>;
}

export interface ContentRule extends RuleObjBase {
  rule_type: 'content';
  rule: ContentRuleParameters;
}

export interface FiltersSlotRule extends RuleObjBase {
  rule_type: 'filters_slot';
  rule: FiltersSlotRuleParameters;
}

export interface WhitelistRule extends RuleObjBase {
  rule_type: 'whitelist';
  rule: WhitelistRuleParameters;
}

export interface VariationSlicingRule extends RuleObjBase {
  rule_type: 'variation_slicing';
  rule: VariationSlicingRuleParameters;
}

export type RuleObj =
  | BoostRule
  | BlacklistRule
  | SlotRule
  | ContentRule
  | FiltersSlotRule
  | WhitelistRule
  | VariationSlicingRule;

/*
 * Omit the server-assigned fields from each rule.
 * `Omit` does not distribute over unions - applied directly to RuleObj it would merge
 * all members into one object and decouple rule_type from rule. The `T extends unknown`
 * conditional forces distribution so each member is omitted individually and the
 * rule_type/rule discrimination is preserved.
 */
type OmitServerFields<T> = T extends unknown
  ? Omit<T, 'id' | 'created_at' | 'updated_at'>
  : never;

/* rule definition supplied when creating or modifying a campaign - server-assigned fields are omitted */
export type CampaignRuleInput = OmitServerFields<RuleObj>;

export interface CampaignMetadata {
  goal?: string;
  goal_description?: string;
}

export interface Campaign extends Record<string, any> {
  id: number;
  created_at: string;
  updated_at: string;
  name?: string;
  description?: string;
  request_tag_name?: RequestTag;
  request_tag_value?: string;
  start_time?: string;
  end_time?: string;
  refined_queries?: RefinedQuery[];
  refined_filters?: RefinedFilter[];
  refined_recommendation_contexts?: RecommendationContext[];
  boost_rules?: BoostRule[];
  blacklist_rules?: BlacklistRule[];
  slot_rules?: SlotRule[];
  content_rules?: ContentRule[];
  filters_slot_rules?: FiltersSlotRule[];
  whitelist_rule?: WhitelistRule;
  variation_slicing_rule?: VariationSlicingRule;
  metadata_json?: CampaignMetadata;
}

/* campaigns results returned from server */
export interface CampaignListGetResponse {
  campaigns: Campaign[];
  total_count: number;
}

/* single campaign result returned from server */
export type CampaignGetResponse = Campaign;

/* campaign result returned from server after creation */
export type CampaignPostResponse = Campaign;

/* campaign result returned from server after update */
export type CampaignPatchResponse = Campaign;