import AuthService from "../services/AuthService";
const API_BASE =
  process.env.NEXT_PUBLIC_API_URL || "https://45.93.137.91.nip.io/api";
const REPORT_API_BASE =
  process.env.NEXT_PUBLIC_API_URL || "http://45.93.137.91/api";

function isFormData(value) {
  return typeof FormData !== "undefined" && value instanceof FormData;
}

class ApiBlockedError extends Error {
  constructor(message = "Your account is blocked") {
    super(message);
    this.name = "ApiBlockedError";
    this.status = 451;
  }
}

export function isApiBlockedError(error) {
  return error instanceof ApiBlockedError || error?.status === 451;
}

function redirectToBlockedPage() {
  if (
    typeof window !== "undefined" &&
    window.location.pathname !== "/blocked"
  ) {
    window.location.replace("/blocked");
  }
}

function assertNotBlocked(response) {
  if (response.status === 451) {
    redirectToBlockedPage();
    throw new ApiBlockedError();
  }
}

function buildApiUrl(base, endpoint) {
  return `${base.replace(/\/$/, "")}${endpoint.startsWith("/") ? endpoint : `/${endpoint}`}`;
}

/**
 * Generic API fetch — attaches auth token, unwraps { data } envelope
 */
async function apiFetch(endpoint, options = {}) {
  const token = AuthService.getToken();

  const headers = {
    ...(token && { Authorization: `Bearer ${token}` }),
    ...(options.headers || {}),
  };

  const hasBody = options.body != null;
  const bodyIsFormData = isFormData(options.body);

  if (
    hasBody &&
    !bodyIsFormData &&
    !headers["Content-Type"] &&
    !headers["content-type"]
  ) {
    headers["Content-Type"] = "application/json";
  }

  const url = `${API_BASE}${endpoint}`;

  const res = await fetch(url, {
    ...options,
    headers,
    body:
      hasBody && !bodyIsFormData && typeof options.body !== "string"
        ? JSON.stringify(options.body)
        : options.body,
  });

  assertNotBlocked(res);

  if (!res.ok && res.status !== 206) {
    const text = await res.text().catch(() => "");
    throw new Error(`API ${res.status}: ${text || res.statusText}`);
  }

  const text = await res.text();
  if (!text) return null;

  try {
    const json = JSON.parse(text);
    if (json && typeof json === "object" && "data" in json) {
      return json.data;
    }
    return json;
  } catch {
    return text;
  }
}

/**
 * Auth fetch — returns full { status, data, ok } for status-code handling
 */
async function authFetch(endpoint, body, token = null) {
  const headers = {};

  const bodyIsFormData = isFormData(body);
  if (!bodyIsFormData) {
    headers["Content-Type"] = "application/json";
  }

  if (token) {
    headers["Authorization"] = `Bearer ${token}`;
  }

  const res = await fetch(`${API_BASE}${endpoint}`, {
    method: "POST",
    headers,
    body: bodyIsFormData ? body : JSON.stringify(body),
  });

  assertNotBlocked(res);

  const text = await res.text();
  let data = null;

  try {
    data = text ? JSON.parse(text) : null;
    if (data && typeof data === "object" && "data" in data) {
      data = data.data;
    }
  } catch {
    data = text;
  }

  const message =
    typeof data === "object" && data?.message ? data.message : null;

  return {
    status: res.status,
    data,
    ok: res.ok || res.status === 206,
    message,
  };
}

async function reportFetch(endpoint, body) {
  const res = await fetch(buildApiUrl(REPORT_API_BASE, endpoint), {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  });

  assertNotBlocked(res);

  const text = await res.text();
  let data = null;

  try {
    data = text ? JSON.parse(text) : null;
    if (data && typeof data === "object" && "data" in data) {
      data = data.data;
    }
  } catch {
    data = text;
  }

  const message =
    typeof data === "object" && data?.message ? data.message : null;

  return {
    status: res.status,
    data,
    ok: res.ok || res.status === 206,
    message,
  };
}

// ─── Rent Properties ───

export async function getRentProperties() {
  return apiFetch("/RentProperties/GetRentProperties");
}

export async function getRentProperty(id) {
  return apiFetch(`/RentProperties/GetRentPropertyById/${id}`);
}

export async function getRentPropertyLocations(params = {}) {
  const qs = new URLSearchParams();
  if (params.maxOffset != null) qs.set("maxOffset", params.maxOffset);
  if (params.minOffset != null) qs.set("minOffset", params.minOffset);
  const query = qs.toString();
  return apiFetch(
    `/RentProperties/GetRentPropertiesLocations${query ? `?${query}` : ""}`,
  );
}

// ─── Sale Properties ───

export async function getSaleProperties() {
  return apiFetch("/SaleProperties/GetSaleProperties");
}

export async function getSaleProperty(id) {
  const items = await apiFetch("/SaleProperties/GetSaleProperties");
  if (!Array.isArray(items)) return items;
  return items.find((p) => p.id == id) || items[0];
}

// ─── Properties (generic) ───

export async function getProperty(id) {
  return apiFetch(`/Properties/Get/${id}`);
}

// ─── Recommendations ───

export async function getRecommendations() {
  return apiFetch("/Recommendations/GetRecommendations");
}

export async function getTopRecommendations(count = 10) {
  return apiFetch(`/Recommendations/GetTopRecommendations?count=${count}`);
}

// ─── Reservations ───

export async function getAvailableDateRanges(
  propertyId,
  fromDate = null,
  toDate = null,
) {
  const qs = new URLSearchParams();
  if (fromDate) qs.set("fromDate", fromDate);
  if (toDate) qs.set("toDate", toDate);
  const query = qs.toString();

  return apiFetch(
    `/Reservations/GetAvailableDates/available/${propertyId}${query ? `?${query}` : ""}`,
  );
}

export async function getReservations() {
  return apiFetch("/Reservations/GetAllReservations");
}

export async function getReservation(id) {
  return apiFetch(`/Reservations/GetReservation?id=${id}`);
}

export async function checkAvailability(
  propertyId,
  fromDate = null,
  toDate = null,
) {
  const qs = new URLSearchParams();
  if (fromDate) qs.set("fromDate", fromDate);
  if (toDate) qs.set("toDate", toDate);
  const query = qs.toString();
  return apiFetch(
    `/Reservations/GetAvailable/${propertyId}${query ? `?${query}` : ""}`,
  );
}

export async function bookReservation(propertyInfoId, startDate, endDate) {
  return apiFetch("/Reservations/BookReservation/book", {
    method: "POST",
    body: {
      propertyInfoId,
      startDate,
      endDate,
    },
  });
}

// ─── Terms ───

export async function getARTerms() {
  return apiFetch("/Configuration/GetARTerms");
}

export async function getENTerms() {
  return apiFetch("/Configuration/GetENTerms");
}

// ─── Profile ───

export async function getCustomerByUserId(userId) {
  return apiFetch(`/Customer/GetByUserId/${userId}`);
}

export async function getOwnerByUserId(userId) {
  return apiFetch(`/Owner/GetByUserId/${userId}`);
}

// ─── Properties ───

export async function getMyRentListings() {
  return apiFetch("/RentProperties/GetMyRentListings");
}

export async function addRentProperty(data) {
  return apiFetch("/RentProperties/AddRentProperty", {
    method: "POST",
    body: data,
  });
}

export async function editRentProperty(id, data) {
  return apiFetch(`/RentProperties/EditRentProperty/${id}`, {
    method: "PUT",
    body: data,
  });
}

export async function editSaleProperty(id, data) {
  return apiFetch(`/SaleProperties/EditSaleProperty/${id}`, {
    method: "PUT",
    body: data,
  });
}

export async function addSaleProperty(data) {
  return apiFetch("/SaleProperties/AddSaleProperty", {
    method: "POST",
    body: data,
  });
}

export async function getMySaleListings() {
  return apiFetch("/SaleProperties/GetMySaleListings");
}

export async function getSalePropertyById(id) {
  return apiFetch(`/SaleProperties/${id}`);
}

export async function updateRentPropertyStatus(id, status) {
  return apiFetch(`/RentProperties/UpdateStatus/${id}`, {
    method: "PUT",
    body: { status },
  });
}

export async function updateSalePropertyStatus(id, status) {
  return apiFetch(`/SaleProperties/UpdateStatus/${id}`, {
    method: "PUT",
    body: { status },
  });
}

// ─── Currencies ───

export async function getCurrencies() {
  return apiFetch("/Currency/GetAll");
}

// ─── Files ───

export async function uploadPicture(file) {
  const formData = new FormData();
  formData.append("image", file);

  const token = AuthService.getToken();

  const res = await fetch(`${API_BASE}/Files/UploadPicture`, {
    method: "POST",
    headers: {
      ...(token && { Authorization: `Bearer ${token}` }),
    },
    body: formData,
  });

  assertNotBlocked(res);

  const text = await res.text();

  if (!res.ok) throw new Error(`Upload failed: ${res.status} ${text}`);

  try {
    const json = JSON.parse(text);
    return json?.data || json;
  } catch {
    return text;
  }
}

// ─── Auth: Registration ───

async function multipartAuthFetch(endpoint, formData) {
  const token = AuthService.getToken();

  const res = await fetch(`${API_BASE}${endpoint}`, {
    method: "POST",
    headers: {
      ...(token && { Authorization: `Bearer ${token}` }),
    },
    body: formData,
  });

  assertNotBlocked(res);

  const text = await res.text();
  let data = null;

  try {
    data = text ? JSON.parse(text) : null;
    if (data && typeof data === "object" && "data" in data) {
      data = data.data;
    }
  } catch {
    data = text;
  }

  return {
    status: res.status,
    data,
    ok: res.ok || res.status === 206,
    message: data?.message,
  };
}

export async function addOwner(
  data,
  frontImage = null,
  backImage = null,
  licenseImage = null,
) {
  const formData = new FormData();

  formData.append("FirstName", data.firstName || data.FirstName || "");
  formData.append("LastName", data.lastName || data.LastName || "");
  formData.append("Email", data.email || data.Email || "");

  const phoneValue =
    data.phone || data.phoneNumber || data.Phone || data.PhoneNumber || "";
  const whatsappValue =
    data.whatsAppNumber ||
    data.whatsapp ||
    data.WhatsAppNumber ||
    data.WhatsApp ||
    "";

  formData.append("PhoneNumber", phoneValue);
  formData.append("Phone", phoneValue);
  formData.append("WhatsAppNumber", whatsappValue);

  formData.append(
    "NationalNumber",
    data.nationalNumber || data.NationalNumber || "",
  );
  formData.append("Password", data.password || data.Password || "");
  formData.append(
    "Type",
    String(data.type ?? data.ownerType ?? data.Type ?? 0),
  );
  formData.append("Language", String(data.language ?? data.Language ?? 1));

  if (frontImage) formData.append("FrontIdCarImagePath", frontImage);
  if (backImage) formData.append("RearIdCarImagePath", backImage);
  if (licenseImage) formData.append("LicenseImagePath", licenseImage);

  return multipartAuthFetch("/Owner/Add", formData);
}

export async function addCustomer(data, frontImage = null, backImage = null) {
  const formData = new FormData();
  formData.append("FirstName", data.firstName || data.FirstName || "");
  formData.append("LastName", data.lastName || data.LastName || "");
  formData.append("Email", data.email || "");
  formData.append("PhoneNumber", data.phoneNumber || "");
  formData.append("WhatsAppNumber", data.whatsAppNumber || "");
  formData.append("Phone", data.phone || "");
  formData.append("NationalNumber", data.nationalNumber || "");
  formData.append("Password", data.password || "");
  formData.append("Type", String(data.customerType ?? data.Type ?? 0));
  formData.append("Language", "0");

  if (frontImage) formData.append("FrontIdCarImagePath", frontImage);
  if (backImage) formData.append("RearIdCarImagePath", backImage);

  return multipartAuthFetch("/Customer/Add", formData);
}

// ─── Auth: Login ───

export async function loginWithEmail(credential, password) {
  return authFetch("/Auth/LogInWithEmail", {
    credential,
    password,
    device: 0,
    appVersion: "",
  });
}

export async function loginWithPhone(credential, password) {
  return authFetch("/Auth/LogInWithPhoneNumber", {
    credential,
    password,
    device: 0,
    appVersion: "",
  });
}

// ─── Auth: OTP ───

export async function sendEmailOTP() {
  return apiFetch("/Auth/SendEmailOTP", { method: "POST" });
}

export async function sendPhoneOTP() {
  return apiFetch("/Auth/SendPhoneNumberOTP", { method: "POST" });
}

export async function verifyEmail(code) {
  const token = AuthService.getToken();
  return authFetch(
    `/Auth/VerifyEmail?code=${encodeURIComponent(code)}`,
    {},
    token,
  );
}

export async function verifyPhone(code) {
  const token = AuthService.getToken();
  return authFetch(
    `/Auth/VerifyPhoneNumber?code=${encodeURIComponent(code)}`,
    {},
    token,
  );
}

// ─── Helpers ───

export function isEmail(value) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
}

export function isPhoneNumber(value) {
  return /^\+?\d{7,15}$/.test(value.replace(/[\s\-()]/g, ""));
}

// ─── Favorites ───

export async function getUserFavoriteProperties() {
  return apiFetch("/FavoriteProperty/GetUserFavoriteProperties");
}

export async function addFavoriteProperty(propId) {
  return apiFetch(`/FavoriteProperty/Add?propId=${propId}`, { method: "POST" });
}

export async function removeFavoriteProperty(favePropId) {
  return apiFetch(`/FavoriteProperty/Remove?favePropId=${favePropId}`, {
    method: "DELETE",
  });
}

export async function getUserNotifications() {
  return apiFetch("/Notifications/GetUserNotifications");
}

// ─── Booking/Reservation Management ───

export async function confirmDepositPayment(bookingId) {
  return apiFetch("/Reservations/ConfirmDepositPayment", {
    method: "POST",
    body: { bookingId },
  });
}

export async function adminConfirmDeposit(
  reservationId,
  adminId,
  comment = null,
) {
  const token = AuthService.getToken();
  const endpoint = `${API_BASE}/Reservations/AdminConfirmDeposit/admin-confirm-deposit`;
  const normalizedComment =
    typeof comment === "string" && comment.trim() ? comment.trim() : null;
  const payload = {
    reservationId,
    adminId,
    comment: normalizedComment,
  };

  const res = await fetch(endpoint, {
    method: "PUT",
    headers: {
      "Content-Type": "application/json",
      ...(token && { Authorization: `Bearer ${token}` }),
    },
    body: JSON.stringify(payload),
  });

  const text = await res.text();
  let data = null;

  try {
    data = text ? JSON.parse(text) : null;
    if (data && typeof data === "object" && "data" in data) {
      data = data.data;
    }
  } catch {
    data = text;
  }

  const message =
    typeof data === "object" && data?.message ? data.message : null;

  return { status: res.status, data, ok: res.ok, message };
}

export async function updateBookingStatus(bookingId, status) {
  return apiFetch("/Reservations/UpdateStatus", {
    method: "PUT",
    body: { bookingId, status },
  });
}

// ─── Owner / Reservations ───

export async function getOwnerReservationRequests() {
  return apiFetch("/Reservations/GetOwnerResevationRequests");
}

export async function getOwnerReservationsByStatuses(filterStatuses) {
  return apiFetch("/Reservations/GetAllReservationsByStateForOwner", {
    method: "POST",
    body: { filterStatuses },
  });
}

export async function getUserReservations() {
  return apiFetch("/Reservations/GetUserResevations");
}

export async function ownerConfirmReservation(id) {
  return apiFetch(`/Reservations/OwnerConfirmReservation/owner-confirm/${id}`, {
    method: "PUT",
  });
}

// ─── Payments ───

export async function payDeposit(data) {
  return apiFetch("/Reservations/PayDeposit/pay-deposit", {
    method: "POST",
    body: data,
  });
}

export async function getMyTransaction() {
  return apiFetch("/Customer/GetMyTransaction");
}

// ─── Owner Contact & Stats ───

export async function getOwnerContactInformation(propertyInformationId) {
  return apiFetch(
    `/Owner/GetOwnerContactInformation?propertyInformationId=${propertyInformationId}`,
  );
}

export async function getOwnerStatistics() {
  return apiFetch("/Statistics/GetOwnerStatistics");
}

// ─── Agent Registration ───

export async function registerRealEstateAgent(formData) {
  const token = AuthService.getToken();

  const res = await fetch(`${API_BASE}/RealEstateAgent/Add`, {
    method: "POST",
    headers: {
      ...(token && { Authorization: `Bearer ${token}` }),
    },
    body: formData,
  });

  assertNotBlocked(res);

  const text = await res.text();
  let data = null;

  try {
    data = text ? JSON.parse(text) : null;
    if (data && typeof data === "object" && "data" in data) data = data.data;
  } catch {
    data = text;
  }

  return {
    status: res.status,
    data,
    ok: res.ok || res.status === 206,
    message: data?.message || (typeof data === "string" ? data : null),
  };
}

// ─── Change Password ───

export async function changePassword(oldPassword, newPassword) {
  return apiFetch(
    `/User/ChangePassword?oldPassword=${encodeURIComponent(oldPassword)}&newPassword=${encodeURIComponent(newPassword)}`,
    {
      method: "PUT",
    },
  );
}

// ─── Forget Password (OTP flow) ───

export async function requestForgetPasswordOtp(email) {
  return apiFetch(`/User/ForgetPassword?email=${encodeURIComponent(email)}`, {
    method: "POST",
  });
}

export async function verifyForgetPasswordOtp(email, code, newPassword) {
  return apiFetch(
    `/User/VerifyForgetPasswordOTP?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code)}&newPassword=${encodeURIComponent(newPassword)}`,
    {
      method: "POST",
    },
  );
}

// ─── Reset Password (token flow) ───

export async function resetPassword(token) {
  return apiFetch(`/Auth/ResetPassword?token=${encodeURIComponent(token)}`);
}

// ─── Delete Account ───

export async function deleteMyAccount(password) {
  return apiFetch(
    `/User/DeleteMyAccount?password=${encodeURIComponent(password)}`,
    {
      method: "DELETE",
    },
  );
}

// ─── Set FCM Token ───

export async function setFCMToken(token, deviceType = 2) {
  return apiFetch("/User/SetFCMToken", {
    method: "POST",
    body: { token, deviceType },
  });
}

// ─── Filter Rent Properties ───

export async function filterRentProperties(params = {}) {
  const qs = new URLSearchParams();
  Object.entries(params).forEach(([k, v]) => {
    if (v != null && v !== "") qs.set(k, v);
  });
  const query = qs.toString();
  return apiFetch(
    `/RentProperties/FilterRentProperties${query ? `?${query}` : ""}`,
  );
}

// ─── Reports ───

export async function sendGeneralReport(subject, reportBody) {
  return reportFetch("/Reports/SendGeneralReport", {
    subject,
    body: reportBody,
  });
}

export async function submitReport(subject, body) {
  return apiFetch("/Reports/SendGeneralReport", {
    method: "POST",
    body: { subject, body },
  });
}

export async function submitReservationReport(data) {
  return apiFetch("/ReservationReports", {
    method: "POST",
    body: data,
  });
}

export async function updateReservationReport(id, data) {
  return apiFetch(`/ReservationReports/${id}`, {
    method: "PUT",
    body: data,
  });
}

export async function submitSaleReport(data) {
  return apiFetch("/SaleReports", {
    method: "POST",
    body: data,
  });
}

export async function updateSaleReport(id, data) {
  return apiFetch(`/SaleReports/${id}`, {
    method: "PUT",
    body: data,
  });
}

// ─── Terms (Add or Update) ───

export async function addOrUpdateTerms(terms) {
  return apiFetch("/Terms/AddOrUpdateTerms", {
    method: "POST",
    body: terms,
  });
}