admin / Bid-Sentinel

import axios from "axios";

// Defaults to the same-origin "/api" path, which nginx reverse-proxies to the
// backend (see frontend/nginx.conf). This works whether the app is opened on the
// Docker host or any remote machine. Override with VITE_API_BASE_URL only if you
// run the frontend dev server separately (e.g. "http://localhost:8000").
const BASE_URL = import.meta.env.VITE_API_BASE_URL || "/api";
const TOKEN_KEY = "ctt_token";

export const tokenStore = {
  get: () => localStorage.getItem(TOKEN_KEY),
  set: (t) => localStorage.setItem(TOKEN_KEY, t),
  clear: () => localStorage.removeItem(TOKEN_KEY),
};

const api = axios.create({ baseURL: BASE_URL });

// Attach the JWT to every request (persistent session via localStorage).
api.interceptors.request.use((config) => {
  const token = tokenStore.get();
  if (token) config.headers.Authorization = `Bearer ${token}`;
  return config;
});

// On 401, clear the stale token and bounce to login.
api.interceptors.response.use(
  (res) => res,
  (error) => {
    if (error.response?.status === 401) {
      tokenStore.clear();
      if (window.location.pathname !== "/login") {
        window.location.assign("/login");
      }
    }
    return Promise.reject(error);
  }
);

// --- Auth -----------------------------------------------------------------
export async function getSetupStatus() {
  const { data } = await api.get("/auth/setup-status");
  return data; // { needs_setup: boolean }
}

export async function setupAdmin({ email, full_name, password }) {
  const { data } = await api.post("/auth/setup", { email, full_name, password });
  tokenStore.set(data.access_token);
  return data;
}

export async function login(email, password) {
  // OAuth2PasswordRequestForm expects form-encoded username/password.
  const form = new URLSearchParams();
  form.append("username", email);
  form.append("password", password);
  const { data } = await api.post("/auth/login", form, {
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
  });
  tokenStore.set(data.access_token);
  return data;
}

export async function fetchMe() {
  const { data } = await api.get("/auth/me");
  return data;
}

// --- Tenders --------------------------------------------------------------
export async function fetchTenders(params = {}) {
  const { data } = await api.get("/tenders", { params });
  return data;
}

export async function createTender(payload) {
  const { data } = await api.post("/tenders", payload);
  return data;
}

export async function updateTender(tenderId, payload) {
  const { data } = await api.patch(`/tenders/${tenderId}`, payload);
  return data;
}

export async function deleteTender(tenderId) {
  const { data } = await api.delete(`/tenders/${tenderId}`);
  return data; // { batch_id }
}

export async function bulkDeleteTenders(ids) {
  const { data } = await api.post("/tenders/bulk-delete", { ids });
  return data; // { deleted, suppressed, batch_id }
}

export async function undoDelete(batchId) {
  const { data } = await api.post(`/tenders/undo/${batchId}`);
  return data; // { restored }
}

export async function updateBidStatus(tenderId, bidStatus) {
  const { data } = await api.patch(`/tenders/${tenderId}/status`, {
    bid_status: bidStatus,
  });
  return data;
}

export async function updateOutcome(tenderId, outcome) {
  const { data } = await api.patch(`/tenders/${tenderId}/outcome`, { outcome });
  return data;
}

export async function fetchComments(tenderId) {
  const { data } = await api.get(`/tenders/${tenderId}/comments`);
  return data;
}

export async function addComment(tenderId, body) {
  const { data } = await api.post(`/tenders/${tenderId}/comments`, { body });
  return data;
}

export async function deleteComment(tenderId, commentId) {
  await api.delete(`/tenders/${tenderId}/comments/${commentId}`);
}

// --- Audit trail (admin) --------------------------------------------------
export async function fetchAudit(limit = 200) {
  const { data } = await api.get("/audit", { params: { limit } });
  return data;
}

export async function triggerScrape() {
  const { data } = await api.post("/tenders/scrape");
  return data;
}

// --- Users (admin / RBAC) -------------------------------------------------
export async function fetchUsers() {
  const { data } = await api.get("/users");
  return data;
}

export async function createUser(payload) {
  const { data } = await api.post("/users", payload);
  return data;
}

export async function updateUser(id, payload) {
  const { data } = await api.patch(`/users/${id}`, payload);
  return data;
}

export async function deleteUser(id) {
  await api.delete(`/users/${id}`);
}

// --- Portals --------------------------------------------------------------
export async function fetchPortals() {
  const { data } = await api.get("/config/portals");
  return data;
}

export async function setPortalEnabled(key, enabled) {
  const { data } = await api.patch(`/config/portals/${key}`, { enabled });
  return data;
}

export async function addPortal({ name, url, scope }) {
  const { data } = await api.post("/config/portals", { name, url, scope });
  return data;
}

export async function deletePortal(key) {
  await api.delete(`/config/portals/${key}`);
}

// --- Keywords -------------------------------------------------------------
export async function fetchKeywords() {
  const { data } = await api.get("/config/keywords");
  return data; // { builtin: [...], custom: [{id, keyword}] }
}

export async function addKeyword(keyword) {
  const { data } = await api.post("/config/keywords", { keyword });
  return data;
}

export async function deleteKeyword(id) {
  await api.delete(`/config/keywords/${id}`);
}

// --- CPV codes (scrape criteria) ------------------------------------------
export async function fetchCpvCodes() {
  const { data } = await api.get("/config/cpv");
  return data; // [{id, code, description}]
}

export async function addCpvCode({ code, description }) {
  const { data } = await api.post("/config/cpv", { code, description });
  return data;
}

export async function setCpvEnabled(id, enabled) {
  const { data } = await api.patch(`/config/cpv/${id}`, { enabled });
  return data;
}

export async function deleteCpvCode(id) {
  await api.delete(`/config/cpv/${id}`);
}

export async function fetchCpvStrict() {
  const { data } = await api.get("/config/cpv-strict");
  return data; // { strict }
}

export async function setCpvStrict(strict) {
  const { data } = await api.patch("/config/cpv-strict", { strict });
  return data;
}

// --- Tune-out list (negative filter) --------------------------------------
export async function fetchTuneOuts() {
  const { data } = await api.get("/config/tuneout");
  return data; // [{id, term}]
}

export async function addTuneOut(term) {
  const { data } = await api.post("/config/tuneout", { term });
  return data; // { term: {id, term}, removed }
}

export async function deleteTuneOut(id) {
  await api.delete(`/config/tuneout/${id}`);
}

// --- Schedule -------------------------------------------------------------
export async function fetchSchedule() {
  const { data } = await api.get("/config/schedule");
  return data; // { timezone, slots: [...], next_run }
}

export async function addScheduleSlots(days, times) {
  const { data } = await api.post("/config/schedule", { days, times });
  return data;
}

export async function toggleScheduleSlot(id, enabled) {
  const { data } = await api.patch(`/config/schedule/${id}`, { enabled });
  return data;
}

export async function deleteScheduleSlot(id) {
  await api.delete(`/config/schedule/${id}`);
}

// --- Capability profile & analysis (deterministic, non-AI) ----------------
export async function fetchCapabilities() {
  const { data } = await api.get("/config/capabilities");
  return data; // { terms: [{id, term}] }
}

export async function addCapability(term) {
  const { data } = await api.post("/config/capabilities", { term });
  return data;
}

export async function deleteCapability(id) {
  await api.delete(`/config/capabilities/${id}`);
}

export async function uploadCapabilityDoc(file) {
  const form = new FormData();
  form.append("file", file);
  const { data } = await api.post("/config/capabilities/upload", form, {
    headers: { "Content-Type": "multipart/form-data" },
  });
  return data; // { filename, extracted_chars, suggested, detected_certs }
}

export async function fetchCertLexicon() {
  const { data } = await api.get("/config/certs");
  return data; // string[]
}

export async function recomputeAnalysis() {
  const { data } = await api.post("/config/recompute");
  return data; // { updated, message }
}

// --- AI bolt-on -----------------------------------------------------------
export async function fetchAiConfig() {
  const { data } = await api.get("/config/ai");
  return data; // { enabled, available, model }
}

export async function setAiEnabled(enabled) {
  const { data } = await api.patch("/config/ai", { enabled });
  return data;
}

// --- Accreditations held --------------------------------------------------
export async function fetchAccreditations() {
  const { data } = await api.get("/config/accreditations");
  return data;
}
export async function addAccreditation(name) {
  const { data } = await api.post("/config/accreditations", { name });
  return data;
}
export async function deleteAccreditation(id) {
  await api.delete(`/config/accreditations/${id}`);
}

// --- Intelligence (analyst) -----------------------------------------------
export async function fetchIntelSummary() {
  const { data } = await api.get("/intelligence/summary");
  return data;
}
export async function fetchCapabilityGaps() {
  const { data } = await api.get("/intelligence/capability-gaps");
  return data;
}
export async function fetchCertGaps() {
  const { data } = await api.get("/intelligence/cert-gaps");
  return data;
}
export async function fetchBuyers() {
  const { data } = await api.get("/intelligence/buyers");
  return data;
}
export async function fetchWinLoss() {
  const { data } = await api.get("/intelligence/winloss");
  return data;
}
export async function fetchTrends() {
  const { data } = await api.get("/intelligence/trends");
  return data;
}
export async function fetchAngles(useAi = false) {
  const { data } = await api.get("/intelligence/angles", { params: { use_ai: useAi } });
  return data;
}
export async function fetchIntelReportBlob(useAi = false) {
  const resp = await api.get("/intelligence/report.pdf", {
    params: { use_ai: useAi },
    responseType: "blob",
  });
  return new Blob([resp.data], { type: "application/pdf" });
}

export async function downloadIntelReport(useAi = false) {
  const blob = await fetchIntelReportBlob(useAi);
  triggerDownload(blob, "bid-sentinel-intelligence.pdf");
}

// --- Management summary report --------------------------------------------
export async function fetchManagementSummaryBlob() {
  const resp = await api.get("/intelligence/management-summary.pdf", {
    responseType: "blob",
  });
  return new Blob([resp.data], { type: "application/pdf" });
}

export async function downloadManagementSummary() {
  const blob = await fetchManagementSummaryBlob();
  triggerDownload(blob, "bid-sentinel-management-summary.pdf");
}

function triggerDownload(blob, filename) {
  const url = URL.createObjectURL(blob);
  const a = document.createElement("a");
  a.href = url;
  a.download = filename;
  document.body.appendChild(a);
  a.click();
  document.body.removeChild(a);
  URL.revokeObjectURL(url);
}

// --- Email me this --------------------------------------------------------
export async function fetchEmailStatus() {
  const { data } = await api.get("/email/status");
  return data; // { available }
}

export async function emailReport(blob, filename, subject) {
  const form = new FormData();
  form.append("file", blob, filename);
  form.append("subject", subject || "Bid Sentinel report");
  const { data } = await api.post("/email/report", form, {
    headers: { "Content-Type": "multipart/form-data" },
  });
  return data; // { sent, to }
}

export default api;