import { createCoreAPIClient } from "@/lib/features/coreClient";
import type { CoreAPIPagination } from "../types";
import type {
  CoreMember,
  CoreMemberAccountType,
  CoreMemberDetailed,
  CoreMemberActivityLog,
  CoreMemberSavedSearch,
  CoreMemberSession,
  CoreMembership,
  VpAccountDetails,
} from "./types";
const coreClient = createCoreAPIClient();

export async function searchMembers(
  page = 1,
  pageSize = 15,
  search?: string,
  headers?: HeadersInit,
) {
  const params = new URLSearchParams();
  params.set("page", page.toString());
  params.set("pageSize", pageSize.toString());
  if (search) {
    params.set("searchTerm", search);
  }

  const response = await coreClient<{
    members: CoreMember[];
    pagination: CoreAPIPagination;
  }>(`/v1/admin/members/search?${params.toString()}`, { headers });
  return response;
}

export interface MembershipSearchFilters {
  searchTerm?: string;
  accountTypeIds?: string[];
  accountStatusIds?: string[];
  isActive?: boolean;
  createdFrom?: string;
  createdTo?: string;
}

export async function searchMemberships(
  page = 1,
  pageSize = 15,
  search?: string,
  headers?: HeadersInit,
  filters?: MembershipSearchFilters,
) {
  const params = new URLSearchParams();
  params.set("page", page.toString());
  params.set("pageSize", pageSize.toString());
  if (search) {
    params.set("searchTerm", search);
  }
  if (filters?.accountTypeIds?.length) {
    params.set("accountTypeIds", filters.accountTypeIds.join(","));
  }
  if (filters?.accountStatusIds?.length) {
    params.set("accountStatusIds", filters.accountStatusIds.join(","));
  }
  if (typeof filters?.isActive === "boolean") {
    params.set("isActive", String(filters.isActive));
  }
  if (filters?.createdFrom) {
    params.set("createdFrom", filters.createdFrom);
  }
  if (filters?.createdTo) {
    params.set("createdTo", filters.createdTo);
  }

  try {
    const response = await coreClient<{
      members: CoreMembership[];
      pagination: CoreAPIPagination;
    }>(`/v1/admin-console/members/memberships?${params.toString()}`, {
      headers,
    });
    return response;
  } catch (error) {
    return {
      message: (error as Error).message ?? "Failed fetching accounts",
      data: null,
    };
  }
}

export interface CoreAccountOverview {
  bookings: { internal: number; external: number; curated: number };
  lastSession: {
    id: string;
    created_at: string;
    application_type: string | null;
    application_version: string | null;
    os: string | null;
    browser: string | null;
    device_type: string | null;
    ip_address: string | null;
    location: string | null;
    member_number: string | null;
  } | null;
  emails: { contacts: number; withEmail: number; unique: string[] };
  /** Most-booked entities for this account, per booking kind. */
  topEntities: {
    kind: "internal" | "external" | "curated";
    name: string;
    bookings: number;
  }[];
  promoCodes: string[];
}

export interface CoreMemberPoints {
  balance: number;
  clubResortID: number;
  entitlements: unknown[];
}

// Fetched only when asked for: it round-trips to Viewpoint, so it is not part
// of the member page's initial load.
export async function getMemberPointsBalance(
  membershipNumber: string,
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient<CoreMemberPoints>(
      `/v1/admin-console/members/points/${membershipNumber}`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: (error as Error)?.message ?? "Failed to fetch points",
      data: undefined,
    };
  }
}

export async function getAccountOverview(
  membershipNumber: string,
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient<CoreAccountOverview>(
      `/v1/admin-console/members/account-overview/${membershipNumber}`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMembershipAnalytics(
  filters?: MembershipSearchFilters,
  headers?: HeadersInit,
) {
  // The same filters the table sends: the charts describe the filtered rows,
  // and the server applies the caller's access slice on top.
  const params = new URLSearchParams();
  if (filters?.searchTerm) {
    params.set("searchTerm", filters.searchTerm);
  }
  if (filters?.accountTypeIds?.length) {
    params.set("accountTypeIds", filters.accountTypeIds.join(","));
  }
  if (filters?.accountStatusIds?.length) {
    params.set("accountStatusIds", filters.accountStatusIds.join(","));
  }
  if (typeof filters?.isActive === "boolean") {
    params.set("isActive", String(filters.isActive));
  }
  if (filters?.createdFrom) {
    params.set("createdFrom", filters.createdFrom);
  }
  if (filters?.createdTo) {
    params.set("createdTo", filters.createdTo);
  }
  const queryString = params.toString();

  try {
    const response = await coreClient<{
      totals: {
        accounts: number;
        members: number;
        active: number;
        inactive: number;
      };
      bookings: {
        total: number;
        internal: number;
        external: number;
        curated: number;
      };
      byAccountType: { id: string; name: string; count: number }[];
      byAccountStatus: { id: string; name: string; count: number }[];
      byCountry: {
        country: string;
        accountTypeId: string;
        accountTypeName: string;
        count: number;
      }[];
    }>(
      `/v1/admin-console/members/analytics${
        queryString ? `?${queryString}` : ""
      }`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMembershipFilterOptions(headers?: HeadersInit) {
  try {
    const response = await coreClient<{
      accountTypes: { id: string; name: string; is_active: boolean }[];
      accountStatuses: { id: string; name: string; is_active: boolean }[];
    }>(`/v1/admin-console/members/filter-options`, { headers });
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function searchMemberAccountTypes(
  page = 1,
  pageSize = 15,
  search?: string,
  headers?: HeadersInit,
) {
  const params = new URLSearchParams();
  params.set("page", page.toString());
  params.set("pageSize", pageSize.toString());
  if (search) {
    params.set("searchTerm", search);
  }
  try {
    const response = await coreClient<{
      account_types: CoreMemberAccountType[];
      pagination: CoreAPIPagination;
    }>(`/v1/admin/memberships/account-types?${params.toString()}`, {
      headers,
    });
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMemberByMemberNumber(
  memberNumber: string,
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient<{ member: CoreMemberDetailed }>(
      `/v1/admin-console/members/${memberNumber}`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMembershipDetails(
  membershipNumber: string,
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient<{ account: VpAccountDetails }>(
      `/v1/admin-console/members/account/${membershipNumber}`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMemberShipContacts(
  membershipNumber: string,
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient<{ members: CoreMemberDetailed[] }>(
      `/v1/admin-console/members/contacts/${membershipNumber}`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMemberSessionsByUserId(
  userId: string,
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient<{ sessions: CoreMemberSession[] }>(
      `/v1/admin-console/members/sessions/${userId}`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMemberActivityLogs(
  memberRecordId: string,
  userId?: string,
  headers?: HeadersInit,
) {
  const params = new URLSearchParams();
  if (userId) {
    params.set("userId", userId);
  }
  const queryString = params.toString();
  try {
    const response = await coreClient<{ logs: CoreMemberActivityLog[] }>(
      `/v1/admin-console/members/logs/${memberRecordId}${
        queryString ? `?${queryString}` : ""
      }`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMemberSessionLogs(
  memberRecordId: string,
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient<{ sessions: CoreMemberSession[] }>(
      `/v1/admin-console/members/session-logs/${memberRecordId}`,
      { headers },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function getMemberSavedSearches(
  memberRecordId: string,
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient<{
      saved_searches: CoreMemberSavedSearch[];
    }>(`/v1/admin-console/members/saved-searches/${memberRecordId}`, {
      headers,
    });
    return response;
  } catch (error) {
    return {
      success: false,
      message: "",
      data: undefined,
    };
  }
}

export async function resetMemberPassword(
  memberRecordId: string,
  entry: { password: string },
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient(
      `/v1/admin-console/members/password/${memberRecordId}`,
      {
        method: "PATCH",
        body: JSON.stringify({ newPassword: entry.password }),
        headers,
      },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: (error as Error)?.message ?? "Failed to reset member password",
      data: null,
    };
  }
}

// Profile sync still executes on Core (it drives the Viewpoint worker), but it
// goes through Core2's guarded route so only super admins can trigger it.
export async function syncMemberProfile(
  profileID: string,
  entry: { accountId: string; contactId: string },
  headers?: HeadersInit,
) {
  try {
    const response = await coreClient(
      `/v1/admin-console/members/sync-profile/${profileID}`,
      {
        method: "PUT",
        body: JSON.stringify(entry),
        headers,
      },
    );
    return response;
  } catch (error) {
    return {
      success: false,
      message: (error as Error)?.message ?? "Failed to sync member profile",
      data: null,
    };
  }
}