/**
 * Formes rendues par l'API, cote WordPress.
 *
 * Elles sont volontairement recopiees plutot qu'importees de `@ocl/core`: ce paquet est compile en
 * CommonJS pour le serveur, et le faire entrer dans un bundle navigateur casse la page (lecon du
 * 2026-09-17 sur l'app Shopify). Ce qui doit rester d'accord, ce sont les identifiants de statut,
 * et un test les compare aux valeurs ecrites par le serveur.
 */

export type OnboardingStepId =
  | 'connect_store'
  | 'link_ads_account'
  | 'activate_tracking'
  | 'first_event'
  | 'sync_catalog'
  | 'describe_store'
  | 'deliver_catalog'
  | 'go_live';

export type OnboardingStepStatus =
  'todo' | 'in_progress' | 'done' | 'error' | 'skipped' | 'locked' | 'unavailable';

export interface OnboardingStep {
  id: OnboardingStepId;
  status: OnboardingStepStatus;
  reason?: string | null;
}

export interface ShopStatus {
  state: {
    phase: string;
    steps: OnboardingStep[];
    nextStep: OnboardingStepId | null;
    doneCount: number;
    totalCount: number;
  };
  metrics: {
    /** `null` quand l'offre n'ouvre pas l'attribution. */
    attributedRevenue: number | null;
    attributedOrders: number;
    totalOrders: number;
    openAlerts: number;
    productsCount: number;
    /** Variantes (articles du flux). Absent tant que l'API deployee est plus ancienne. */
    variantsCount?: number;
    events30d: number;
  };
  /**
   * Instantane qui a servi au calcul des etapes. L'accueil n'en lit que la description de la
   * boutique, pour dire QUELLE information manque au lieu de « le nom ou les pays ».
   */
  snapshot?: {
    testMode?: boolean;
    feed?: {
      configured?: boolean;
      sellerName: string | null;
      targetCountries: string[];
      /** Marque par defaut enregistree. */
      hasDefaultBrand?: boolean;
      /** Produits actifs sans marque: sans marque par defaut, chacun est ecarte du flux. */
      productsWithoutBrand?: number;
    };
  };
}

export type ConsentPosture = 'granted' | 'banner' | 'none' | 'denied';

export interface Shop {
  domain: string;
  testMode: boolean;
  /** Posture de consentement declaree par le marchand. Voir `ConsentPosture` de @ocl/tracking. */
  consentPosture: ConsentPosture;
  currency: string;
  credentials: {
    pixelId: string | null;
    validationStatus: string;
    /** Une cle Conversions est enregistree (sa valeur n'est jamais renvoyee). */
    hasCapiToken?: boolean;
    /** Une cle Ads Manager (Advertiser API) est enregistree (valeur jamais renvoyee). */
    hasAdsApiKey?: boolean;
  };
}

export interface FeedConfig {
  configured: boolean;
  /** Produits actifs sans marque: sans marque par defaut, chacun est ecarte du flux. */
  productsWithoutBrand?: number;
  /** Cle ChatGPT Ads enregistree: sans elle, le flux ne peut pas etre cree chez OpenAI. */
  hasAdsKey?: boolean;
  knownBrands?: string[];
  /** Collections ou categories presentes dans le catalogue, pour le choix de la publicite. */
  knownCollections?: { id: string; title: string }[];
  /** Collections diffusees en publicite. Vide = tout le catalogue. */
  adsCollections?: string[];
  sellerName?: string | null;
  targetCountries?: string[];
  defaultBrand?: string | null;
  /** Etat des produits et systeme de taille, declares une fois pour la boutique. */
  condition?: string | null;
  sizeSystem?: string | null;
  /** Retours: `null` veut dire « pas declare », ce qui n'est pas « je refuse ». */
  acceptsReturns?: boolean | null;
  returnPolicyUrl?: string | null;
  returnDeadlineDays?: number | null;
  eligibleSearch?: boolean;
  adsEligible?: boolean;
  format?: string;
  scheduleHourUtc?: number | null;
  sftpConfigured?: boolean;
  openaiFeedId?: string | null;
  openaiFeedCountries?: string[];
  openaiFeedError?: string | null;
  /** Dernier controle d'acces du robot d'OpenAI aux images et pages livrees (NULL avant). */
  crawlerCheck?: { checkedAt: string; sampled: number; ok: number; refused: number } | null;
}

export interface FeedRun {
  id: string;
  kind: string;
  status: string;
  itemsTotal: number;
  itemsValid: number;
  itemsRejected: number;
  /** Articles valides laisses de cote faute de place dans l'offre. */
  itemsOverQuota: number;
  added?: number;
  removed?: number;
  changed?: number;
  deliveryStatus: string;
  /** Livraison reportee: heure a laquelle elle repart (ISO). */
  deliverAfter?: string | null;
  /** Envoi complet quotidien d'un contenu identique au dernier envoi (calcule par l'API). */
  dailyRefresh?: boolean;
  deliveryError: string | null;
  openaiStatus: string | null;
  rowsAccepted: number | null;
  rowsRejected: number | null;
  errors: { itemId: string; errors: { field: string; code?: string; message: string }[] }[] | null;
  /** Nombre exact de variantes par motif, sur tout le passage. Absent des passages anciens. */
  rejectionCounts?: { field: string; code?: string; message: string; count: number }[] | null;
  startedAt: string;
}

export type OpenAiFeed =
  | { ok: false; reason: string; detail?: string }
  | {
      ok: true;
      feedId: string;
      countries: string[];
      productCount: number | null;
      totalCount: number;
      matchedCount: number;
      products: Record<string, unknown>[];
    };

export type DashboardHighlight =
  | { kind: 'revenue_up' | 'revenue_down'; changeRatio: number }
  | { kind: 'revenue_flat' }
  | { kind: 'first_revenue' }
  | { kind: 'no_attributed_yet' }
  | { kind: 'no_orders_yet' };

/** Offre sans le module: ce que l'ecran dit a la place (voir `PlanLocked`). */
export interface PlanLockedInfo {
  locked: true;
  upgradeTo: string | null;
  trialDays: number;
}

export type DashboardResponse =
  Dashboard | (PlanLockedInfo & { attributedOrders: number; chatGptVisits?: number });

export interface Dashboard {
  locked?: false;
  currency: string;
  highlight: DashboardHighlight;
  totalRevenue: number;
  previous: {
    attributedRevenue: number;
    attributedOrders: number;
    totalRevenue: number;
    totalOrders: number;
    spend: number;
  };
  attributedRevenue: number;
  attributedOrders: number;
  totalOrders: number;
  adsRevenue: number;
  organicRevenue: number;
  spend: number;
  impressions: number;
  clicks: number;
  roas: number | null;
  topProducts: { id: string; title: string; quantity: number; revenue: number }[];
  daily: { date: string; revenue: number; orders: number; spend: number }[];
  /**
   * Trafic reellement venu de ChatGPT sur la MEME periode que le chiffre d'affaires ci-dessus.
   * Capte cote serveur, donc insensible aux bloqueurs de publicite.
   */
  traffic: {
    totalVisits: number;
    fromAds: number;
    landings: { path: string; visits: number; fromAds: number }[];
  };
}

export type AlertsResponse = { alerts: Alert[] } & ({ locked?: false } | PlanLockedInfo);

export interface Alert {
  id: string;
  type: string;
  severity: string;
  /** Phrase anglaise du serveur: repli seulement, jamais le premier choix. */
  message: string;
  params?: Record<string, string | number> | null;
  status: string;
  createdAt: string;
}

export interface NotificationSettings {
  email: string | null;
  alertsEnabled: boolean;
  weeklyReport: boolean;
}

export interface EventRow {
  id: string;
  eventId: string;
  type: string;
  source: string;
  status: string;
  test: boolean;
  occurredAt: string;
  createdAt?: string;
  sentAt?: string | null;
  /** Motif d'un echec, en identifiant: `no_credentials`, `key_refused`, `rejected_by_openai`... */
  reason?: string | null;
  /** Commandes: copies recues sous le meme identifiant (navigateur, serveur ou les deux). */
  copies?: ('browser' | 'server')[] | null;
}

export interface EventsResponse {
  events: EventRow[];
  /** Mode test ACTUEL de la boutique. */
  testMode?: boolean;
  /** Etat du suivi: rien de relie, cle refusee, ou relie. */
  tracking?: 'missing' | 'refused' | 'connected';
  /** OpenAI a accepte les identifiants: le mode test peut etre coupe. */
  canGoLive?: boolean;
}

export interface ProductScore {
  externalId: string;
  title: string;
  score: number;
  valid: boolean;
  /** Actions priorisees renvoyees par l'API: `code` traduit, `message` en repli. */
  actions: {
    field: string;
    gain: number;
    code: string;
    message: string;
    params?: Record<string, string | number>;
  }[];
  /** `null` veut dire « OpenAI ne nous a rien dit », ce qui n'est pas « zero impression ». */
  impressions: number | null;
  /** SKU de la premiere variante qui en a un: distingue deux fiches au meme titre. */
  reference?: string | null;
}

export interface ProductScores {
  products: ProductScore[];
  /** Vrai quand OpenAI n'a partage aucune exposition par produit pour ce compte. */
  adsMetricsMissing: boolean;
  /** Aucune cle Ads Manager: les impressions ne viendront pas sans elle. */
  adsKeyMissing?: boolean;
  /** Produits actifs notes sur tout le catalogue (absent sur une API plus ancienne). */
  total?: number;
  /** Produits pas encore envoyables (nos controles avant envoi, pas un verdict d'OpenAI). */
  refused?: number;
  /** Variantes de ces produits: le pont avec les articles comptes par l'ecran Flux produit. */
  refusedItems?: number;
  offset?: number;
  limit?: number;
}

export interface ProductPerformance {
  productExternalId: string;
  variantExternalId: string;
  title: string;
  currency: string | null;
  spendCurrency: string | null;
  revenue: number | null;
  spend: number | null;
  units: number | null;
  /** Nom du champ renvoye par l'API; `units` reste pour les reponses anterieures. */
  unitsSold?: number | null;
  grossMargin: number | null;
  netMargin: number | null;
  roas: number | null;
  inventoryQuantity: number | null;
  currencyMismatch: boolean;
}

/** Offres et etat d'abonnement. Les montants viennent du catalogue partage, jamais d'ici. */
export interface BillingPlan {
  key: 'free' | 'growth' | 'scale';
  monthlyUsd: number;
  yearlyUsd: number;
  trialDays: number;
  limits: {
    feedItems: number | null;
    shops: number;
    attribution: boolean;
    alerts: boolean;
    visibility: boolean;
    /** Questions suivies par le panel de visibilite (0 quand le module est ferme). */
    visibilityPrompts?: number;
  };
  isCurrent: boolean;
}

export interface Billing {
  current: {
    plan: 'free' | 'growth' | 'scale' | 'agency';
    interval: 'monthly' | 'yearly';
    status: string;
    channel: string | null;
    trialEndsAt: string | null;
    currentPeriodEnd: string | null;
    trialing: boolean;
  };
  plans: BillingPlan[];
  quota: { allowed: boolean; limit: number | null; used: number; upgradeTo: string | null };
}

/** Apercu de la fiche telle qu'OpenAI la recoit: les champs reellement envoyes, pas une imitation. */
export interface FeedPreview {
  found: boolean;
  productExternalId?: string;
  title?: string;
  items?: {
    item: Record<string, unknown>;
    valid: boolean;
    errors: {
      field: string;
      code?: string;
      message: string;
      params?: Record<string, string | number>;
    }[];
  }[];
}

/**
 * Panel de visibilite: ce qu'un modele OpenAI avec recherche web repond a une question d'acheteur.
 *
 * Ce n'est pas le carrousel produit de ChatGPT. L'ecran le dit, parce que laisser croire le
 * contraire serait plus grave que de ne rien mesurer.
 */
export interface VisibilityPanel {
  windowDays: number;
  /** Le palier ouvre-t-il le module. */
  enabled: boolean;
  upgradeTo: string | null;
  /** Essai gratuit du palier qui ouvre le module, en jours. */
  trialDays?: number;
  /** La prochaine verification hebdomadaire peut tourner a partir de cette date. */
  nextCheckAfter?: string | null;
  plan: string;
  promptLimit: number;
  /** Une cle de plateforme est-elle configuree: sans elle, aucune vague ne tourne. */
  configured: boolean;
  prompts: {
    id: string;
    text: string;
    country: string;
    measures: number;
    /** `null` tant que l'echantillon est trop petit pour qu'un pourcentage veuille dire quelque chose. */
    citationRate: number | null;
    bestRank: number | null;
    lastRunAt: string | null;
  }[];
  competitors: { domain: string; mentions: number }[];
  measures: number;
  minMeasures: number;
}

/**
 * Copilote, etape 2: campagnes et groupes d'annonces, lus EN DIRECT chez OpenAI.
 *
 * Aucun cache: le marchand modifie aussi ses campagnes depuis Ads Manager, et une enchere perimee
 * affichee au moment ou il decide de la changer est pire que pas d'affichage du tout.
 */
export interface AdsOverview {
  configured: boolean;
  reason?: string;
  detail?: string;
  currency: string | null;
  campaigns: {
    id: string;
    name: string | null;
    status: string | null;
    /** Objectif de la campagne : `impressions`, `clicks` ou `conversions`. */
    objective?: string | null;
    adGroups: {
      id: string;
      name: string | null;
      status: string | null;
      /** Strategie d'enchere rendue par OpenAI, affichee seulement (reglee dans Ads Manager). */
      bidStrategy?: string | null;
      /** Enchere fixe dans la devise du compte. `null` hors enchere fixe. */
      maxBid: number | null;
      billingEventType: string | null;
      productSetSize: number | null;
    }[];
  }[];
}

/** Ce que le copilote propose de diffuser, et ce qu'il refuse de decider seul. */
export interface ProductSetSuggestion {
  window: number;
  itemIds: string[];
  /** Nombre d'articles gardes sur le catalogue entier. `itemIds` est vide quand `truncated`. */
  kept: number;
  losing: { itemId: string; title: string; netMargin: number | null; spend: number }[];
  /** Articles diffuses dont la marge est INCONNUE: gardes, mais le marchand doit le savoir. */
  unknown: { itemId: string; title: string; netMargin: number | null; spend: number }[];
  /** Vrai quand la liste depasse le plafond: l'action est alors refusee, pas reduite. */
  truncated: boolean;
}

/** Garde-fou. `enabled` vaut faux tant que le marchand ne l'a pas allume lui-meme. */
export interface CopilotRule {
  kind: 'profitable_products_only';
  enabled: boolean;
  config: Record<string, unknown>;
  lastRunAt: string | null;
}

/** Journal: rien n'est applique sans etre ecrit ici, declenchements automatiques compris. */
export interface CopilotActionRow {
  id: string;
  kind: string;
  targetExternalId: string;
  status: string;
  detail: string | null;
  source: string;
  createdAt: string;
}

/** Groupe de boutiques d'une offre Scale (voir docs/adr/0006-groupes-de-boutiques.md). */
export interface StoreGroup {
  role: 'billing' | 'covered' | 'none';
  plan: string | null;
  active: boolean;
  coveredBy: { domain: string; plan: string } | null;
  members: { domain: string; platform: string }[];
  seats: { used: number; limit: number } | null;
}

export type StoreGroupResult =
  | { ok: true; code?: string; expiresAt?: string; billingDomain?: string }
  | { ok: false; reason?: string };
