import { medusa, medusaHeaders } from "@/lib/medusa/client";
import { HttpTypes } from "@medusajs/types";

type MedusaOrderLike = {
  id?: string;
};

type CompleteCartResult = {
  orderId: string | null;
  state: "completed" | "not_ready" | "failed";
  error: string | null;
};

function extractOrderId(payload: unknown): string | null {
  if (!payload || typeof payload !== "object") {
    return null;
  }

  const root = payload as Record<string, unknown>;
  const directOrder = root.order as MedusaOrderLike | undefined;
  if (directOrder?.id) {
    return directOrder.id;
  }

  const nestedData = root.data as Record<string, unknown> | undefined;
  const nestedOrder = nestedData?.order as MedusaOrderLike | undefined;
  if (nestedOrder?.id) {
    return nestedOrder.id;
  }

  if (root.type === "order") {
    const typedOrder = root.order as MedusaOrderLike | undefined;
    if (typedOrder?.id) {
      return typedOrder.id;
    }
  }

  return null;
}

function extractErrorMessage(payload: unknown): string | null {
  if (!payload || typeof payload !== "object") {
    return null;
  }

  const root = payload as Record<string, unknown>;
  const directError = root.error;

  if (typeof directError === "string" && directError) {
    return directError;
  }

  if (directError && typeof directError === "object") {
    const message = (directError as { message?: unknown }).message;
    if (typeof message === "string" && message) {
      return message;
    }
  }

  return null;
}

function extractProviderIds(payload: unknown): string[] {
  if (!payload || typeof payload !== "object") {
    return [];
  }

  const providers = (payload as { payment_providers?: Array<{ id?: string | null }> }).payment_providers;
  if (!Array.isArray(providers)) {
    return [];
  }

  return providers
    .map((provider) => provider?.id || "")
    .filter((id): id is string => Boolean(id));
}

function pickProviderId(providerIds: string[]) {
  const priority = ["pp_system_default", "pp_stripe_stripe"];

  for (const preferred of priority) {
    if (providerIds.includes(preferred)) {
      return preferred;
    }
  }

  return providerIds[0] || null;
}

async function initiatePaymentSession(cart: HttpTypes.StoreCart): Promise<{ ok: boolean; error: string | null }> {
  const regionId = cart.region_id || cart.region?.id || null;

  if (!regionId) {
    return { ok: false, error: "Missing cart region." };
  }

  try {
    const providersResponse = await medusa.store.payment.listPaymentProviders(
      { region_id: regionId, limit: 20 },
      medusaHeaders(),
    );
    const providerIds = extractProviderIds(providersResponse);
    const selectedProviderId = pickProviderId(providerIds);

    if (!selectedProviderId) {
      return { ok: false, error: "No payment provider available for region." };
    }

    await medusa.store.payment.initiatePaymentSession(
      cart,
      { provider_id: selectedProviderId },
      {},
      medusaHeaders(),
    );

    return { ok: true, error: null };
  } catch (error) {
    const message =
      error instanceof Error
        ? error.message
        : "Failed to initiate payment session.";
    return { ok: false, error: message };
  }
}

export async function completeCartById(cartId: string): Promise<CompleteCartResult> {
  if (!cartId) {
    return { orderId: null, state: "failed", error: "Missing cart id." };
  }

  try {
    const { cart } = await medusa.store.cart.retrieve(cartId, {}, medusaHeaders());
    const initResult = await initiatePaymentSession(cart);

    if (!initResult.ok) {
      return { orderId: null, state: "failed", error: initResult.error };
    }

    const response = await medusa.store.cart.complete(cartId, {}, medusaHeaders());
    const orderId = extractOrderId(response);

    if (orderId) {
      return { orderId, state: "completed", error: null };
    }

    return {
      orderId: null,
      state: "not_ready",
      error: extractErrorMessage(response),
    };
  } catch (error) {
    const message =
      error instanceof Error
        ? error.message
        : "Unknown error while completing cart.";

    return { orderId: null, state: "failed", error: message };
  }
}