import axios from "axios";
import type {
  Car,
  CarFilters,
  PaginatedCarsResponse,
  CompareResponse,
  HomepageData,
  SimilarCarsResponse,
  FilterOptions,
  NLSearchResponse,
  RecommendResponse,
  AICompareResponse,
  ChatMessage,
  ChatResponse,
  AISummaryResponse,
  NewsArticle,
  PaginatedNewsResponse,
  Lead,
  LeadStatus,
  LeadStats,
  LeadAnalytics,
  PaginatedLeadsResponse,
  CarLeadAnalytics,
  Blog,
  BlogStats,
  PaginatedBlogsResponse,
  CarComparison,
  PaginatedComparisonsResponse,
  CarReviewsResponse,
} from "./types";
import { getAdminToken } from "./adminAuth";

const api = axios.create({
  baseURL: process.env.NEXT_PUBLIC_API_URL || "http://localhost:8000",
  timeout: 15_000,
});

// ── Cars ────────────────────────────────────────────────────────────────────

export async function fetchCars(filters: CarFilters = {}): Promise<PaginatedCarsResponse> {
  const params = new URLSearchParams();

  filters.brand?.forEach((b) => params.append("brand", b));
  filters.fuelType?.forEach((f) => params.append("fuelType", f));
  filters.transmission?.forEach((t) => params.append("transmission", t));
  filters.bodyType?.forEach((b) => params.append("bodyType", b));

  if (filters.priceMin !== undefined) params.append("priceMin", String(filters.priceMin));
  if (filters.priceMax !== undefined) params.append("priceMax", String(filters.priceMax));
  if (filters.city)   params.append("city", filters.city);
  if (filters.search) params.append("search", filters.search);

  if (filters.seating !== undefined)  params.append("seating",    String(filters.seating));
  if (filters.hasADAS !== undefined)  params.append("hasADAS",    String(filters.hasADAS));
  if (filters.minMileage !== undefined) params.append("minMileage", String(filters.minMileage));
  if (filters.ncapRating)             params.append("ncapRating", filters.ncapRating);
  if (filters.minGroundClearance !== undefined) params.append("minGroundClearance", String(filters.minGroundClearance));
  if (filters.isEV !== undefined)     params.append("isEV",       String(filters.isEV));
  if (filters.isNew !== undefined)    params.append("isNew",      String(filters.isNew));
  if (filters.isUpcoming !== undefined) params.append("isUpcoming", String(filters.isUpcoming));

  if (filters.sortBy)
    params.append("sortBy", filters.sortBy === "price" ? "priceMin" : filters.sortBy);
  if (filters.sortOrder !== undefined) params.append("sortOrder", String(filters.sortOrder));
  if (filters.page)  params.append("page",  String(filters.page));
  if (filters.limit) params.append("limit", String(filters.limit));

  const { data } = await api.get<PaginatedCarsResponse>(`/api/cars?${params.toString()}`);
  return data;
}

export async function fetchFeaturedCars(limit = 8): Promise<{ cars: Car[] }> {
  const { data } = await api.get("/api/cars/featured", { params: { limit } });
  return data;
}

export async function fetchCarById(id: string): Promise<Car> {
  const { data } = await api.get<Car>(`/api/cars/${id}`);
  return data;
}

export async function fetchCarReviews(carId: string): Promise<CarReviewsResponse> {
  const { data } = await api.get<CarReviewsResponse>(`/api/cars/${carId}/reviews`);
  return data;
}

export async function fetchBrands(): Promise<{ brands: string[] }> {
  const { data } = await api.get("/api/cars/brands");
  return data;
}

/**
 * Fetches the car count for each brand in parallel.
 * Uses limit=1 so the API returns only the total count, not full car data.
 */
export async function fetchBrandCounts(
  brands: string[]
): Promise<Record<string, number>> {
  const results = await Promise.allSettled(
    brands.map(async (brand) => {
      const { total } = await fetchCars({ brand: [brand], limit: 1 });
      return { brand, count: total };
    })
  );

  const counts: Record<string, number> = {};
  results.forEach((r) => {
    if (r.status === "fulfilled") counts[r.value.brand] = r.value.count;
  });
  return counts;
}

export async function fetchStats() {
  const { data } = await api.get("/api/cars/stats");
  return data as { totalCars: number; totalBrands: number; totalCities: number };
}

export async function fetchHomepageData(): Promise<HomepageData> {
  const { data } = await api.get<HomepageData>("/api/cars/homepage");
  return data;
}

export async function fetchSimilarCars(carId: string): Promise<SimilarCarsResponse> {
  const { data } = await api.get<SimilarCarsResponse>(`/api/cars/${carId}/similar`);
  return data;
}

export async function fetchFilterOptions(): Promise<FilterOptions> {
  const { data } = await api.get<FilterOptions>("/api/cars/filter-options");
  return data;
}

export async function fetchSuggestions(q: string): Promise<{ suggestions: Car[] }> {
  const { data } = await api.get("/api/cars/suggest", { params: { q } });
  return data;
}

export async function compareCars(carIds: string[]): Promise<CompareResponse> {
  const { data } = await api.post("/api/compare", { car_ids: carIds });
  return data;
}

// ── News ─────────────────────────────────────────────────────────────────────

export interface FetchNewsParams {
  category?: string;
  tag?: string;
  featured?: boolean;
  page?: number;
  limit?: number;
}

export async function fetchNews(params: FetchNewsParams = {}): Promise<PaginatedNewsResponse> {
  const p = new URLSearchParams();
  if (params.category && params.category !== "All") p.append("category", params.category);
  if (params.tag)       p.append("tag", params.tag);
  if (params.featured !== undefined) p.append("featured", String(params.featured));
  if (params.page)      p.append("page",  String(params.page));
  if (params.limit)     p.append("limit", String(params.limit));
  const { data } = await api.get<PaginatedNewsResponse>(`/api/news?${p.toString()}`);
  return data;
}

export async function fetchNewsArticle(slug: string): Promise<NewsArticle> {
  const { data } = await api.get<NewsArticle>(`/api/news/${slug}`);
  return data;
}

export async function fetchNewsCategories(): Promise<{ categories: string[] }> {
  const { data } = await api.get("/api/news/categories");
  return data;
}

export async function fetchRelatedNews(carId: string, limit = 4): Promise<{ articles: NewsArticle[] }> {
  const { data } = await api.get(`/api/news/related/${carId}`, { params: { limit } });
  return data;
}

export async function generateNews(count = 3): Promise<{ generated: number; articles: { title: string; slug: string; category: string }[]; errors: string[] }> {
  const { data } = await adminApi().post("/api/news/generate", null, { params: { count } });
  return data;
}

// ── AI ───────────────────────────────────────────────────────────────────────

export async function aiSearch(query: string): Promise<NLSearchResponse> {
  const { data } = await api.post<NLSearchResponse>("/api/ai/search", { query });
  return data;
}

export async function aiRecommend(
  preferences: string,
  limit = 4
): Promise<RecommendResponse> {
  const { data } = await api.post<RecommendResponse>("/api/ai/recommend", {
    preferences,
    limit,
  });
  return data;
}

export async function aiCompare(carIds: string[]): Promise<AICompareResponse> {
  const { data } = await api.post<AICompareResponse>("/api/ai/compare", {
    car_ids: carIds,
  });
  return data;
}

export async function aiChat(messages: ChatMessage[]): Promise<ChatResponse> {
  const { data } = await api.post<ChatResponse>("/api/ai/chat", { messages });
  return data;
}

export async function aiSummary(carId: string): Promise<AISummaryResponse> {
  const { data } = await api.get<AISummaryResponse>(`/api/ai/summary/${carId}`);
  return data;
}

// ── Scraper management (admin only) ─────────────────────────────────────────

export interface ScraperStatus {
  scraper: {
    running: boolean;
    last_run: string | null;
    last_success: string | null;
    last_error: string | null;
    last_result: ScraperResult | null;
  };
  database: {
    total_cars: number;
    total_brands: number;
    featured_cars: number;
    new_launches: number;
    brands: string[];
  };
  scheduler: {
    interval_hours: number;
    apify_configured: boolean;
  };
}

export interface ScraperResult {
  source: string;
  cars_discovered: number;
  inserted: number;
  updated: number;
  skipped: number;
  errors: number;
  execution_time_s: number;
  timestamp: string;
}

export async function fetchScraperStatus(): Promise<ScraperStatus> {
  const { data } = await adminApi().get<ScraperStatus>("/api/scraper/status");
  return data;
}

export async function triggerScrape(scraperKey = ""): Promise<ScraperResult> {
  const { data } = await adminApi().post<ScraperResult>(
    "/api/scraper/trigger",
    {},
    { headers: scraperKey ? { "X-Scraper-Key": scraperKey } : {} }
  );
  return data;
}

// ── Leads ─────────────────────────────────────────────────────────────────────

export async function submitLead(payload: {
  carId: string;
  carName: string;
  variant?: string;
  name: string;
  mobile: string;
  email?: string;
  pinCode?: string;
  city: string;
  state?: string;
  message?: string;
  source?: string;
}): Promise<{ id: string; message: string }> {
  const { data } = await api.post<{ id: string; message: string }>("/api/leads", {
    ...payload,
    source: payload.source ?? "web",
  });
  return data;
}

export async function trackLeadClick(payload: {
  carId: string;
  carName: string;
  source?: string;
}): Promise<void> {
  await api.post("/api/leads/click", {
    ...payload,
    source: payload.source ?? "web",
  });
}

// ── Admin API helpers ─────────────────────────────────────────────────────────

function adminApi(timeout = 15_000) {
  const token = typeof window !== "undefined" ? getAdminToken() : null;
  return axios.create({
    baseURL: process.env.NEXT_PUBLIC_API_URL || "http://localhost:8000",
    timeout,
    headers: token ? { Authorization: `Bearer ${token}` } : {},
  });
}

export async function adminLogin(
  email: string,
  password: string
): Promise<{ token: string; email: string; role: string }> {
  try {
    const { data } = await api.post<{ token: string; email: string; role: string }>(
      "/api/admin/login",
      { email, password }
    );
    return data;
  } catch (err: unknown) {
    if (axios.isAxiosError(err) && err.response?.data?.detail) {
      const detail = err.response.data.detail;
      throw new Error(
        typeof detail === "string" ? detail : "Invalid email or password"
      );
    }
    throw err;
  }
}

export async function adminStatus(): Promise<{ initialized: boolean }> {
  const { data } = await api.get<{ initialized: boolean }>("/api/admin/status");
  return data;
}

export async function adminSetup(): Promise<{ created: boolean; email: string }> {
  const { data } = await api.get<{ created: boolean; email: string }>("/api/admin/setup");
  return data;
}

export async function fetchLeads(params?: {
  page?: number;
  limit?: number;
  status?: string;
  search?: string;
  city?: string;
  car?: string;
  variant?: string;
  dateFrom?: string;
  dateTo?: string;
}): Promise<PaginatedLeadsResponse> {
  const p = new URLSearchParams();
  if (params?.page)     p.append("page",      String(params.page));
  if (params?.limit)    p.append("limit",     String(params.limit));
  if (params?.status)   p.append("status",    params.status);
  if (params?.search)   p.append("search",    params.search);
  if (params?.city)     p.append("city",      params.city);
  if (params?.car)      p.append("car",       params.car);
  if (params?.variant)  p.append("variant",   params.variant);
  if (params?.dateFrom) p.append("date_from", params.dateFrom);
  if (params?.dateTo)   p.append("date_to",   params.dateTo);
  const { data } = await adminApi().get<PaginatedLeadsResponse>(
    `/api/leads?${p.toString()}`
  );
  return data;
}

export async function updateLeadStatus(id: string, status: LeadStatus): Promise<void> {
  await adminApi().patch(`/api/leads/${id}/status`, { status });
}

export async function deleteLead(id: string): Promise<void> {
  await adminApi().delete(`/api/leads/${id}`);
}

export async function fetchLeadStats(): Promise<LeadStats> {
  const { data } = await adminApi().get<LeadStats>("/api/leads/stats");
  return data;
}

export async function fetchLeadAnalytics(): Promise<LeadAnalytics> {
  const { data } = await adminApi().get<LeadAnalytics>("/api/leads/analytics");
  return data;
}

export async function exportLeadsCSV(): Promise<void> {
  const token =
    typeof window !== "undefined"
      ? sessionStorage.getItem("drivehub_admin_token")
      : null;
  const base = process.env.NEXT_PUBLIC_API_URL || "http://localhost:8000";
  const response = await fetch(`${base}/api/leads/export`, {
    headers: token ? { Authorization: `Bearer ${token}` } : {},
  });
  if (!response.ok) throw new Error("Export failed");
  const blob = await response.blob();
  const url = URL.createObjectURL(blob);
  const a = document.createElement("a");
  a.href = url;
  a.download = `leads-${new Date().toISOString().split("T")[0]}.csv`;
  document.body.appendChild(a);
  a.click();
  document.body.removeChild(a);
  URL.revokeObjectURL(url);
}

export async function fetchCarLeadAnalytics(carId: string): Promise<CarLeadAnalytics> {
  const { data } = await adminApi().get<CarLeadAnalytics>(`/api/leads/car/${carId}`);
  return data;
}

// Re-export Lead type for convenience
export type { Lead, LeadStatus, LeadStats, LeadAnalytics, PaginatedLeadsResponse, CarLeadAnalytics };

// ── Blog API ──────────────────────────────────────────────────────────────────

export async function fetchBlogs(params?: {
  category?: string;
  page?: number;
  limit?: number;
  status?: string;
}): Promise<PaginatedBlogsResponse> {
  const { data } = await api.get<PaginatedBlogsResponse>("/api/blogs", { params });
  return data;
}

export async function fetchBlog(slug: string): Promise<Blog> {
  const { data } = await api.get<Blog>(`/api/blogs/${slug}`);
  return data;
}

export async function generateBlog(options?: {
  category?: string;
  topic?: string;
}): Promise<Blog> {
  const { data } = await adminApi().post<Blog>("/api/blogs/generate", options ?? {});
  return data;
}

export async function updateBlog(id: string, updates: Partial<Blog>): Promise<Blog> {
  const { data } = await adminApi().patch<Blog>(`/api/blogs/${id}`, updates);
  return data;
}

export async function deleteBlog(id: string): Promise<void> {
  await adminApi().delete(`/api/blogs/${id}`);
}

export async function fetchBlogStats(): Promise<BlogStats> {
  const { data } = await adminApi().get<BlogStats>("/api/blogs/stats");
  return data;
}

// ── Comparison API ────────────────────────────────────────────────────────────

export async function fetchComparisons(params?: {
  page?: number;
  limit?: number;
}): Promise<PaginatedComparisonsResponse> {
  const { data } = await api.get<PaginatedComparisonsResponse>("/api/comparisons", { params });
  return data;
}

export async function fetchComparison(slug: string): Promise<CarComparison> {
  const { data } = await api.get<CarComparison>(`/api/comparisons/${slug}`);
  return data;
}

export async function generateComparison(car1Id: string, car2Id: string): Promise<CarComparison> {
  const { data } = await adminApi().post<CarComparison>("/api/comparisons/generate", { car1Id, car2Id });
  return data;
}

// ── Brand API ─────────────────────────────────────────────────────────────────

import type { BrandListItem, BrandPage, BestCarsCategory, BestCarsPage, SeoHealthReport } from "./types";

export async function fetchBrandsList(): Promise<{ brands: BrandListItem[]; total: number }> {
  const { data } = await api.get("/api/brands");
  return data;
}

export async function fetchBrandPage(brandSlug: string): Promise<BrandPage> {
  const { data } = await api.get<BrandPage>(`/api/brands/${brandSlug}`);
  return data;
}

export async function fetchBrandCars(
  brandSlug: string,
  params?: { page?: number; limit?: number; body_type?: string; fuel_type?: string }
): Promise<{ cars: Car[]; total: number; page: number; limit: number; totalPages: number }> {
  const { data } = await api.get(`/api/brands/${brandSlug}/cars`, { params });
  return data;
}

export async function generateBrandPage(brandSlug: string): Promise<BrandPage> {
  const { data } = await adminApi().post<BrandPage>(`/api/brands/${brandSlug}/generate`);
  return data;
}

export interface CreateBrandPayload {
  brandName: string;
  country: string;
  logoUrl?: string;
  carsCount: number;
  generateAiCars: boolean;
}

export interface CreateBrandResult {
  brand: string;
  brandSlug: string;
  country: string;
  logoUrl: string;
  generateAiCars: boolean;
  steps: Record<string, unknown>;
  message: string;
}

export async function createBrand(payload: CreateBrandPayload): Promise<CreateBrandResult> {
  try {
    const { data } = await adminApi().post<CreateBrandResult>("/api/brands/create", {
      brand_name: payload.brandName,
      country: payload.country,
      logo_url: payload.logoUrl || null,
      cars_count: payload.carsCount,
      generate_ai_cars: payload.generateAiCars,
    });
    return data;
  } catch (err: unknown) {
    if (axios.isAxiosError(err) && err.response?.data?.detail) {
      const detail = err.response.data.detail;
      throw new Error(typeof detail === "string" ? detail : "Failed to create brand");
    }
    throw err;
  }
}

// ── Best Cars API ─────────────────────────────────────────────────────────────

export async function fetchBestCarsCategories(): Promise<{ categories: BestCarsCategory[]; total: number }> {
  const { data } = await api.get("/api/best-cars");
  return data;
}

export async function fetchBestCarsPage(
  categorySlug: string,
  params?: { page?: number; limit?: number }
): Promise<BestCarsPage> {
  const { data } = await api.get<BestCarsPage>(`/api/best-cars/${categorySlug}`, { params });
  return data;
}

export async function generateBestCarsPage(categorySlug: string): Promise<BestCarsPage> {
  const { data } = await adminApi().post<BestCarsPage>(`/api/best-cars/${categorySlug}/generate`);
  return data;
}

// ── SEO Health API ────────────────────────────────────────────────────────────

export async function fetchSeoHealthReport(): Promise<SeoHealthReport> {
  const { data } = await adminApi().get<SeoHealthReport>("/api/best-cars/admin/seo-health");
  return data;
}

export async function runSeoHealthCheck(): Promise<SeoHealthReport> {
  const { data } = await adminApi().post<SeoHealthReport>("/api/best-cars/admin/seo-check");
  return data;
}

// ── Recommendations API (F28) ─────────────────────────────────────────────────

export interface CarRecommendation {
  id: string;
  name: string;
  brand: string;
  slug: string;
  priceMin: number | null;
  priceMax: number | null;
  fuelType: string;
  bodyType: string;
  rating: number;
  image: string | null;
  similarityScore: number;
}

export async function fetchRecommendations(carId: string): Promise<CarRecommendation[]> {
  const { data } = await api.get<{ recommendations: CarRecommendation[] }>(`/api/recommendations/${carId}`);
  return data.recommendations ?? [];
}

// ── Alerts API (F34) ─────────────────────────────────────────────────────────

export interface CarAlert {
  id: string;
  carId: string;
  carName: string;
  type: string;
  typeLabel: string;
  message: string;
  detectedAt: string;
  read: boolean;
}

export async function fetchAlerts(unreadOnly = false): Promise<CarAlert[]> {
  const { data } = await adminApi().get<{ alerts: CarAlert[] }>("/api/alerts", {
    params: unreadOnly ? { unread_only: true } : {},
  });
  return data.alerts ?? [];
}

export async function markAlertRead(alertId: string): Promise<void> {
  await adminApi().patch(`/api/alerts/${alertId}/read`);
}

export async function markAllAlertsRead(): Promise<void> {
  await adminApi().patch("/api/alerts/read-all");
}

// ── Lead Intelligence API (F36) ───────────────────────────────────────────────

export interface LeadReport {
  weekStart: string;
  generatedAt: string;
  totalLeads: number;
  topCars: { name: string; count: number }[];
  topBrands: { name: string; count: number }[];
  topCities: { name: string; count: number }[];
  topFuelTypes: { type: string; count: number }[];
  topBudgetRanges: { range: string; count: number }[];
  conversionRate: number;
  convertedLeads: number;
}

export async function fetchLeadReport(): Promise<LeadReport | null> {
  try {
    const { data } = await adminApi().get<LeadReport>("/api/lead-intelligence/latest");
    return data;
  } catch {
    return null;
  }
}

export async function generateLeadReport(): Promise<LeadReport | null> {
  try {
    const { data } = await adminApi().post<LeadReport>("/api/lead-intelligence/generate");
    return data;
  } catch {
    return null;
  }
}

// ── Confidence API (F41) ──────────────────────────────────────────────────────

export interface ConfidenceEntry {
  confidence: number;
  sourceCount: number;
  verified: boolean;
  level: "verified" | "high" | "medium" | "needs_review";
  label: string;
  method: string;
  lastChecked: string;
}

export interface ConfidenceSummary {
  total: number;
  publishReady: number;
  needsReview: number;
  avgConfidence: number;
}

export interface CarConfidence {
  carId: string;
  carName: string;
  publishReady: boolean;
  overallConfidence: number;
  flaggedFields: string[];
  confidenceMap: Record<string, ConfidenceEntry>;
}

export async function fetchConfidenceSummary(): Promise<ConfidenceSummary> {
  const { data } = await adminApi().get<ConfidenceSummary>("/api/confidence/summary");
  return data;
}

export async function fetchCarsNeedingReview(limit = 100): Promise<{ cars: CarConfidence[]; total: number }> {
  const { data } = await adminApi().get("/api/confidence/needs-review", { params: { limit } });
  return data;
}

export async function runConfidenceCheck(): Promise<{ total: number; updated: number; flagged_for_review: number }> {
  const { data } = await adminApi().post("/api/confidence/run-check");
  return data;
}

export async function verifyConfidenceField(carId: string, field: string): Promise<boolean> {
  try {
    await adminApi().patch(`/api/confidence/${carId}/verify/${field}`);
    return true;
  } catch {
    return false;
  }
}

export async function fetchCarConfidence(carIdOrSlug: string): Promise<CarConfidence | null> {
  try {
    const { data } = await api.get<CarConfidence>(`/api/confidence/${carIdOrSlug}`);
    return data;
  } catch {
    return null;
  }
}

// ── Rivals API ────────────────────────────────────────────────────────────────

import type { CarRivals } from "./types";

export async function fetchRivals(carId: string): Promise<CarRivals | null> {
  try {
    const { data } = await api.get<CarRivals>(`/api/rivals/${carId}`);
    return data;
  } catch {
    return null;
  }
}

export async function refreshRivals(carId: string): Promise<CarRivals | null> {
  try {
    const { data } = await adminApi().post<CarRivals>(`/api/rivals/${carId}/refresh`);
    return data;
  } catch {
    return null;
  }
}

export async function runRivalsJob(): Promise<{ processed: number; updated: number; errors: number }> {
  const { data } = await adminApi(120_000).post("/api/rivals/run");
  return data;
}

// ── Price History API ─────────────────────────────────────────────────────────

import type { CarPriceHistory } from "./types";

export async function fetchPriceHistory(
  carId: string,
  limit = 60
): Promise<CarPriceHistory | null> {
  try {
    const { data } = await api.get<CarPriceHistory>(`/api/prices/${carId}/history`, {
      params: { limit },
    });
    return data;
  } catch {
    return null;
  }
}

export async function fetchRecentPriceChanges(limit = 20) {
  const { data } = await api.get("/api/prices/recent-changes", { params: { limit } });
  return data as { changes: import("./types").PriceHistoryEntry[]; total: number };
}

export async function runPriceTracking(): Promise<{ tracked: number; changes: number }> {
  const { data } = await adminApi(120_000).post("/api/prices/track");
  return data;
}

export async function fetchProductionReport(): Promise<unknown> {
  const { data } = await adminApi(60_000).get("/api/report/production");
  return data;
}

// ── Moderation API (F42) ──────────────────────────────────────────────────────

import type { ModerationStats, ModerationCar } from "./types";

export async function fetchModerationStats(): Promise<ModerationStats> {
  const { data } = await adminApi().get<ModerationStats>("/api/moderation/stats");
  return data;
}

export async function fetchRejectedCars(
  skip = 0,
  limit = 50
): Promise<{ cars: ModerationCar[]; total: number }> {
  const { data } = await adminApi().get("/api/moderation/rejections", {
    params: { skip, limit },
  });
  return data;
}

export async function fetchWarningCars(
  skip = 0,
  limit = 50
): Promise<{ cars: ModerationCar[] }> {
  const { data } = await adminApi().get("/api/moderation/warnings", {
    params: { skip, limit },
  });
  return data;
}

export async function runModerationJob(): Promise<{
  total: number; passed: number; rejected: number; withWarnings: number;
}> {
  const { data } = await adminApi().post("/api/moderation/run");
  return data;
}

export async function whitelistCar(carId: string): Promise<void> {
  await adminApi().post(`/api/moderation/whitelist/${carId}`);
}

export async function recheckCar(carId: string): Promise<void> {
  await adminApi().post(`/api/moderation/recheck/${carId}`);
}

// ── F44: Car Wizard ───────────────────────────────────────────────────────────

import type { WizardInput, WizardResult } from "./types";

export async function wizardRecommend(input: WizardInput): Promise<WizardResult> {
  const { data } = await api.post<WizardResult>("/api/wizard/recommend", {
    budgetMin:  input.budgetMin,
    budgetMax:  input.budgetMax,
    fuelTypes:  input.fuelTypes,
    bodyTypes:  input.bodyTypes,
    familySize: input.familySize,
  });
  return data;
}

// ── F43: City pricing, offers, waiting periods, dealers, city pages ───────────

import type {
  CityPriceBreakdown, CarDiscounts, WaitingPeriod,
  CityPageSummary, CityPage, Dealer,
} from "./types";

// City pricing
export async function fetchCityPricing(carId: string): Promise<CityPriceBreakdown[]> {
  try {
    const { data } = await api.get<{ prices: CityPriceBreakdown[] }>(`/api/pricing/${carId}`);
    return data.prices ?? [];
  } catch {
    return [];
  }
}

export async function fetchCityPricingForCity(
  carId: string,
  city: string
): Promise<CityPriceBreakdown | null> {
  try {
    const { data } = await api.get<CityPriceBreakdown>(`/api/pricing/${carId}`, { params: { city } });
    return data;
  } catch {
    return null;
  }
}

// Offers / Discounts
export async function fetchOffers(carId: string, city?: string): Promise<CarDiscounts | null> {
  try {
    const { data } = await api.get<CarDiscounts>(`/api/offers/${carId}`, {
      params: city ? { city } : {},
    });
    return data;
  } catch {
    return null;
  }
}

// Waiting periods
export async function fetchWaitingPeriod(
  carId: string,
  city?: string
): Promise<WaitingPeriod | null> {
  try {
    const { data } = await api.get<WaitingPeriod>(`/api/waiting/${carId}`, {
      params: city ? { city } : {},
    });
    return data;
  } catch {
    return null;
  }
}

// Dealers
export async function fetchDealers(params: {
  city?: string;
  brand?: string;
  skip?: number;
  limit?: number;
}): Promise<{ dealers: Dealer[]; total: number }> {
  try {
    const { data } = await api.get("/api/dealers", { params });
    return data;
  } catch {
    return { dealers: [], total: 0 };
  }
}

export async function fetchDealerCities(): Promise<
  { city: string; state?: string; dealerCount: number; brands: string[] }[]
> {
  try {
    const { data } = await api.get("/api/dealers/cities");
    return data.cities ?? [];
  } catch {
    return [];
  }
}

// City pages
export async function fetchCities(): Promise<CityPageSummary[]> {
  try {
    const { data } = await api.get<{ cities: CityPageSummary[] }>("/api/cities");
    return data.cities ?? [];
  } catch {
    return [];
  }
}

export async function fetchCityPage(slug: string): Promise<CityPage | null> {
  try {
    const { data } = await api.get<CityPage>(`/api/cities/${slug}`);
    return data;
  } catch {
    return null;
  }
}

// ── F48: Notifications & Watchlist ───────────────────────────────────────────

import type { UserNotification, WatchedCar } from "./types";

// — Watchlist —

export async function watchCar(
  sessionId: string,
  carId: string,
  types?: string[]
): Promise<{ watching: boolean; entry?: WatchedCar }> {
  try {
    const { data } = await api.post("/api/watchlist", { sessionId, carId, types });
    return data;
  } catch { return { watching: false }; }
}

export async function unwatchCar(sessionId: string, carId: string): Promise<boolean> {
  try {
    await api.delete(`/api/watchlist/${carId}`, { params: { session_id: sessionId } });
    return true;
  } catch { return false; }
}

export async function toggleWatch(
  sessionId: string,
  carId: string
): Promise<{ watching: boolean }> {
  try {
    const { data } = await api.post(
      `/api/watchlist/toggle/${carId}`,
      {},
      { params: { session_id: sessionId } }
    );
    return data;
  } catch { return { watching: false }; }
}

export async function checkWatching(sessionId: string, carId: string): Promise<boolean> {
  try {
    const { data } = await api.get(`/api/watchlist/check/${carId}`, {
      params: { session_id: sessionId },
    });
    return data.watching ?? false;
  } catch { return false; }
}

export async function fetchWatchlist(sessionId: string): Promise<WatchedCar[]> {
  try {
    const { data } = await api.get("/api/watchlist", { params: { session_id: sessionId } });
    return data.watchlist ?? [];
  } catch { return []; }
}

// — Notifications —

export async function fetchNotifications(
  sessionId: string,
  limit = 20,
  unreadOnly = false,
  type?: string
): Promise<UserNotification[]> {
  try {
    const { data } = await api.get("/api/notifications", {
      params: { session_id: sessionId, limit, unread_only: unreadOnly, ...(type ? { type } : {}) },
    });
    return data.notifications ?? [];
  } catch { return []; }
}

export async function fetchUnreadCount(sessionId: string): Promise<number> {
  try {
    const { data } = await api.get("/api/notifications/unread-count", {
      params: { session_id: sessionId },
    });
    return data.count ?? 0;
  } catch { return 0; }
}

export async function markNotificationsRead(
  sessionId: string,
  ids: string[]
): Promise<void> {
  try { await api.post("/api/notifications/mark-read", { sessionId, ids }); }
  catch { /* silent */ }
}

export async function markAllNotificationsRead(sessionId: string): Promise<void> {
  try { await api.post("/api/notifications/mark-all-read", {}, { params: { session_id: sessionId } }); }
  catch { /* silent */ }
}

export async function deleteNotification(sessionId: string, id: string): Promise<void> {
  try { await api.delete(`/api/notifications/${id}`, { params: { session_id: sessionId } }); }
  catch { /* silent */ }
}

export async function clearAllNotifications(sessionId: string): Promise<void> {
  try { await api.delete("/api/notifications", { params: { session_id: sessionId } }); }
  catch { /* silent */ }
}

// ── F47: Analytics tracking & Weekly Reports ─────────────────────────────────

import type { WeeklyReport, WeeklyReportSummary } from "./types";

/** Fire-and-forget view/compare tracking (deduplicated by caller via sessionStorage). */
export async function trackCarEvent(
  carId: string,
  eventType: "view" | "compare" | "wishlist" = "view"
): Promise<void> {
  try {
    await api.post("/api/analytics/track", { carId, eventType });
  } catch { /* silent — never block the user */ }
}

export async function fetchLatestReport(): Promise<WeeklyReport | null> {
  try {
    const { data } = await api.get<WeeklyReport>("/api/analytics/reports/latest");
    return data;
  } catch { return null; }
}

export async function fetchReportByWeek(week: string): Promise<WeeklyReport | null> {
  try {
    const { data } = await api.get<WeeklyReport>(`/api/analytics/reports/${week}`);
    return data;
  } catch { return null; }
}

export async function fetchReportsList(): Promise<WeeklyReportSummary[]> {
  try {
    const { data } = await api.get<{ reports: WeeklyReportSummary[] }>("/api/analytics/reports");
    return data.reports ?? [];
  } catch { return []; }
}

// ── F46: Ownership Cost API ───────────────────────────────────────────────────

import type { OwnershipCostResult } from "./types";

export async function fetchOwnershipCost(
  carId: string,
  params?: { kmPerYear?: number; fuelPrice?: number }
): Promise<OwnershipCostResult | null> {
  try {
    const p: Record<string, string | number> = {};
    if (params?.kmPerYear) p.km_per_year = params.kmPerYear;
    if (params?.fuelPrice) p.fuel_price  = params.fuelPrice;
    const { data } = await api.get<OwnershipCostResult>(
      `/api/ownership/${carId}`,
      { params: p }
    );
    return data;
  } catch {
    return null;
  }
}

// ── F49: Data Quality & AI Enrichment ────────────────────────────────────────

import type {
  CarQualityReport, QualityAuditSummary, QualityStats,
  EnrichmentLog,
} from "@/lib/types";

export async function fetchQualityStats(): Promise<QualityStats | null> {
  try {
    const { data } = await adminApi().get<QualityStats>("/api/quality/stats");
    return data;
  } catch { return null; }
}

export async function fetchQualityAudit(options?: {
  limit?: number;
  deficientOnly?: boolean;
}): Promise<{ summary: QualityAuditSummary; cars: CarQualityReport[] } | null> {
  try {
    const { data } = await adminApi().get("/api/quality/audit", {
      params: {
        limit:           options?.limit          ?? 500,
        deficient_only:  options?.deficientOnly  ?? false,
      },
    });
    return data;
  } catch { return null; }
}

export async function fetchCarQuality(carId: string): Promise<CarQualityReport | null> {
  try {
    const { data } = await adminApi().get<CarQualityReport>(`/api/quality/audit/${carId}`);
    return data;
  } catch { return null; }
}

export async function enrichCar(carId: string): Promise<EnrichmentLog | null> {
  try {
    const { data } = await adminApi(120_000).post<EnrichmentLog>(`/api/quality/enrich/${carId}`);
    return data;
  } catch { return null; }
}

export async function enrichBatch(limit = 10): Promise<{
  processed: number; enriched: number; avgScoreGain: number;
  results: { carId: string; carName: string; success: boolean; scoreGain: number }[];
} | null> {
  try {
    const { data } = await adminApi(300_000).post(
      "/api/quality/enrich/batch/sync",
      null,
      { params: { limit } },
    );
    return data;
  } catch { return null; }
}

export async function fetchEnrichmentLogs(options?: {
  limit?: number;
  carId?: string;
}): Promise<{ logs: EnrichmentLog[]; count: number } | null> {
  try {
    const { data } = await adminApi().get("/api/quality/logs", {
      params: {
        limit:  options?.limit ?? 50,
        car_id: options?.carId,
      },
    });
    return data;
  } catch { return null; }
}

// ── Phase 13: AI Provider Settings ───────────────────────────────────────────

export interface ProviderHealth {
  provider: string;
  status: "healthy" | "down" | "unconfigured" | "unknown" | "error";
  latency_ms: number;
  model?: string;
  last_error?: string;
  checkedAt?: string;
  configured?: boolean;
  error?: string;
}

export interface ProviderStats {
  calls: number;
  successes: number;
  failures: number;
  success_rate: number;
  configured: boolean;
}

export interface ProviderHealthExtended extends ProviderHealth {
  configured?: boolean;
  stats?: ProviderStats;
}

export interface AIStatusResponse {
  mode: "auto" | "openai" | "gemini" | "claude";
  active: string;
  openai: ProviderHealthExtended;
  gemini: ProviderHealthExtended;
  claude: ProviderHealthExtended;
  failoverEnabled: boolean;
  costOptimisation: boolean;
  generatedAt: string;
}

export interface AIHealthCheckResult {
  checkedAt: string;
  openai: ProviderHealth;
  gemini: ProviderHealth;
  claude: ProviderHealth;
}

export interface DebugProvidersResult {
  openai: boolean;
  gemini: boolean;
  claude: boolean;
  active: string;
  mode: string;
  providers: Record<string, ProviderHealthExtended & { configured: boolean }>;
  stats: Record<string, ProviderStats>;
  checkedAt: string;
}

export interface DebugTestResult {
  provider: string;
  model: string;
  status: "success" | "failed";
  tokens_generated?: string;
  blog_generated: boolean;
  content?: string;
  latency_ms?: number;
  task_type: string;
  generatedAt: string;
  error?: string;
}

export async function fetchAIStatus(): Promise<AIStatusResponse> {
  const { data } = await adminApi().get<AIStatusResponse>("/api/ai/status");
  return data;
}

export async function runAIHealthCheck(): Promise<AIHealthCheckResult> {
  const { data } = await adminApi().post<AIHealthCheckResult>("/api/ai/health/check");
  return data;
}

export async function setAIProviderMode(
  mode: "auto" | "openai" | "gemini" | "claude"
): Promise<{ success: boolean; previous: string; current: string; message: string }> {
  const { data } = await adminApi().post("/api/ai/settings/mode", { mode });
  return data;
}

export type CarImageSource = "google" | "serpapi" | "bing" | "manual";

export interface CarImageSourceSettings {
  source: CarImageSource;
  default: CarImageSource;
  validSources: CarImageSource[];
  providers: { google: boolean; serpapi: boolean; bing: boolean };
  anyConfigured: boolean;
}

export async function fetchCarImageSource(): Promise<CarImageSourceSettings> {
  const { data } = await adminApi().get<CarImageSourceSettings>("/api/ai/settings/image-source");
  return data;
}

export async function setCarImageSource(
  source: CarImageSource
): Promise<{ success: boolean; previous: string; current: string; message: string }> {
  const { data } = await adminApi().post("/api/ai/settings/image-source", { source });
  return data;
}

export async function fetchAIHealthHistory(
  limit = 20
): Promise<{ records: { checkedAt: string; mode: string; results: Record<string, ProviderHealth> }[] }> {
  const { data } = await adminApi().get("/api/ai/health/history", { params: { limit } });
  return data;
}

export async function fetchDebugProviders(): Promise<DebugProvidersResult> {
  const { data } = await adminApi().get<DebugProvidersResult>("/api/debug/providers");
  return data;
}

export async function runDebugTest(
  prompt = "Write a 3-sentence blog intro about Mahindra Thar",
  taskType = "blog"
): Promise<DebugTestResult> {
  const { data } = await adminApi().post<DebugTestResult>("/api/debug/test", {
    prompt,
    task_type: taskType,
  });
  return data;
}

// ── Hero Banners ─────────────────────────────────────────────────────────────

export interface HeroBanner {
  id: string;
  title: string;
  subtitle?: string;
  description?: string;
  imageDesktop: string;
  imageMobile?: string;
  buttonText?: string;
  buttonUrl?: string;
  priority: number;
  isActive: boolean;
  startDate?: string;
  endDate?: string;
  createdAt?: string;
}

/** Public — active banners for the homepage hero slider */
export async function fetchActiveBanners(): Promise<{ banners: HeroBanner[]; total: number }> {
  const { data } = await api.get<{ banners: HeroBanner[]; total: number }>("/api/banners/active");
  return data;
}

/** Admin — all banners regardless of active state */
export async function fetchAllBanners(): Promise<{ banners: HeroBanner[]; total: number }> {
  const { data } = await adminApi().get<{ banners: HeroBanner[]; total: number }>("/api/banners");
  return data;
}

// ── Ad Slots ─────────────────────────────────────────────────────────────────

export interface AdSlotData {
  id: string;
  slot: string;
  image?: string;
  targetUrl?: string;
  altText?: string;
  active: boolean;
  startDate?: string;
  endDate?: string;
  createdAt?: string;
}

/** Public — get the active ad for a specific slot (null if no ad configured) */
export async function fetchActiveAd(
  slotName: string
): Promise<{ ad: AdSlotData | null }> {
  const { data } = await api.get<{ ad: AdSlotData | null }>(`/api/ads/slot/${slotName}`);
  return data;
}

export default api;