import type { ApiSettings, CampaignListItem } from "../types";
import { apiDownload, apiFetch } from "./client";

export type CampaignListResponse =
  | CampaignListItem[]
  | {
      campaigns?: CampaignListItem[];
      items?: CampaignListItem[];
      results?: CampaignListItem[];
    };



export type CampaignShare = {
  id: string;
  campaign_id: string;
  target_type: "user" | "group";
  target_id: string;
  permission: "read" | "write";
  revoked_at?: string | null;
};

export type CampaignShareTarget = { id: string; name: string; secondary?: string | null };
export type CampaignShareTargets = { users: CampaignShareTarget[]; groups: CampaignShareTarget[] };

export type CampaignUpdatePayload = {
  external_id?: string | null;
  name?: string | null;
  status?: string | null;
  description?: string | null;
};

export type CampaignCreateMinimalPayload = {
  external_id?: string;
  name?: string;
  description?: string | null;
  current_flow?: string;
  current_step?: string;
};

export type CampaignCreateResponse = {
  campaign: CampaignListItem & {
    current_version_id?: string | null;
  };
  version: CampaignVersionListItem;
};

export type CampaignVersionListItem = {
  id: string;
  campaign_id: string;
  version_number: number;
  schema_version?: string;
  source_filename?: string | null;
  source_base_path?: string | null;
  workflow_state?: string;
  current_flow?: string;
  current_step?: string | null;
  is_complete?: boolean;
  editor_state?: Record<string, unknown>;
  autosaved_at?: string | null;
  published_at?: string | null;
  locked_at?: string | null;
  locked_by_user_id?: string | null;
  user_lock_state?: "temporary" | "permanent" | null;
  user_locked_at?: string | null;
  user_locked_by_user_id?: string | null;
  created_at?: string;
  updated_at?: string;
  validation_summary?: Record<string, unknown> | null;
  build_summary?: Record<string, unknown> | null;
  execution_snapshot_hash?: string | null;
  execution_snapshot_at?: string | null;
};

export type CampaignVersionDetail = CampaignVersionListItem & {
  raw_json: Record<string, unknown>;
  campaign_json?: Record<string, unknown>;
};

export type CampaignVersionUpdatePayload = {
  campaign_json?: Record<string, unknown> | null;
  current_flow?: string | null;
  current_step?: string | null;
  workflow_state?: string | null;
  is_complete?: boolean | null;
  editor_state?: Record<string, unknown> | null;
  source_filename?: string | null;
  source_base_path?: string | null;
};

export type CampaignPartialValidationPayload = {
  campaign_json?: Record<string, unknown> | null;
  section?: string | null;
};

export type CampaignPartialValidationResponse = {
  ok: boolean;
  section?: string | null;
  error_count: number;
  warning_count: number;
  info_count: number;
  issues: Record<string, unknown>[];
};

export type CampaignSummary = {
  generated_at?: string;
  selected_version_id?: string | null;
  campaign?: CampaignListItem;
  current_version?: {
    id: string;
    version_number?: number;
    schema_version?: string;
    source_filename?: string | null;
    created_at?: string | null;
    validation_summary?: Record<string, unknown> | null;
    build_summary?: Record<string, unknown> | null;
  } | null;
  cards?: {
    jobs_total?: number;
    inactive?: number;
    queueable?: number;
    needs_attention?: number;
    sent?: number;
    smtp_accepted?: number;
    failed?: number;
    outcome_unknown?: number;
    not_attempted?: number;
    queued_or_active?: number;
    cancelled?: number;
    partially_completed?: boolean;
    imap_appended?: number;
    imap_failed?: number;
  };
  status_counts?: Record<string, Record<string, number>>;
  issues?: Record<string, unknown>;
  attachments?: Record<string, unknown>;
  attempts?: Record<string, unknown>;
  delivery?: Record<string, unknown>;
  recent_failures?: Record<string, unknown>[];
};

export type CampaignQueuePayload = {
  version_id?: string | null;
  include_warnings?: boolean;
  enqueue_celery?: boolean;
  dry_run?: boolean;
};

export type CampaignSendNowPayload = {
  version_id?: string | null;
  include_warnings?: boolean;
  check_files?: boolean;
  validate_before_send?: boolean;
  build_before_send?: boolean;
  dry_run?: boolean;
  use_rate_limit?: boolean;
  enqueue_imap_task?: boolean;
};


export type CampaignAttachmentPreviewFile = {
  id: string;
  version_id?: string;
  blob_id?: string;
  display_path: string;
  filename: string;
  owner_type: string;
  owner_id: string;
  checksum_sha256?: string;
  size_bytes?: number;
  content_type?: string | null;
};

export type CampaignAttachmentPreviewRule = {
  source: "global" | "entry";
  entry_index: number;
  entry_id?: string | null;
  index: number;
  attachment_id?: string | null;
  label?: string | null;
  required: boolean;
  pattern: string;
  base_path_name?: string | null;
  base_path?: string | null;
  status: "ok" | "missing" | "ambiguous";
  behavior?: string | null;
  zip_included?: boolean;
  zip_mode?: "inherit" | "include" | "exclude";
  zip_archive_id?: string | null;
  zip_filename?: string | null;
  matches: CampaignAttachmentPreviewFile[];
  match_count: number;
  issues: Record<string, unknown>[];
};

export type CampaignAttachmentPreviewResponse = {
  campaign_id: string;
  version_id: string;
  shared_file_count: number;
  rules: CampaignAttachmentPreviewRule[];
  unused_shared_files: CampaignAttachmentPreviewFile[];
};

export type CampaignAttachmentPreviewPayload = {
  include_unmatched?: boolean;
  campaign_json?: Record<string, unknown>;
};

export type CampaignMockSendPayload = {
  version_id?: string | null;
  send?: boolean;
  include_warnings?: boolean;
  include_needs_review?: boolean;
  append_sent?: boolean;
  clear_mailbox?: boolean;
  check_files?: boolean;
};

export type CampaignReviewStatePayload = {
  inspection_complete: boolean;
  reviewed_message_keys: string[];
};


export type CampaignJobsQuery = {
  versionId?: string;
  page?: number;
  pageSize?: number;
  sendStatus?: string[];
  validationStatus?: string[];
  imapStatus?: string[];
  query?: string;
};

export type CampaignJobsResponse = {
  jobs: Record<string, unknown>[];
  page: number;
  page_size: number;
  total: number;
  total_unfiltered: number;
  pages: number;
  counts: Record<string, Record<string, number>>;
  filtered_counts: Record<string, Record<string, number>>;
  review: {
    inspection_complete?: boolean;
    blocking_count?: number;
    required_count?: number;
    reviewed_required_count?: number;
    bulk_acceptable_count?: number;
  };
};

export type CampaignJobDetailResponse = {
  job: Record<string, unknown>;
  attempts: {
    smtp?: Record<string, unknown>[];
    imap?: Record<string, unknown>[];
  };
};

export type CampaignReportEmailPayload = {
  to: string[];
  version_id?: string;
  include_jobs?: boolean;
  attach_jobs_csv?: boolean;
  attach_report_json?: boolean;
  dry_run?: boolean;
};

export async function listCampaigns(settings: ApiSettings): Promise<CampaignListItem[]> {
  const response = await apiFetch<CampaignListResponse>(settings, "/api/v1/campaigns");

  if (Array.isArray(response)) {
    return response;
  }

  return response.campaigns ?? response.items ?? response.results ?? [];
}

export async function getCampaign(settings: ApiSettings, campaignId: string): Promise<CampaignListItem> {
  return apiFetch<CampaignListItem>(settings, `/api/v1/campaigns/${campaignId}`);
}

export async function updateCampaignMetadata(
  settings: ApiSettings,
  campaignId: string,
  payload: CampaignUpdatePayload
): Promise<CampaignListItem> {
  return apiFetch<CampaignListItem>(settings, `/api/v1/campaigns/${campaignId}`, {
    method: "PUT",
    body: JSON.stringify(payload)
  });
}

export async function createNewCampaign(
  settings: ApiSettings,
  overrides: CampaignCreateMinimalPayload = {}
): Promise<CampaignCreateResponse> {
  const now = new Date();
  const stamp = now.toISOString().slice(0, 19).replace(/[-:T]/g, "");
  const payload = {
    external_id: overrides.external_id ?? `new-campaign-${stamp}`,
    name: overrides.name ?? "New Campaign",
    description: overrides.description ?? "",
    current_flow: overrides.current_flow ?? "create",
    current_step: overrides.current_step ?? "basics"
  };

  return apiFetch<CampaignCreateResponse>(settings, "/api/v1/campaigns/new", {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function getCampaignSchema(settings: ApiSettings): Promise<unknown> {
  return apiFetch(settings, "/api/v1/schemas/campaign");
}

export async function listCampaignVersions(
  settings: ApiSettings,
  campaignId: string
): Promise<CampaignVersionListItem[]> {
  return apiFetch<CampaignVersionListItem[]>(settings, `/api/v1/campaigns/${campaignId}/versions`);
}

export async function getCampaignVersion(
  settings: ApiSettings,
  campaignId: string,
  versionId: string
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}`);
}

export async function unlockCampaignVersionValidation(
  settings: ApiSettings,
  campaignId: string,
  versionId: string
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/unlock-validation`, {
    method: "POST"
  });
}

export async function lockCampaignVersionTemporarily(
  settings: ApiSettings,
  campaignId: string,
  versionId: string
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/lock-temporarily`, {
    method: "POST"
  });
}

export async function unlockCampaignVersionUserLock(
  settings: ApiSettings,
  campaignId: string,
  versionId: string
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/unlock-user-lock`, {
    method: "POST"
  });
}

export async function lockCampaignVersionPermanently(
  settings: ApiSettings,
  campaignId: string,
  versionId: string
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/lock-permanently`, {
    method: "POST"
  });
}

export async function updateCampaignVersion(
  settings: ApiSettings,
  campaignId: string,
  versionId: string,
  payload: CampaignVersionUpdatePayload
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}`, {
    method: "PUT",
    body: JSON.stringify(payload)
  });
}

export async function forkCampaignVersion(
  settings: ApiSettings,
  campaignId: string,
  versionId: string,
  payload: CampaignVersionUpdatePayload = {}
): Promise<CampaignCreateResponse> {
  return apiFetch<CampaignCreateResponse>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/fork`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function autosaveCampaignVersion(
  settings: ApiSettings,
  campaignId: string,
  versionId: string,
  payload: CampaignVersionUpdatePayload
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/autosave`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function setCampaignVersionStep(
  settings: ApiSettings,
  campaignId: string,
  versionId: string,
  currentStep: string,
  currentFlow?: string | null
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/set-step`, {
    method: "POST",
    body: JSON.stringify({ current_flow: currentFlow, current_step: currentStep })
  });
}

export async function validatePartial(
  settings: ApiSettings,
  campaignId: string,
  versionId: string,
  payload: CampaignPartialValidationPayload = {}
): Promise<CampaignPartialValidationResponse> {
  return apiFetch<CampaignPartialValidationResponse>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/validate-partial`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function publishCampaignVersion(
  settings: ApiSettings,
  campaignId: string,
  versionId: string
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/publish`, {
    method: "POST"
  });
}

export async function validateVersion(
  settings: ApiSettings,
  versionId: string,
  checkFiles = false
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/versions/${versionId}/validate`, {
    method: "POST",
    body: JSON.stringify({ check_files: checkFiles })
  });
}

export async function buildVersion(
  settings: ApiSettings,
  versionId: string,
  writeEml = true
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/versions/${versionId}/build`, {
    method: "POST",
    body: JSON.stringify({ write_eml: writeEml })
  });
}


export function previewCampaignAttachments(
  settings: ApiSettings,
  campaignId: string,
  versionId: string,
  payload: CampaignAttachmentPreviewPayload = {}
): Promise<CampaignAttachmentPreviewResponse> {
  return apiFetch<CampaignAttachmentPreviewResponse>(
    settings,
    `/api/v1/campaigns/${campaignId}/versions/${versionId}/attachments/preview`,
    { method: "POST", body: JSON.stringify(payload) }
  );
}

export async function getCampaignSummary(
  settings: ApiSettings,
  campaignId: string,
  versionId?: string
): Promise<CampaignSummary> {
  const suffix = versionId ? `?version_id=${encodeURIComponent(versionId)}` : "";
  return apiFetch<CampaignSummary>(settings, `/api/v1/campaigns/${campaignId}/summary${suffix}`);
}

export async function getCampaignJobs(
  settings: ApiSettings,
  campaignId: string,
  options: CampaignJobsQuery = {}
): Promise<CampaignJobsResponse> {
  const params = new URLSearchParams();
  if (options.versionId) params.set("version_id", options.versionId);
  if (options.page) params.set("page", String(options.page));
  if (options.pageSize) params.set("page_size", String(options.pageSize));
  for (const value of options.sendStatus ?? []) params.append("send_status", value);
  for (const value of options.validationStatus ?? []) params.append("validation_status", value);
  for (const value of options.imapStatus ?? []) params.append("imap_status", value);
  if (options.query?.trim()) params.set("q", options.query.trim());
  const suffix = params.size > 0 ? `?${params.toString()}` : "";
  return apiFetch<CampaignJobsResponse>(settings, `/api/v1/campaigns/${campaignId}/jobs${suffix}`);
}

export async function getCampaignJobDetail(
  settings: ApiSettings,
  campaignId: string,
  jobId: string
): Promise<CampaignJobDetailResponse> {
  return apiFetch<CampaignJobDetailResponse>(settings, `/api/v1/campaigns/${campaignId}/jobs/${jobId}`);
}

export async function getCampaignReport(
  settings: ApiSettings,
  campaignId: string,
  versionId?: string
): Promise<CampaignSummary> {
  const params = new URLSearchParams({ include_jobs: "false" });
  if (versionId) params.set("version_id", versionId);
  return apiFetch<CampaignSummary>(settings, `/api/v1/campaigns/${campaignId}/report?${params.toString()}`);
}

export async function downloadCampaignJobsCsv(
  settings: ApiSettings,
  campaignId: string,
  versionId?: string
): Promise<void> {
  const suffix = versionId ? `?version_id=${encodeURIComponent(versionId)}` : "";
  await apiDownload(
    settings,
    `/api/v1/campaigns/${campaignId}/report/jobs.csv${suffix}`,
    `campaign-${campaignId}${versionId ? `-${versionId}` : ""}-jobs.csv`
  );
}

export async function emailCampaignReport(
  settings: ApiSettings,
  campaignId: string,
  payload: CampaignReportEmailPayload
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/report/email`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function retryCampaignJobs(
  settings: ApiSettings,
  campaignId: string,
  payload: Record<string, unknown> = {}
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/jobs/retry`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function sendUnattemptedCampaignJobs(
  settings: ApiSettings,
  campaignId: string,
  payload: Record<string, unknown> = {}
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/jobs/send-unattempted`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function resolveCampaignJobOutcome(
  settings: ApiSettings,
  campaignId: string,
  jobId: string,
  decision: "smtp_accepted" | "not_sent",
  note?: string
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/jobs/${jobId}/resolve-outcome`, {
    method: "POST",
    body: JSON.stringify({ decision, note: note || null })
  });
}

export async function updateCampaignReviewState(
  settings: ApiSettings,
  campaignId: string,
  versionId: string,
  payload: CampaignReviewStatePayload
): Promise<CampaignVersionDetail> {
  return apiFetch<CampaignVersionDetail>(settings, `/api/v1/campaigns/${campaignId}/versions/${versionId}/review-state`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function queueCampaign(
  settings: ApiSettings,
  campaignId: string,
  payload: CampaignQueuePayload = {}
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/queue`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function sendCampaignNow(
  settings: ApiSettings,
  campaignId: string,
  payload: CampaignSendNowPayload = {}
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/send-now`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}


export async function mockSendCampaign(
  settings: ApiSettings,
  campaignId: string,
  payload: CampaignMockSendPayload = {}
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/mock-send`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
}

export async function pauseCampaign(settings: ApiSettings, campaignId: string): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/pause`, { method: "POST" });
}

export async function resumeCampaign(settings: ApiSettings, campaignId: string): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/resume`, { method: "POST" });
}

export async function cancelCampaign(settings: ApiSettings, campaignId: string): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/cancel`, { method: "POST" });
}

export async function appendSent(
  settings: ApiSettings,
  campaignId: string,
  dryRun = false
): Promise<Record<string, unknown>> {
  return apiFetch<Record<string, unknown>>(settings, `/api/v1/campaigns/${campaignId}/append-sent`, {
    method: "POST",
    body: JSON.stringify({ dry_run: dryRun })
  });
}

export async function getCampaignShareTargets(settings: ApiSettings, campaignId: string): Promise<CampaignShareTargets> {
  return apiFetch<CampaignShareTargets>(settings, `/api/v1/campaigns/${campaignId}/share-targets`);
}

export async function getCampaignShares(settings: ApiSettings, campaignId: string): Promise<CampaignShare[]> {
  const response = await apiFetch<{ shares: CampaignShare[] }>(settings, `/api/v1/campaigns/${campaignId}/shares`);
  return response.shares;
}

export async function updateCampaignOwner(
  settings: ApiSettings,
  campaignId: string,
  payload: { owner_user_id?: string | null; owner_group_id?: string | null }
): Promise<CampaignListItem> {
  return apiFetch<CampaignListItem>(settings, `/api/v1/campaigns/${campaignId}/owner`, { method: "PUT", body: JSON.stringify(payload) });
}

export async function upsertCampaignShare(
  settings: ApiSettings,
  campaignId: string,
  payload: { target_type: "user" | "group"; target_id: string; permission: "read" | "write" }
): Promise<CampaignShare> {
  return apiFetch<CampaignShare>(settings, `/api/v1/campaigns/${campaignId}/shares`, { method: "POST", body: JSON.stringify(payload) });
}

export async function revokeCampaignShare(settings: ApiSettings, campaignId: string, shareId: string): Promise<void> {
  await apiFetch<void>(settings, `/api/v1/campaigns/${campaignId}/shares/${shareId}`, { method: "DELETE" });
}