"use client";

import MediaSection from "./parts/Media";
import InfoSection from "./parts/Info";
import DocumentsSection from "./parts/Documents";
import VideosSection from "./parts/Video";
import SidebarSection from "./parts/Sidebar";
import AuctionMetaSection from "./parts/AuctionMeta";
import CamelDetailsSection from "./parts/CamelDetails";
import { useEffect, useMemo, useState } from "react";
import { useSession } from "@/auth/session-provider";
import { useSetAtom } from "jotai";
import { loginModalAtom } from "@/components/state/loginAtom";
import { useLocale, useTranslations } from "next-intl";
import { useParams, useRouter } from "next/navigation";
import { useAvailablePaddlesForAuction } from "@/lib/clientQueries";
import YearlyPaddleModal from "@/components/paddles/YearlyPaddleModal";
import { getPrefetchedGroupAuctionTerms } from "@/lib/groupAuctionShowTerms";
import PurchaseOfferModal from "@/components/purchase/PurchaseOfferModal";
import HorseDetailsSection from "./parts/HorseDetails";
import SellerReviewsSection from "@/components/reviews/SellerReviewsSection";
import {
  getAuctionGroupById,
  getGroupAuctionById,
} from "@/actions/group-auctions";
import type { AuctionGroupDetails, GroupAuction } from "@/actions/group-auctions";
import { OfferModal } from "@/components/annaulMazad/live-rooms-table/LiveRoomsTableModals";
import { createPurchaseOffer } from "@/actions/purchase-offers";
import { useAppToast } from "@/app/[lang]/providers";
import { toMoneyNumber } from "@/lib/moneyParse";

function isUnsoldStatusString(raw: string): boolean {
  const t = raw.trim();
  if (!t) return false;
  const l = t.toLowerCase();
  if (l === "unsold" || l === "not_sold" || l === "not sold") return true;
  if (t === "لم يتم البيع" || t === "غير مباع") return true;
  if (/لم[\s\u200c]*يتم[\s\u200c]*البيع/i.test(t)) return true;
  if (/غير[\s\u200c]*مباع/i.test(t)) return true;
  return false;
}

function normalizePaddleLabel(v: unknown): string {
  if (v == null) return "";
  return String(v).trim();
}

function extractPaddleFromPurchaseOfferResponse(result: unknown): string | null {
  const r = result as Record<string, unknown> | null;
  if (r && typeof r === "object") {
    const root = normalizePaddleLabel(
      r.paddle_number ??
        r.paddleNumber ??
        r.paddle_unique_id ??
        r.paddleUniqueId,
    );
    if (root) return root;
  }
  const d = r?.data as Record<string, unknown> | null | undefined;
  if (!d || typeof d !== "object") return null;
  const o = d as Record<string, unknown>;
  const candidates = [
    o.paddle_number,
    o.paddleNumber,
    o.paddle_unique_id,
    o.paddleUniqueId,
    o.buyer_paddle_number,
    (o.buyer as Record<string, unknown> | undefined)?.paddle_number,
    (o.auction as Record<string, unknown> | undefined)?.paddle_number,
  ];
  for (const c of candidates) {
    const label = normalizePaddleLabel(c);
    if (label) return label;
  }
  return null;
}

// واجهة تبسيطية لشكل الريسبونس القادم من /user/single-auctions/{id}
//test
interface SingleAuctionResponseItem {
  id: string;
  unique_id: string;
  title: string;
  description: string;
  auction_start_time: string | null;
  auction_end_time: string | null;
  status: string;
  auction_state: string;
  is_group: boolean;
  state: string;
  country: string;
  starting_price: string | null;
  market_entry_price: string | null;
  videos: any[];
  media_files: {
    main_image?: { id: number | null; url: string } | null;
    additional_images?: { id?: number | null; url: string }[];
    medical_exam_certificate?: string | null;
    info_certificate?: string | null;
    owner_document?: string | null;
    video?: string | null;
  };
  camel: {
    id: string;
    animal_usage: string;
    animal_color: string;
    name: string;
    father_name: string;
    mother_name: string;
    mother_father_name: string;
    gender: "male" | "female" | string;
    date_of_birth: string | null;
    breed: string;
    height: string;
    type: string;
    /** @deprecated rollout */
    is_pregnant?: boolean | null;
    vaccination_status?: string | null;
  };
  horse?: {
    id: string;
    animal_usage: string;
    animal_color: string;
    name: string;
    father_name: string;
    mother_name: string;
    mother_father_name: string;
  };
  owner?: {
    name: string;
    phone: string;
  } | null;
  created_by?: { name?: string } | null;
  can_edit_status?: boolean;
  can_edit_details?: boolean;
  /** Parent yearly / group auction (group_auction in API route). */
  group_auction_id?: string | null;
  group_auction?: {
    id: string;
    normal_paddle_price?: number | string | null;
    premium_paddle_price?: number | string | null;
    premium_use_times?: number | string | null;
  } | null;
  /** Room / auction_group id for GET .../auction-groups/{auction_group}. */
  auction_group_id?: string | null;
  auction_group?: {
    id?: string | null;
    group_auction_id?: string | null;
    group_auction?: { id?: string | null } | null;
  } | null;
  normal_paddle_price?: number | string | null;
  premium_paddle_price?: number | string | null;
  premium_use_times?: number | string | null;
  owner_review_summary?: { avg?: number | string | null; count?: number | string | null } | null;
  final_bid_amount?: string | number | null;
  info_final_bid?: {
    final_bid_amount?: string | number | null;
    lowest_offer_value?: string | number | null;
  } | null;
}

function resolveGroupAuctionId(
  item: SingleAuctionResponseItem,
): string | null {
  const o = item as unknown as Record<string, unknown>;
  const nestedGa = o.group_auction as Record<string, unknown> | undefined;
  const nestedAg = o.auction_group as Record<string, unknown> | undefined;
  const nestedAgGa = nestedAg?.group_auction as
    | Record<string, unknown>
    | undefined;
  const raw =
    o.group_auction_id ??
    (o as { groupAuctionId?: string }).groupAuctionId ??
    nestedGa?.id ??
    nestedAg?.group_auction_id ??
    nestedAgGa?.id;
  if (raw == null || String(raw).trim() === "") return null;
  return String(raw);
}

function resolveAuctionGroupId(
  item: SingleAuctionResponseItem,
): string | null {
  const o = item as unknown as Record<string, unknown>;
  const nestedAg = o.auction_group as Record<string, unknown> | undefined;
  const raw =
    o.auction_group_id ??
    (o as { auctionGroupId?: string }).auctionGroupId ??
    nestedAg?.id;
  if (raw == null || String(raw).trim() === "") return null;
  return String(raw);
}

export default function AnnualSingleAuctionClient({
  item,
}: {
  item: SingleAuctionResponseItem;
}) {
  const session = useSession();
  const setLoginModal = useSetAtom(loginModalAtom);
  const toast = useAppToast();
  const tToast = useTranslations("TOAST");
  const router = useRouter();
  const locale = useLocale();
  const params = useParams();
  const isRtl = (locale || "").toLowerCase().startsWith("ar");
  const lang = (params?.lang as string) || "ar";

  const [paddleModalOpen, setPaddleModalOpen] = useState(false);
  const [sendOfferModalOpen, setSendOfferModalOpen] = useState(false);
  const [paddleJustPurchased, setPaddleJustPurchased] = useState(false);
  const [offerModalOpen, setOfferModalOpen] = useState(false);
  const [offerAmount, setOfferAmount] = useState("");
  const [sendingOffer, setSendingOffer] = useState(false);
  const [offerSent, setOfferSent] = useState(false);
  const [offerSubmittedPaddle, setOfferSubmittedPaddle] = useState<
    string | null
  >(null);
  const [groupDetails, setGroupDetails] = useState<AuctionGroupDetails | null>(
    null,
  );
  const [groupDetailsLoading, setGroupDetailsLoading] = useState(false);
  const [parentGroupAuction, setParentGroupAuction] =
    useState<GroupAuction | null>(null);

  const auctionId = item?.id ? String(item.id) : "";
  const groupAuctionId = resolveGroupAuctionId(item);
  const auctionGroupId = resolveAuctionGroupId(item);
  const groupLinked = Boolean(groupAuctionId && auctionGroupId);

  const animalType = item.horse ? "horse" : "camel";
  const isHorseFallbackGroup =
    animalType === "horse" &&
    groupAuctionId != null &&
    auctionGroupId != null &&
    groupAuctionId === auctionGroupId;

  useEffect(() => {
    if (!groupAuctionId || !auctionGroupId) {
      setGroupDetails(null);
      return;
    }
    let cancelled = false;
    setGroupDetailsLoading(true);
    getAuctionGroupById(groupAuctionId, auctionGroupId)
      .then((data) => {
        if (!cancelled) setGroupDetails(data);
      })
      .catch(() => {
        if (!cancelled) setGroupDetails(null);
      })
      .finally(() => {
        if (!cancelled) setGroupDetailsLoading(false);
      });
    return () => {
      cancelled = true;
    };
  }, [groupAuctionId, auctionGroupId]);

  useEffect(() => {
    if (!groupAuctionId) {
      setParentGroupAuction(null);
      return;
    }
    let cancelled = false;
    getGroupAuctionById(groupAuctionId)
      .then((data) => {
        if (!cancelled) setParentGroupAuction(data ?? null);
      })
      .catch(() => {
        if (!cancelled) setParentGroupAuction(null);
      });
    return () => {
      cancelled = true;
    };
  }, [groupAuctionId]);

  const resolvedNormalPaddlePrice = useMemo(() => {
    const n = toMoneyNumber(
      groupDetails?.normal_paddle_price ??
        parentGroupAuction?.normal_paddle_price ??
        item.group_auction?.normal_paddle_price ??
        item.normal_paddle_price,
      0,
    );
    return Number.isFinite(n) && n > 0 ? n : 0;
  }, [
    groupDetails?.normal_paddle_price,
    parentGroupAuction?.normal_paddle_price,
    item.group_auction?.normal_paddle_price,
    item.normal_paddle_price,
  ]);

  const g = groupDetails as Record<string, unknown> | null | undefined;
  const trimmedGroupStatus = String(g?.status ?? "").trim();
  const groupUnsold = isUnsoldStatusString(trimmedGroupStatus);
  const hasGroupPaddle =
    g?.paddle_number != null && String(g.paddle_number).trim() !== "";
  const isGroupOwner = Boolean(
    g?.is_owner ?? (item as { is_owner?: boolean }).is_owner,
  );

  /** Annual single page: normal paddle only; price from parent group_auction API, then embedded group_auction on item. */
  const paddlePricesForModal = useMemo(
    () => ({
      normalPrice: resolvedNormalPaddlePrice,
      premiumPrice: 0,
      premiumUseTimes: 0,
    }),
    [resolvedNormalPaddlePrice],
  );

  const auctionPrices = paddlePricesForModal;

  const canBuyPaddleApi = Boolean(g?.can_buy_paddle);
  const canSendOfferApi = Boolean(g?.can_send_offer);

  const serverOfferSubmittedChip =
    groupLinked &&
    groupUnsold &&
    hasGroupPaddle &&
    !canBuyPaddleApi &&
    !canSendOfferApi;

  const paddleLabelForSubmittedOffer =
    normalizePaddleLabel(g?.paddle_number) || offerSubmittedPaddle || "";

  const showOfferSubmittedUI =
    groupLinked &&
    Boolean(session) &&
    groupUnsold &&
    !isGroupOwner &&
    (serverOfferSubmittedChip || offerSent);

  const canBuyPaddleEffective =
    groupLinked &&
    !paddleJustPurchased &&
    !isGroupOwner &&
    groupUnsold &&
    !hasGroupPaddle &&
    (canBuyPaddleApi || resolvedNormalPaddlePrice > 0);

  const paddlesQueryIdForHook =
    canBuyPaddleEffective && groupLinked
      ? isHorseFallbackGroup
        ? groupAuctionId!
        : auctionGroupId!
      : !groupLinked
        ? auctionId
        : undefined;

  const { data: availablePaddles = [] } = useAvailablePaddlesForAuction(
    paddlesQueryIdForHook,
    "annual",
  );

  const minOfferAmount =
    groupLinked && groupUnsold
      ? toMoneyNumber(
          (g?.info_final_bid as { lowest_offer_value?: unknown } | undefined)
            ?.lowest_offer_value,
          0,
        ) || 0
      : toMoneyNumber(
          (g?.winning_bid as { amount?: unknown } | undefined)?.amount ??
            g?.market_entry_price,
          0,
        ) || 0;

  const serverPaddleNorm = normalizePaddleLabel(g?.paddle_number);
  useEffect(() => {
    if (serverPaddleNorm) setOfferSubmittedPaddle(null);
  }, [serverPaddleNorm]);

  useEffect(() => {
    if (serverOfferSubmittedChip) setOfferSent(false);
  }, [serverOfferSubmittedChip]);

  const handleSubmitGroupOffer = async () => {
    if (!auctionGroupId) return;
    const amount = toMoneyNumber(offerAmount, 0);
    if (!Number.isFinite(amount) || amount <= 0) {
      toast.error(tToast("enter_valid_offer_amount"));
      return;
    }
    if (minOfferAmount > 0 && amount <= minOfferAmount) {
      toast.error(
        tToast("offer_must_exceed_min", {
          min: minOfferAmount.toLocaleString(),
        }),
      );
      return;
    }
    setSendingOffer(true);
    try {
      const result = await createPurchaseOffer({
        auction_type: "group",
        auction_id: auctionGroupId,
        full_amount: amount,
      });
      if (result.success) {
        const paddleFromRes = extractPaddleFromPurchaseOfferResponse(result);
        if (paddleFromRes) setOfferSubmittedPaddle(paddleFromRes);
        toast.success(
          result.message || tToast("offer_sent_success"),
        );
        setOfferSent(true);
        setOfferModalOpen(false);
        setOfferAmount("");
        setPaddleJustPurchased(false);
        router.refresh();
      } else {
        toast.error(
          result.message || tToast("offer_send_failed"),
        );
      }
    } catch {
      toast.error(tToast("generic_try_again"));
    } finally {
      setSendingOffer(false);
    }
  };

  const handleOpenPaddleModal = () => {
    if (!session) {
      setLoginModal(true);
      return;
    }
    setPaddleModalOpen(true);
  };

  const handleOpenSendOfferModal = () => {
    if (!session) {
      setLoginModal(true);
      return;
    }
    if (groupLinked && groupUnsold && !isGroupOwner) {
      setOfferModalOpen(true);
      return;
    }
    setSendOfferModalOpen(true);
  };

  const sidebarCanBuyPaddle = groupLinked
    ? canBuyPaddleEffective && !showOfferSubmittedUI
    : Boolean(
        (item as { can_buy_paddle?: boolean }).can_buy_paddle ||
          resolvedNormalPaddlePrice > 0,
      );

  /** Merge group room API fields for sidebar result card + offer-submitted state. */
  const itemForSidebar = useMemo(() => {
    let next = item;

    if (groupLinked && groupDetails) {
      const g = groupDetails as AuctionGroupDetails;
      const ifb = g?.info_final_bid;
      const fba =
        ifb && typeof ifb === "object" ? ifb.final_bid_amount : undefined;
      const winnerPatch: Record<string, unknown> = {};
      if (g.winner_name != null && String(g.winner_name).trim() !== "")
        winnerPatch.winner_name = g.winner_name;
      if (g.winner_user != null) winnerPatch.winner_user = g.winner_user;
      if (g.winner != null) winnerPatch.winner = g.winner;
      if (g.highest_bidder_name != null && String(g.highest_bidder_name).trim() !== "")
        winnerPatch.highest_bidder_name = g.highest_bidder_name;
      if (g.highest_bidder != null) winnerPatch.highest_bidder = g.highest_bidder;
      if (g.winner_paddle_number != null && String(g.winner_paddle_number).trim() !== "")
        winnerPatch.winner_paddle_number = g.winner_paddle_number;
      if (
        g.highest_bidder_paddle_number != null &&
        String(g.highest_bidder_paddle_number).trim() !== ""
      )
        winnerPatch.highest_bidder_paddle_number =
          g.highest_bidder_paddle_number;
      const wpu = g.winner_paddle_unique_id ?? g.winner_paddle_uniqueId;
      if (wpu != null && String(wpu).trim() !== "")
        winnerPatch.winner_paddle_unique_id = wpu;
      if (g.winning_bid != null) winnerPatch.winning_bid = g.winning_bid;
      if (g.purchasing_date != null && String(g.purchasing_date).trim() !== "")
        winnerPatch.purchase_date = g.purchasing_date;

      next = {
        ...next,
        ...winnerPatch,
        ...(ifb && typeof ifb === "object"
          ? {
              info_final_bid: ifb,
              ...(fba != null && String(fba).trim() !== ""
                ? { final_bid_amount: fba }
                : {}),
            }
          : {}),
      };
    }

    if (groupLinked && showOfferSubmittedUI) {
      const pn = paddleLabelForSubmittedOffer;
      if (pn) {
        return {
          ...next,
          paddle_number: pn as unknown as string,
          can_buy_paddle: false,
          can_send_offer: false,
        };
      }
    }

    return next;
  }, [
    groupLinked,
    groupDetails,
    showOfferSubmittedUI,
    item,
    paddleLabelForSubmittedOffer,
  ]);

  const sidebarIsOwner = groupLinked ? isGroupOwner : false;

  const sidebarCanSendOffer = groupLinked
    ? Boolean(
        session &&
          groupUnsold &&
          !isGroupOwner &&
          !showOfferSubmittedUI &&
          (paddleJustPurchased || canSendOfferApi || hasGroupPaddle) &&
          !canBuyPaddleEffective,
      )
    : Boolean((item as { can_send_offer?: boolean }).can_send_offer) ||
      !session;

  const paddleNumberBesideOffer = groupLinked
    ? normalizePaddleLabel(g?.paddle_number) || undefined
    : undefined;

  return (
    <main className="max-w-7xl mx-auto px-4 py-8 space-y-10" dir="rtl">
      <div className="grid lg:grid-cols-3 gap-6">
        <div className="lg:col-span-2 space-y-6">
          <MediaSection item={item as any} />
          <AuctionMetaSection item={item as any} />
          {item.horse ? (
            <HorseDetailsSection item={item as any} />
          ) : item.camel ? (
            <CamelDetailsSection item={item as any} />
          ) : null}
          <InfoSection item={item as any} />
          <DocumentsSection item={item as any} />
          <VideosSection item={item as any} />
        </div>

        <div className="space-y-4">
          {groupLinked && groupDetailsLoading ? (
            <div className="rounded-2xl border border-slate-200 bg-white p-4 text-sm text-slate-500">
              {isRtl ? "جاري تحميل بيانات المجموعة…" : "Loading group details…"}
            </div>
          ) : null}

          <SidebarSection
            item={itemForSidebar as any}
            purchaseOffersAuctionId={
              groupLinked ? auctionGroupId ?? undefined : undefined
            }
            onBidClick={handleOpenSendOfferModal}
            postBidInfoOpen={false}
            deadlineText={""}
            hideBidButton
            hidePricePanel
            hidePaddlePurchaseCard
            canBuyPaddle={sidebarCanBuyPaddle}
            paddlePrice={resolvedNormalPaddlePrice}
            buyingPaddle={false}
            onBuyPaddleClick={handleOpenPaddleModal}
            isOwner={sidebarIsOwner}
            isDashboard={false}
            auctionStatus={item.auction_state as any}
            canSendOffer={sidebarCanSendOffer}
            onSendOfferClick={() => {
              if (groupLinked && groupUnsold && !isGroupOwner) {
                setOfferModalOpen(true);
                return;
              }
              handleOpenSendOfferModal();
            }}
            paddleNumberBesideOffer={paddleNumberBesideOffer}
          />

          {auctionId ? (
            <SellerReviewsSection
              offerableId={auctionId}
              offerableType="single_auctions"
              sellerLabel={item.owner?.name ?? item.created_by?.name ?? undefined}
              summary={
                item.owner_review_summary
                  ? {
                      avg: Number(item.owner_review_summary.avg ?? 0),
                      count: Number(item.owner_review_summary.count ?? 0),
                    }
                  : null
              }
            />
          ) : null}
        </div>
      </div>

      {groupLinked && groupAuctionId && auctionGroupId ? (
        <YearlyPaddleModal
          open={paddleModalOpen}
          onClose={() => setPaddleModalOpen(false)}
          groupAuctionId={groupAuctionId}
          yearlyAuctionId={
            isHorseFallbackGroup ? groupAuctionId : auctionGroupId
          }
          yearlyAuctionType={isHorseFallbackGroup ? "group" : "single"}
          prices={auctionPrices}
          availablePaddles={availablePaddles}
          prefetchedAuctionTerms={getPrefetchedGroupAuctionTerms(
            parentGroupAuction,
          )}
          normalOnly
          onJoined={() => {
            setPaddleModalOpen(false);
            setPaddleJustPurchased(true);
            router.refresh();
            if (session) setOfferModalOpen(true);
          }}
        />
      ) : (
        <YearlyPaddleModal
          open={paddleModalOpen}
          onClose={() => setPaddleModalOpen(false)}
          groupAuctionId={groupAuctionId}
          yearlyAuctionId={auctionId}
          yearlyAuctionType="single"
          prices={paddlePricesForModal}
          availablePaddles={availablePaddles}
          prefetchedAuctionTerms={getPrefetchedGroupAuctionTerms(
            parentGroupAuction,
          )}
          normalOnly
          onJoined={() => {}}
        />
      )}

      {groupLinked && auctionGroupId ? (
        <OfferModal
          isOpen={offerModalOpen}
          onOpenChange={(open) => {
            setOfferModalOpen(open);
            if (!open) setOfferAmount("");
          }}
          isRtl={isRtl}
          title={isRtl ? "تقديم عرض شراء" : "Submit Purchase Offer"}
          description={
            isRtl
              ? "أدخل قيمة عرض الشراء وسيتم إرسالها للمراجعة بعد التحقق من الحد الأدنى المطلوب."
              : "Enter your purchase offer amount and it will be submitted for review after validating the minimum required amount."
          }
          offerDeadlineLabel={null}
          offerAmountLabel={isRtl ? "مبلغ العرض" : "Offer Amount"}
          offerAmountPlaceholder={
            isRtl
              ? `أدخل مبلغًا أكبر من ${minOfferAmount.toLocaleString()}`
              : `Enter amount greater than ${minOfferAmount.toLocaleString()}`
          }
          offerAmount={offerAmount}
          onOfferAmountChange={setOfferAmount}
          minOfferPrice={minOfferAmount}
          cancelLabel={isRtl ? "إلغاء" : "Cancel"}
          confirmLabel={isRtl ? "إرسال العرض" : "Send Offer"}
          sendingOffer={sendingOffer}
          onCancel={() => {
            setOfferModalOpen(false);
            setOfferAmount("");
          }}
          onConfirm={handleSubmitGroupOffer}
        />
      ) : null}

      {!groupLinked ? (
        <PurchaseOfferModal
          isOpen={sendOfferModalOpen}
          onClose={() => setSendOfferModalOpen(false)}
          auctionId={auctionId}
          auctionType={item.is_group ? "group" : "normal"}
        />
      ) : null}
    </main>
  );
}