/**
 * Typed wrappers around every ``/api/visibility/*`` endpoint on the agent
 * backend. Each function unwraps the standard ``BaseResponse`` envelope so
 * callers receive the ``data`` payload directly.
 *
 * HTTP calls go through {@link BaseAgentService}, which owns its own axios
 * instance - no global interceptors, so 403s don't trigger the session
 * refresh modal that the main Recomaze axios instance wires up.
 */

import type { AxiosError } from 'axios';

import BaseAgentService from '../BaseAgentService';

import type {
  AdoptFromChatRequest,
  AdoptFromChatResponse,
  StopTrackingChatRequest,
  StopTrackingChatResponse,
  ArticleDeleteResponse,
  ArticleAeoChecklistResponse,
  ArticleDetailResponse,
  ArticleDispatchResponse,
  ArticleEditRequest,
  ArticleGenerateRequest,
  ArticleListResponse,
  ArticleRegenerateRequest,
  ArticleVersionDetailResponse,
  ArticleVersionsResponse,
  BrandCreateRequest,
  BrandListResponse,
  BrandResponse,
  BrandUpdateRequest,
  StoreContextResponse,
  StoreContextEditRequest,
  BulkGenerateRequest,
  BulkJobResponse,
  ChatPromptVolumesResponse,
  CitedSourcesResponse,
  CompetitorLeaderboardResponse,
  FunnelCoverageResponse,
  ManualCompetitorAddRequest,
  ManualCompetitorListResponse,
  ExcludedCompetitorAddRequest,
  ExcludedCompetitorListResponse,
  GenerateSuggestionsFromBriefRequest,
  PageTemplate,
  PageTemplateCreateRequest,
  PageTemplateListResponse,
  PageTemplatePreset,
  PageTemplatePresetListResponse,
  PageTemplateUpdateRequest,
  ProblemsResponse,
  PromptListResponse,
  PromptMetricsResponse,
  PromptReplaceRequest,
  PromptResponse,
  PromptUpdateRequest,
  PromptResponsesResponse,
  ArticlePromptImpactResponse,
  RefreshSuggestionsRequest,
  ScanDispatchResponse,
  ScanHistoryResponse,
  ScanTriggerRequest,
  SuggestionEntry,
  SuggestionListResponse,
  VisibilityBaseResponse,
  VisibilitySettingsResponse,
  VisibilitySettingsUpdateRequest,
  WeeklyReportResponse,
} from './visibility.interface';
import { InsufficientCreditsError } from './visibility.interface';
import {
  VISIBILITY_ARTICLES,
  VISIBILITY_ARTICLES_BULK,
  VISIBILITY_ARTICLES_GENERATE,
  VISIBILITY_BRANDS,
  VISIBILITY_PAGE_TEMPLATE_PRESETS,
  VISIBILITY_SETTINGS,
  visibilityArticle,
  visibilityArticleAeoChecklist,
  visibilityArticlePublish,
  visibilityArticlePublishToBlog,
  visibilityArticleRegenerate,
  visibilityArticlesBulkJob,
  visibilityArticleUnpublish,
  visibilityArticleVersion,
  visibilityArticleVersions,
  visibilityBrand,
  visibilityBrandStoreContext,
  visibilityBrandStoreContextRegenerate,
  visibilityBrandAdoptFromChat,
  visibilityBrandStopTrackingChat,
  visibilityBrandChatVolumes,
  visibilityBrandCitedSources,
  visibilityBrandCompetitors,
  visibilityBrandFunnelCoverage,
  visibilityBrandProblems,
  visibilityBrandPromptMetrics,
  visibilityBrandPrompts,
  visibilityBrandPromptsRegenerate,
  visibilityArticlePromptImpact,
  visibilityPrompt,
  visibilityPromptRegenerate,
  visibilityBrandReport,
  visibilityBrandScan,
  visibilityBrandScans,
  visibilityBrandSuggestion,
  visibilityBrandSuggestions,
  visibilityBrandSuggestionsFromBrief,
  visibilityBrandSuggestionsRefresh,
  visibilityPageTemplate,
  visibilityPageTemplates,
  visibilityPromptResponses,
  visibilityTrackedCompetitor,
  visibilityTrackedCompetitors,
  visibilityExcludedCompetitor,
  visibilityExcludedCompetitors,
} from './visibility.routes';

const unwrap = <T>(response: VisibilityBaseResponse<T>): T => response.data;

const throwAgentError = (err: unknown, fallback: string): never => {
  const axiosErr = err as AxiosError<Record<string, unknown>> | undefined;
  if (!axiosErr?.isAxiosError) {
    throw err;
  }

  const status = axiosErr.response?.status;
  const body = axiosErr.response?.data;
  const pick = (key: string): string | undefined =>
    typeof body?.[key] === 'string' ? (body[key] as string) : undefined;
  const serverMessage =
    pick('message') || pick('detail') || pick('error') || fallback;

  if (status === 402) {
    throw new InsufficientCreditsError(serverMessage);
  }

  throw new Error(serverMessage);
};

/* ------------------------------------------------------------------ */
/* settings                                                           */
/* ------------------------------------------------------------------ */

export const fetchSettings = async (
  clientId: string,
  token: string
): Promise<VisibilitySettingsResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<VisibilitySettingsResponse>
  >(VISIBILITY_SETTINGS, clientId, token);

  return unwrap(response);
};

export const updateSettings = async (
  clientId: string,
  token: string,
  body: VisibilitySettingsUpdateRequest
): Promise<VisibilitySettingsResponse> => {
  const response = await BaseAgentService.putWithClientId<
    VisibilityBaseResponse<VisibilitySettingsResponse>
  >(VISIBILITY_SETTINGS, body, clientId, token);

  return unwrap(response);
};

/* ------------------------------------------------------------------ */
/* brands                                                             */
/* ------------------------------------------------------------------ */

export const listBrands = async (
  clientId: string,
  token: string
): Promise<BrandListResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<BrandListResponse>
  >(VISIBILITY_BRANDS, clientId, token);

  return unwrap(response);
};

export const createBrand = async (
  clientId: string,
  token: string,
  body: BrandCreateRequest
): Promise<BrandResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<BrandResponse>
  >(VISIBILITY_BRANDS, body, clientId, token);

  return unwrap(response);
};

export const getBrand = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<BrandResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<BrandResponse>
  >(visibilityBrand(brandId), clientId, token);

  return unwrap(response);
};

export const patchBrand = async (
  clientId: string,
  token: string,
  brandId: string,
  body: BrandUpdateRequest
): Promise<BrandResponse> => {
  const response = await BaseAgentService.patchWithClientId<
    VisibilityBaseResponse<BrandResponse>
  >(visibilityBrand(brandId), body, clientId, token);

  return unwrap(response);
};

export const getStoreContext = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<StoreContextResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<StoreContextResponse>
  >(visibilityBrandStoreContext(brandId), clientId, token);
  return unwrap(response);
};

export const editStoreContext = async (
  clientId: string,
  token: string,
  brandId: string,
  body: StoreContextEditRequest
): Promise<StoreContextResponse> => {
  const response = await BaseAgentService.putWithClientId<
    VisibilityBaseResponse<StoreContextResponse>
  >(visibilityBrandStoreContext(brandId), body, clientId, token);
  return unwrap(response);
};

export const regenerateStoreContext = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<StoreContextResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<StoreContextResponse>
  >(visibilityBrandStoreContextRegenerate(brandId), {}, clientId, token);
  return unwrap(response);
};

/* ------------------------------------------------------------------ */
/* scans                                                              */
/* ------------------------------------------------------------------ */

/**
 * Dispatch a fresh scan. The backend returns ``402`` when the merchant has
 * run out of credits. We detect that case and throw a typed
 * {@link InsufficientCreditsError} so the UI can render a friendly warning
 * banner.
 */
export const startScan = async (
  clientId: string,
  token: string,
  brandId: string,
  body: ScanTriggerRequest = {}
): Promise<ScanDispatchResponse> => {
  const result = await BaseAgentService.probePostWithClientId<
    VisibilityBaseResponse<ScanDispatchResponse>
  >(visibilityBrandScan(brandId), body, clientId, token);

  if (result.ok && result.data) {
    return unwrap(result.data);
  }

  if (result.status === 402) {
    throw new InsufficientCreditsError();
  }

  throw new Error(
    `Failed to start scan (status ${result.status || 'network'}).`
  );
};

export const listScans = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<ScanHistoryResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ScanHistoryResponse>
  >(visibilityBrandScans(brandId), clientId, token);

  return unwrap(response);
};

export const getWeeklyReport = async (
  clientId: string,
  token: string,
  brandId: string,
  weekIso: string
): Promise<WeeklyReportResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<WeeklyReportResponse>
  >(visibilityBrandReport(brandId, weekIso), clientId, token);

  return unwrap(response);
};

/* ------------------------------------------------------------------ */
/* competitors                                                        */
/* ------------------------------------------------------------------ */

export const getCompetitors = async (
  clientId: string,
  token: string,
  brandId: string,
  weekIso?: string,
  limit = 50
): Promise<CompetitorLeaderboardResponse> => {
  const params = new URLSearchParams();
  if (weekIso) params.set('week_iso', weekIso);
  params.set('limit', String(limit));
  const url = `${visibilityBrandCompetitors(brandId)}?${params.toString()}`;
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<CompetitorLeaderboardResponse>
  >(url, clientId, token);

  return unwrap(response);
};

export const listTrackedCompetitors = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<ManualCompetitorListResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ManualCompetitorListResponse>
  >(visibilityTrackedCompetitors(brandId), clientId, token);

  return unwrap(response);
};

export const addTrackedCompetitor = async (
  clientId: string,
  token: string,
  brandId: string,
  body: ManualCompetitorAddRequest
): Promise<ManualCompetitorListResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<ManualCompetitorListResponse>
  >(visibilityTrackedCompetitors(brandId), body, clientId, token);

  return unwrap(response);
};

export const removeTrackedCompetitor = async (
  clientId: string,
  token: string,
  brandId: string,
  competitorDomain: string
): Promise<ManualCompetitorListResponse> => {
  const response = await BaseAgentService.deleteWithClientId<
    VisibilityBaseResponse<ManualCompetitorListResponse>
  >(visibilityTrackedCompetitor(brandId, competitorDomain), clientId, token);

  return unwrap(response);
};

/**
 * Suppress a competitor domain from the leaderboard and skip it on future
 * scans. Idempotent - re-excluding the same domain returns the existing
 * list unchanged.
 *
 * @param {string} clientId - Recomaze client id used for agent-backend auth.
 * @param {string} token - Recomaze auth token used for agent-backend auth.
 * @param {string} brandId - Target brand id.
 * @param {ExcludedCompetitorAddRequest} body - Domain to exclude.
 * @returns {Promise<ExcludedCompetitorListResponse>} Updated excluded-domains list.
 */
export const excludeCompetitor = async (
  clientId: string,
  token: string,
  brandId: string,
  body: ExcludedCompetitorAddRequest
): Promise<ExcludedCompetitorListResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<ExcludedCompetitorListResponse>
  >(visibilityExcludedCompetitors(brandId), body, clientId, token);

  return unwrap(response);
};

/**
 * Bring a previously excluded competitor back into the leaderboard.
 *
 * @param {string} clientId - Recomaze client id used for agent-backend auth.
 * @param {string} token - Recomaze auth token used for agent-backend auth.
 * @param {string} brandId - Target brand id.
 * @param {string} competitorDomain - Canonical competitor domain.
 * @returns {Promise<ExcludedCompetitorListResponse>} Updated excluded-domains list.
 */
export const unexcludeCompetitor = async (
  clientId: string,
  token: string,
  brandId: string,
  competitorDomain: string
): Promise<ExcludedCompetitorListResponse> => {
  const response = await BaseAgentService.deleteWithClientId<
    VisibilityBaseResponse<ExcludedCompetitorListResponse>
  >(visibilityExcludedCompetitor(brandId, competitorDomain), clientId, token);

  return unwrap(response);
};

/* ------------------------------------------------------------------ */
/* prompts                                                            */
/* ------------------------------------------------------------------ */

export const listPrompts = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<PromptListResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<PromptListResponse>
  >(visibilityBrandPrompts(brandId), clientId, token);

  return unwrap(response);
};

/**
 * Per-prompt composite-score trends for a brand's prompt list (Beta).
 *
 * @param {string} clientId - Recomaze client id used for agent-backend auth.
 * @param {string} token - Recomaze auth token used for agent-backend auth.
 * @param {string} brandId - Target brand id.
 * @returns {Promise<PromptMetricsResponse>} One trend per tracked prompt.
 */
export const getPromptMetrics = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<PromptMetricsResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<PromptMetricsResponse>
  >(visibilityBrandPromptMetrics(brandId), clientId, token);

  return unwrap(response);
};

export const updatePrompts = async (
  clientId: string,
  token: string,
  brandId: string,
  body: PromptReplaceRequest
): Promise<PromptListResponse> => {
  const response = await BaseAgentService.putWithClientId<
    VisibilityBaseResponse<PromptListResponse>
  >(visibilityBrandPrompts(brandId), body, clientId, token);

  return unwrap(response);
};

/**
 * Regenerate the whole prompt set from a fresh live-site crawl. The backend
 * re-reads what the brand actually sells (grounded) and rebuilds the 16
 * prompts, optionally steered by a corrected business type and free-text
 * guidance. The old set is disabled, not deleted.
 *
 * @param clientId {string} Recomaze client id.
 * @param token {string} Recomaze auth token.
 * @param brandId {string} Target brand id.
 * @param body {{ custom_guidance?: string; business_type?: string }} Optional
 *   steer: what the brand sells / corrected business type.
 * @returns {Promise<PromptListResponse>} The freshly generated prompt list.
 */
export const regeneratePrompts = async (
  clientId: string,
  token: string,
  brandId: string,
  body?: { custom_guidance?: string; business_type?: string }
): Promise<PromptListResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<PromptListResponse>
  >(visibilityBrandPromptsRegenerate(brandId), body ?? {}, clientId, token);

  return unwrap(response);
};

export const updatePrompt = async (
  clientId: string,
  token: string,
  brandId: string,
  promptId: string,
  body: PromptUpdateRequest
): Promise<PromptResponse> => {
  const response = await BaseAgentService.patchWithClientId<
    VisibilityBaseResponse<PromptResponse>
  >(visibilityPrompt(brandId, promptId), body, clientId, token);

  return unwrap(response);
};

/**
 * Permanently remove a single tracked prompt.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param brandId {string} Target brand id.
 * @param promptId {string} Prompt id to delete.
 * @returns {Promise<PromptListResponse>} Remaining tracked prompts.
 */
export const deletePrompt = async (
  clientId: string,
  token: string,
  brandId: string,
  promptId: string
): Promise<PromptListResponse> => {
  const response = await BaseAgentService.deleteWithClientId<
    VisibilityBaseResponse<PromptListResponse>
  >(visibilityPrompt(brandId, promptId), clientId, token);

  return unwrap(response);
};

/**
 * Regenerate a single tracked prompt with the LLM, keeping its category. An
 * optional free-text instruction steers the rewrite. The backend anchors it to
 * the brand's other prompts so it stays on-catalog, and persists the result.
 *
 * @param clientId {string} Recomaze client id.
 * @param token {string} Recomaze auth token.
 * @param brandId {string} Target brand id.
 * @param promptId {string} Prompt id to rewrite.
 * @param body {{ instruction?: string }} Optional rewrite instruction.
 * @returns {Promise<PromptResponse>} The regenerated prompt row.
 */
export const regeneratePrompt = async (
  clientId: string,
  token: string,
  brandId: string,
  promptId: string,
  body?: { instruction?: string }
): Promise<PromptResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<PromptResponse>
  >(visibilityPromptRegenerate(brandId, promptId), body ?? {}, clientId, token);

  return unwrap(response);
};

export const getPromptResponses = async (
  clientId: string,
  token: string,
  brandId: string,
  promptId: string
): Promise<PromptResponsesResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<PromptResponsesResponse>
  >(visibilityPromptResponses(brandId, promptId), clientId, token);

  return unwrap(response);
};

/* ------------------------------------------------------------------ */
/* problems & suggestions                                             */
/* ------------------------------------------------------------------ */

export const listProblems = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<ProblemsResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ProblemsResponse>
  >(visibilityBrandProblems(brandId), clientId, token);

  return unwrap(response);
};

export const listSuggestions = async (
  clientId: string,
  token: string,
  brandId: string,
  force: boolean = false
): Promise<SuggestionListResponse> => {
  // force bypasses the 5-min server cache so a poll sees idea cards flip to
  // "generated" as soon as their content is ready.
  const base: string = visibilityBrandSuggestions(brandId);
  const url: string = force ? `${base}?force=true` : base;
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<SuggestionListResponse>
  >(url, clientId, token);

  return unwrap(response);
};

export const refreshSuggestions = async (
  clientId: string,
  token: string,
  brandId: string,
  body: RefreshSuggestionsRequest = {}
): Promise<SuggestionListResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<SuggestionListResponse>
  >(visibilityBrandSuggestionsRefresh(brandId), body, clientId, token);

  return unwrap(response);
};

/**
 * Generate up to five article ideas from a merchant-supplied brief (typed
 * text or pasted txt/csv). The ideas persist as ``source = "user"``
 * suggestions, so {@link generateArticle} works on them unchanged.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param brandId {string} Target brand id.
 * @param body {GenerateSuggestionsFromBriefRequest} Brief text + optional language.
 * @returns {Promise<SuggestionListResponse>} The freshly generated ideas.
 */
export const generateSuggestionsFromBrief = async (
  clientId: string,
  token: string,
  brandId: string,
  body: GenerateSuggestionsFromBriefRequest
): Promise<SuggestionListResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<SuggestionListResponse>
  >(visibilityBrandSuggestionsFromBrief(brandId), body, clientId, token);

  return unwrap(response);
};

export const rejectSuggestion = async (
  clientId: string,
  token: string,
  brandId: string,
  suggestionId: string
): Promise<SuggestionEntry> => {
  const response = await BaseAgentService.deleteWithClientId<
    VisibilityBaseResponse<SuggestionEntry>
  >(visibilityBrandSuggestion(brandId, suggestionId), clientId, token);

  return unwrap(response);
};

/* ------------------------------------------------------------------ */
/* page templates                                                     */
/* ------------------------------------------------------------------ */

/**
 * List a brand's saved page-content briefs, optionally narrowed to one type.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param brandId {string} Target brand id.
 * @param contentType {string} [optional] Page-type filter.
 * @returns {Promise<PageTemplate[]>} The brand's templates, newest update first.
 */
export const listPageTemplates = async (
  clientId: string,
  token: string,
  brandId: string,
  contentType?: string
): Promise<PageTemplate[]> => {
  const base = visibilityPageTemplates(brandId);
  const url = contentType
    ? `${base}?content_type=${encodeURIComponent(contentType)}`
    : base;
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<PageTemplateListResponse>
  >(url, clientId, token);

  return unwrap(response).templates;
};

/**
 * Fetch one saved page-content brief by id.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param brandId {string} Target brand id.
 * @param templateId {string} Template identifier.
 * @returns {Promise<PageTemplate>} The template row.
 */
export const getPageTemplate = async (
  clientId: string,
  token: string,
  brandId: string,
  templateId: string
): Promise<PageTemplate> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<PageTemplate>
  >(visibilityPageTemplate(brandId, templateId), clientId, token);

  return unwrap(response);
};

/**
 * Save a new page-content brief.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param brandId {string} Target brand id.
 * @param body {PageTemplateCreateRequest} The brief to persist.
 * @returns {Promise<PageTemplate>} The created template.
 */
export const createPageTemplate = async (
  clientId: string,
  token: string,
  brandId: string,
  body: PageTemplateCreateRequest
): Promise<PageTemplate> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<PageTemplate>
  >(visibilityPageTemplates(brandId), body, clientId, token);

  return unwrap(response);
};

/**
 * Partially update a saved page-content brief.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param brandId {string} Target brand id.
 * @param templateId {string} Template to edit.
 * @param body {PageTemplateUpdateRequest} Fields to overwrite.
 * @returns {Promise<PageTemplate>} The updated template.
 */
export const updatePageTemplate = async (
  clientId: string,
  token: string,
  brandId: string,
  templateId: string,
  body: PageTemplateUpdateRequest
): Promise<PageTemplate> => {
  const response = await BaseAgentService.patchWithClientId<
    VisibilityBaseResponse<PageTemplate>
  >(visibilityPageTemplate(brandId, templateId), body, clientId, token);

  return unwrap(response);
};

/**
 * Delete a saved page-content brief.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param brandId {string} Target brand id.
 * @param templateId {string} Template to remove.
 * @returns {Promise<void>} Resolves when the row is gone.
 */
export const deletePageTemplate = async (
  clientId: string,
  token: string,
  brandId: string,
  templateId: string
): Promise<void> => {
  await BaseAgentService.deleteWithClientId<
    VisibilityBaseResponse<Record<string, unknown>>
  >(visibilityPageTemplate(brandId, templateId), clientId, token);
};

/**
 * Fetch the global Recomaze-shipped page-template presets, seeded server-side
 * and returned in curated gallery order.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @returns {Promise<PageTemplatePreset[]>} The preset catalog.
 */
export const listPageTemplatePresets = async (
  clientId: string,
  token: string
): Promise<PageTemplatePreset[]> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<PageTemplatePresetListResponse>
  >(VISIBILITY_PAGE_TEMPLATE_PRESETS, clientId, token);

  return unwrap(response).presets;
};

/* ------------------------------------------------------------------ */
/* articles                                                           */
/* ------------------------------------------------------------------ */

export const generateArticle = async (
  clientId: string,
  token: string,
  body: ArticleGenerateRequest
): Promise<ArticleDispatchResponse> => {
  try {
    const response = await BaseAgentService.postWithClientId<
      VisibilityBaseResponse<ArticleDispatchResponse>
    >(VISIBILITY_ARTICLES_GENERATE, body, clientId, token);

    return unwrap(response);
  } catch (err) {
    return throwAgentError(err, 'Failed to start generation.');
  }
};

export const bulkArticles = async (
  clientId: string,
  token: string,
  body: BulkGenerateRequest
): Promise<BulkJobResponse> => {
  try {
    const response = await BaseAgentService.postWithClientId<
      VisibilityBaseResponse<BulkJobResponse>
    >(VISIBILITY_ARTICLES_BULK, body, clientId, token);

    return unwrap(response);
  } catch (err) {
    return throwAgentError(err, 'Failed to start bulk generation.');
  }
};

export const getBulkProgress = async (
  clientId: string,
  token: string,
  jobId: string
): Promise<BulkJobResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<BulkJobResponse>
  >(visibilityArticlesBulkJob(jobId), clientId, token);

  return unwrap(response);
};

export const listArticles = async (
  clientId: string,
  token: string,
  filters: {
    status?: string;
    brand_id?: string;
    language?: string;
    content_type?: string;
    force?: boolean;
    limit?: number;
  } = {}
): Promise<ArticleListResponse> => {
  const params = new URLSearchParams();
  if (filters.status) params.set('status', filters.status);
  if (filters.brand_id) params.set('brand_id', filters.brand_id);
  if (filters.language) params.set('language', filters.language);
  if (filters.content_type) params.set('content_type', filters.content_type);
  if (filters.limit) params.set('limit', String(filters.limit));
  // The content list is cached for 5 min server-side; callers polling a live
  // generation pass force to bypass it so a freshly-ready content shows up.
  if (filters.force) params.set('force', 'true');
  const query = params.toString();
  const url = query ? `${VISIBILITY_ARTICLES}?${query}` : VISIBILITY_ARTICLES;
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ArticleListResponse>
  >(url, clientId, token);

  return unwrap(response);
};

export const getArticle = async (
  clientId: string,
  token: string,
  articleId: string
): Promise<ArticleDetailResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ArticleDetailResponse>
  >(visibilityArticle(articleId), clientId, token);

  return unwrap(response);
};

/**
 * Per-prompt visibility impact for one article (Beta). Returns, for each
 * targeted prompt, the composite score before publish vs the latest week so
 * the merchant can gauge whether the content moved visibility.
 *
 * @param {string} clientId - Recomaze client id used for agent-backend auth.
 * @param {string} token - Recomaze auth token used for agent-backend auth.
 * @param {string} articleId - Target article id.
 * @returns {Promise<ArticlePromptImpactResponse>} Per-prompt impact payload.
 */
export const getArticlePromptImpact = async (
  clientId: string,
  token: string,
  articleId: string
): Promise<ArticlePromptImpactResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ArticlePromptImpactResponse>
  >(visibilityArticlePromptImpact(articleId), clientId, token);

  return unwrap(response);
};

export const patchArticle = async (
  clientId: string,
  token: string,
  articleId: string,
  body: ArticleEditRequest
): Promise<ArticleDetailResponse> => {
  const response = await BaseAgentService.patchWithClientId<
    VisibilityBaseResponse<ArticleDetailResponse>
  >(visibilityArticle(articleId), body, clientId, token);

  return unwrap(response);
};

/**
 * Mark a ``ready`` article as ``published``. Stamps ``published_at`` on
 * the row so the per-week grouping in the UI can bucket it.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param articleId {string} Target article id.
 * @returns {Promise<ArticleDetailResponse>} Article detail with the new status.
 */
export const publishArticle = async (
  clientId: string,
  token: string,
  articleId: string
): Promise<ArticleDetailResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<ArticleDetailResponse>
  >(visibilityArticlePublish(articleId), {}, clientId, token);

  return unwrap(response);
};

/**
 * Publish a ready article to the store blog in the background, optionally
 * generating and embedding AI images first (25 credits each).
 *
 * @param {string} clientId - Merchant client id.
 * @param {string} token - Merchant JWT.
 * @param {string} articleId - Article identifier.
 * @param {boolean} generateImages - Also generate and embed AI images.
 * @returns {Promise<{ queued: boolean; with_images: boolean }>} Queued ack.
 */
export const publishArticleToBlog = async (
  clientId: string,
  token: string,
  articleId: string,
  generateImages: boolean
): Promise<{ queued: boolean; with_images: boolean }> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<{ queued: boolean; with_images: boolean }>
  >(
    visibilityArticlePublishToBlog(articleId),
    { generate_images: generateImages },
    clientId,
    token
  );

  return unwrap(response);
};

/**
 * Revert a ``published`` article back to ``ready`` (clears ``published_at``).
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param articleId {string} Target article id.
 * @returns {Promise<ArticleDetailResponse>} Article detail with the reset status.
 */
export const unpublishArticle = async (
  clientId: string,
  token: string,
  articleId: string
): Promise<ArticleDetailResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<ArticleDetailResponse>
  >(visibilityArticleUnpublish(articleId), {}, clientId, token);

  return unwrap(response);
};

/**
 * Hard-delete a generated article and all its version history.
 *
 * @param clientId {string} Recomaze client id used for agent-backend auth.
 * @param token {string} Recomaze auth token used for agent-backend auth.
 * @param articleId {string} Target article id.
 * @returns {Promise<ArticleDeleteResponse>} Deleted article id + version count.
 */
export const deleteArticle = async (
  clientId: string,
  token: string,
  articleId: string
): Promise<ArticleDeleteResponse> => {
  const response = await BaseAgentService.deleteWithClientId<
    VisibilityBaseResponse<ArticleDeleteResponse>
  >(visibilityArticle(articleId), clientId, token);

  return unwrap(response);
};

/**
 * Dispatch regeneration of an existing article (creates a new version).
 *
 * The optional ``body.instructions`` is a free-form merchant directive
 * passed straight to the LLM as the highest-priority constraint -
 * e.g. "rewrite as a listicle", "shift to a casual tone", "keep current
 * article but don't use the word X".
 */
export const regenerateArticle = async (
  clientId: string,
  token: string,
  articleId: string,
  body?: ArticleRegenerateRequest
): Promise<ArticleDispatchResponse> => {
  try {
    const response = await BaseAgentService.postWithClientId<
      VisibilityBaseResponse<ArticleDispatchResponse>
    >(visibilityArticleRegenerate(articleId), body ?? {}, clientId, token);

    return unwrap(response);
  } catch (err) {
    return throwAgentError(err, 'Failed to start regeneration.');
  }
};

export const getArticleVersions = async (
  clientId: string,
  token: string,
  articleId: string
): Promise<ArticleVersionsResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ArticleVersionsResponse>
  >(visibilityArticleVersions(articleId), clientId, token);

  return unwrap(response);
};

export const getArticleVersion = async (
  clientId: string,
  token: string,
  articleId: string,
  versionId: string
): Promise<ArticleVersionDetailResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ArticleVersionDetailResponse>
  >(visibilityArticleVersion(articleId, versionId), clientId, token);

  return unwrap(response);
};

/* ------------------------------------------------------------------ */
/* chat-prompt mining                                                 */
/* ------------------------------------------------------------------ */

export const getChatPromptVolumes = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<ChatPromptVolumesResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ChatPromptVolumesResponse>
  >(visibilityBrandChatVolumes(brandId), clientId, token);

  return unwrap(response);
};

export const adoptFromChat = async (
  clientId: string,
  token: string,
  brandId: string,
  body: AdoptFromChatRequest
): Promise<AdoptFromChatResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<AdoptFromChatResponse>
  >(visibilityBrandAdoptFromChat(brandId), body, clientId, token);

  return unwrap(response);
};

/**
 * Reverse of {@link adoptFromChat}: permanently delete the tracked AI-search
 * prompt that was previously promoted from a chat theme and clear the
 * theme's tracking pointer.
 *
 * @param {string} clientId - Recomaze client id used for agent-backend auth.
 * @param {string} token - Recomaze auth token used for agent-backend auth.
 * @param {string} brandId - Target brand id.
 * @param {StopTrackingChatRequest} body - Theme ids whose tracked prompt to delete.
 * @returns {Promise<StopTrackingChatResponse>} Per-theme untrack result.
 */
export const stopTrackingFromChat = async (
  clientId: string,
  token: string,
  brandId: string,
  body: StopTrackingChatRequest
): Promise<StopTrackingChatResponse> => {
  const response = await BaseAgentService.postWithClientId<
    VisibilityBaseResponse<StopTrackingChatResponse>
  >(visibilityBrandStopTrackingChat(brandId), body, clientId, token);

  return unwrap(response);
};

/** Per-funnel-stage coverage + demand-ranked content gaps for a brand (Beta). */
export const getFunnelCoverage = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<FunnelCoverageResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<FunnelCoverageResponse>
  >(visibilityBrandFunnelCoverage(brandId), clientId, token);

  return unwrap(response);
};

/** Cited-domain landscape + co-citation cluster for a brand (Beta). */
export const getCitedSources = async (
  clientId: string,
  token: string,
  brandId: string
): Promise<CitedSourcesResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<CitedSourcesResponse>
  >(visibilityBrandCitedSources(brandId), clientId, token);

  return unwrap(response);
};

/** Per-signal AEO breakdown + composite AEO/SEO/Quality/compliance scores (Beta). */
export const getArticleAeoChecklist = async (
  clientId: string,
  token: string,
  articleId: string
): Promise<ArticleAeoChecklistResponse> => {
  const response = await BaseAgentService.getWithClientId<
    VisibilityBaseResponse<ArticleAeoChecklistResponse>
  >(visibilityArticleAeoChecklist(articleId), clientId, token);

  return unwrap(response);
};