/*
|--------------------------------------------------------------------------
| Block / unblock astrologers (customer app)
|--------------------------------------------------------------------------
| Proxied through app/api/user/astrologer/{block,blocked-list,unblock}.
|   block         { astrologerId, reason (max 1000) }
|   blocked-list  { start, limit }   -> { recordList: [...], totalRecords }
|   unblock       { astrologerId, remark (max 500) }
| Success bodies use a numeric `status: 200`; failures are 4xx with a message
| (404 astrologer not found / not blocked, 409 already blocked, 400 validation).
| Blocked astrologers are also filtered out of POST /user/astrologers/list by
| the backend, so no client-side filtering is needed there.
*/

import { getAuthToken } from "./auth-token";

export const BLOCK_REASON_MAX = 1000;
export const UNBLOCK_REMARK_MAX = 500;

export interface BlockedAstrologer {
  blockId: number | null;
  astrologerId: number;
  name: string;
  profileImage: string;
  reason: string;
  blockedAt: string | null;
}

interface CallResult {
  success: boolean;
  message: string;
  data: any;
}

async function call(path: string, body: Record<string, unknown>): Promise<CallResult> {
  const token = getAuthToken();

  if (!token) {
    return { success: false, message: "Please sign in to continue.", data: null };
  }

  try {
    const response = await fetch(`/api/user/astrologer/${path}`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Accept: "application/json",
        Authorization: token.startsWith("Bearer ") ? token : `Bearer ${token}`,
      },
      body: JSON.stringify(body),
      cache: "no-store",
    });

    const text = await response.text();

    let data: any = {};

    try {
      data = text ? JSON.parse(text) : {};
    } catch {
      data = { message: text };
    }

    const statusCode = typeof data?.status === "number" ? data.status : response.status;

    return {
      success: response.ok && statusCode < 400 && data?.success !== false && data?.status !== false,
      message: typeof data?.message === "string" ? data.message : "",
      data,
    };
  } catch {
    return { success: false, message: "Unable to reach the server. Please try again.", data: null };
  }
}

export async function blockAstrologer(astrologerId: number, reason: string) {
  return call("block", { astrologerId: Number(astrologerId), reason: reason.trim() });
}

export async function unblockAstrologer(astrologerId: number, remark: string) {
  return call("unblock", { astrologerId: Number(astrologerId), remark: remark.trim() });
}

export async function getBlockedAstrologers(start = 0, limit = 100) {
  const result = await call("blocked-list", { start, limit });

  const list = result.data?.recordList ?? result.data?.data?.recordList ?? result.data?.data ?? [];

  const items: BlockedAstrologer[] = (Array.isArray(list) ? list : []).map((r: any) => ({
    blockId: Number(r.blockId ?? r.id ?? 0) || null,
    astrologerId: Number(r.astrologerId ?? r.astrologer_id ?? 0),
    name: String(r.name ?? ""),
    profileImage: String(r.profileImage ?? r.profile_image ?? ""),
    reason: String(r.reason ?? ""),
    blockedAt: r.blockedAt ?? r.blocked_at ?? null,
  }));

  return {
    success: result.success,
    message: result.message,
    items: items.filter((item) => item.astrologerId > 0),
    total: Number(result.data?.totalRecords ?? result.data?.total ?? items.length),
  };
}

// Profile images come back as storage paths ("public/storage/images/x.png").
export function blockedAstrologerImage(path: string): string {
  if (!path) return "";

  if (/^https?:\/\//i.test(path)) return path;

  return `https://api.astrology.togwe.com/${path.replace(/^\//, "")}`;
}
