"use client";

import React, { useState, useEffect } from "react";
import Link from "next/link";
import Image from "next/image";
import { generateSlug } from "@/utils/slugHelper";
import { resolveImage, PLACEHOLDER_IMAGE } from "@/utils/imageHelper";
import { useCart } from "../context/CartContext";
import { useRouter } from "next/navigation";
import { formatPrice } from "@/utils/currencyHelper";
import { API_BASE_URL } from "@/utils/apiHelper";

const getColorHex = (colorName: string): string => {
  const lower = colorName.toLowerCase();
  if (lower.includes("black")) return "#121212";
  if (lower.includes("white")) return "#f8fafc";
  if (lower.includes("red")) return "#dc2626";
  if (lower.includes("blue")) return "#2563eb";
  if (lower.includes("yellow")) return "#facc15";
  if (lower.includes("orange")) return "#f97316";
  if (lower.includes("green")) return "#16a34a";
  if (lower.includes("grey") || lower.includes("gray")) return "#4b5563";
  if (lower.includes("carbon")) return "#2b2b2b";
  if (lower.includes("pink")) return "#ec4899";
  if (lower.includes("silver")) return "#cbd5e1";
  return "#e2e8f0";
};

type Product = {
  inward_id: string;
  variant_id: string;
  sku_no: string;
  name: string;
  image: string | null;
  dealer_price: number;
  mrp: number;
  currency?: string;
  color?: string | null;
  size_name?: string | null;
  is_individual: boolean;
  is_carton: boolean;
  is_featured: boolean;
  is_new_arrival: boolean;
  is_best_seller: boolean;
  is_active: boolean;
  category_name?: string | null;
  subcategory_name?: string | null;
  carton_box_size?: number;
  brand_name?: string;
  model_name?: string;
  submodel_name?: string;
  total_variants?: number;
  starting_price?: number;
  variants?: {
    variant_id: string;
    sku_no: string;
    color: string | null;
    size: number | null;
    size_name: string | null;
    dealer_price: number;
    currency: string;
    quantity: number | null;
    inward_id: string;
    is_active: boolean;
    product_images?: string[];
    model_images?: string[];
  }[];
};

export default function ProductCard({ product }: { product: Product }) {
  const [imgSrc, setImgSrc] = useState(resolveImage(product.image));
  const [hoveredImage, setHoveredImage] = useState<string | null>(null);
  const [quantity, setQuantity] = useState(
    product.is_carton ? (product.carton_box_size || 1) : 1
  );
  const [isLoggedIn, setIsLoggedIn] = useState(false);
  const [isActiveUser, setIsActiveUser] = useState(false);
  const [mounted, setMounted] = useState(false);
  const [adding, setAdding] = useState(false);
  const { openCart } = useCart();
  const router = useRouter();

  const colors = React.useMemo(() => {
    if (!product.variants) return [];
    const unique = new Set<string>();
    product.variants.forEach((v) => {
      if (v.color) unique.add(v.color);
    });
    return Array.from(unique);
  }, [product.variants]);

  const sizes = React.useMemo(() => {
    if (!product.variants) return [];
    const unique = new Set<string>();
    product.variants.forEach((v) => {
      if (v.size_name) unique.add(v.size_name);
    });
    return Array.from(unique);
  }, [product.variants]);

  const boxSize = product.carton_box_size || 1;
  const isCarton = product.is_carton;

  const productUrl = `/category/${generateSlug(product.category_name || "uncategorized")}/${generateSlug(
    product.subcategory_name || "general"
  )}/${generateSlug(product.name)}`;

  useEffect(() => {
    setMounted(true);
    const checkAuth = () => {
      setIsLoggedIn(!!localStorage.getItem("access_token"));
      setIsActiveUser(localStorage.getItem("is_active") === "true");
    };
    checkAuth();
    window.addEventListener('storage', checkAuth);
    return () => window.removeEventListener('storage', checkAuth);
  }, []);

  useEffect(() => {
    setImgSrc(resolveImage(product.image));
  }, [product.image]);

  const handleColorHover = (color: string) => {
    // Find the first variant of this color that has product_images
    const variantWithImages = product.variants?.find(
      (v) => v.color === color && v.product_images && v.product_images.length > 0
    );
    // Fallback to any variant of this color
    const fallbackVariant = product.variants?.find((v) => v.color === color);

    if (variantWithImages && variantWithImages.product_images && variantWithImages.product_images.length > 0) {
      setHoveredImage(variantWithImages.product_images[0]);
    } else if (fallbackVariant && fallbackVariant.model_images && fallbackVariant.model_images.length > 0) {
      setHoveredImage(fallbackVariant.model_images[0]);
    }
  };

  const handleColorLeave = () => {
    setHoveredImage(null);
  };

  const handleActionClick = (e: React.MouseEvent) => {
    e.preventDefault();
    e.stopPropagation();
  };

  const increment = () => setQuantity((p) => p + (isCarton ? boxSize : 1));
  const decrement = () => setQuantity((p) => Math.max(isCarton ? boxSize : 1, p - (isCarton ? boxSize : 1)));

  const handleInput = (e: React.ChangeEvent<HTMLInputElement>) => {
    const value = e.target.value;
    if (value === "") {
      setQuantity(0);
    } else {
      const num = parseInt(value, 10);
      if (!isNaN(num) && num >= 0) {
        if (isCarton) {
          const roundedQuantity = Math.ceil(num / boxSize) * boxSize;
          setQuantity(roundedQuantity);
        } else {
          setQuantity(num);
        }
      }
    }
  };

  const handleAddToCart = async () => {
    if (quantity < 1) return;
    const token = localStorage.getItem("access_token");
    if (!token) { router.push('/login'); return; }

    setAdding(true);
    try {
      const res = await fetch(`${API_BASE_URL}/api/v1/b2b-cart/items`, {
        method: "POST",
        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
        body: JSON.stringify({ inward_id: product.inward_id, quantity }),
      });
      if (res.ok) openCart();
      else {
        const err = await res.json().catch(() => ({}));
        alert(`Failed to add: ${err.detail || "Unknown error"}`);
      }
    } catch {
      alert("Failed to add item to cart.");
    } finally {
      setAdding(false);
    }
  };

  const activeFlags = React.useMemo(() => {
    const flags = [];
    if (product.is_new_arrival) flags.push({ type: 'new', label: 'New', classes: 'from-blue-600 to-indigo-600 shadow-blue-500/20' });
    if (product.is_best_seller) flags.push({ type: 'bestseller', label: 'Best Seller', classes: 'from-emerald-500 to-teal-600 shadow-emerald-500/20' });
    if (product.is_featured) flags.push({ type: 'featured', label: 'Featured', classes: 'from-purple-600 to-fuchsia-600 shadow-purple-500/20' });
    return flags;
  }, [product.is_new_arrival, product.is_best_seller, product.is_featured]);

  const [currentFlagIndex, setCurrentFlagIndex] = useState(0);
  const [animate, setAnimate] = useState(true);

  useEffect(() => {
    if (activeFlags.length <= 1) return;
    const interval = setInterval(() => {
      setAnimate(false);
      setTimeout(() => {
        setCurrentFlagIndex((prev) => (prev + 1) % activeFlags.length);
        setAnimate(true);
      }, 300); // Wait for fade-out/slide-out to finish
    }, 3000);
    return () => clearInterval(interval);
  }, [activeFlags.length]);

  return (
    <div
      onClick={() => router.push(productUrl)}
      className="group relative flex flex-col bg-white border border-gray-200 rounded-2xl overflow-hidden cursor-pointer transition-all duration-300 hover:shadow-xl hover:border-gray-300"
    >
      {/* Image area */}
      <div className="relative aspect-square bg-gray-50 overflow-hidden">
        <img
          src={hoveredImage ? resolveImage(hoveredImage) : imgSrc}
          alt={product.name}
          onError={() => {
            if (!hoveredImage) setImgSrc(PLACEHOLDER_IMAGE);
          }}
          className="w-full h-full object-contain p-4 transition-transform duration-500 group-hover:scale-105"
        />
        {/* Badges */}
        {activeFlags.length > 0 && (
          <div className="absolute top-3 left-0 z-10">
            <span
              className={`inline-flex items-center px-3 py-1 rounded-r-lg text-[9px] font-black uppercase tracking-widest bg-gradient-to-r ${activeFlags[currentFlagIndex].classes
                } text-white shadow-lg select-none transition-all duration-300 transform ${animate ? "translate-x-0 opacity-100 scale-100" : "-translate-x-2 opacity-0 scale-95"
                }`}
            >
              {activeFlags[currentFlagIndex].label}
            </span>
          </div>
        )}
        {product.is_carton && (
          <div className="absolute top-3 right-3 z-10">
            <span className="inline-flex items-center px-2.5 py-1 rounded-full text-[9px] font-black uppercase tracking-widest bg-gray-900 text-white shadow-lg shadow-black/20 select-none">
              Box of {boxSize}
            </span>
          </div>
        )}
      </div>

      {/* Content */}
      <div className="flex flex-col flex-grow p-4">
        {/* Name */}
        <h3 className="text-base font-bold text-gray-800 leading-snug line-clamp-2 mb-2 h-12">
          {(() => {
            let displayName = product.submodel_name || product.name;
            if (!product.submodel_name) {
              if (product.brand_name && displayName.toLowerCase().startsWith(product.brand_name.toLowerCase())) {
                displayName = displayName.substring(product.brand_name.length).trim();
              }
              if (product.model_name && displayName.toLowerCase().startsWith(product.model_name.toLowerCase())) {
                displayName = displayName.substring(product.model_name.length).trim();
              }
            }
            return displayName;
          })()}
        </h3>

        {/* Total Variants & Pricing */}
        <div className="flex items-center justify-between mt-auto pt-1 gap-2 flex-wrap">
          {product.total_variants !== undefined && (
            <span className="inline-flex items-center px-2.5 py-0.5 rounded-md bg-gray-100 text-[10px] font-black text-gray-500 uppercase tracking-widest leading-none">
              {product.total_variants} {product.total_variants === 1 ? "Variant" : "Variants"}
            </span>
          )}
          {mounted && isLoggedIn && isActiveUser && product.starting_price !== undefined && (
            <span className="text-[12px] font-black text-gray-900 leading-none">
              From {formatPrice(product.starting_price, product.currency || "INR")}
            </span>
          )}
        </div>

        {/* Colors & Sizes Rows */}
        <div className="flex flex-col gap-2 mt-3 pt-2.5 border-t border-gray-50">
          {colors.length > 0 && (
            <div className="flex items-center gap-1.5 flex-wrap">
              <span className="text-[10px] font-extrabold text-gray-400 uppercase tracking-wider">Colors:</span>
              <div className="flex items-center gap-1 flex-wrap">
                {colors.map((color) => (
                  <span
                    key={color}
                    onMouseEnter={() => handleColorHover(color)}
                    onMouseLeave={handleColorLeave}
                    className="w-3.5 h-3.5 rounded-full border border-gray-300 shadow-sm cursor-pointer hover:scale-125 transition-transform"
                    style={{ backgroundColor: getColorHex(color) }}
                    title={color}
                  />
                ))}
              </div>
            </div>
          )}

          {sizes.length > 0 && (
            <div className="flex items-center gap-1.5 flex-wrap">
              <span className="text-[10px] font-extrabold text-gray-400 uppercase tracking-wider">Sizes:</span>
              <div className="flex items-center gap-1 flex-wrap">
                {sizes.map((size) => (
                  <span
                    key={size}
                    className="px-1.5 py-0.5 rounded bg-gray-50 border border-gray-150 text-[9px] font-black text-gray-500 uppercase tracking-wider"
                  >
                    {size}
                  </span>
                ))}
              </div>
            </div>
          )}
        </div>
      </div>
    </div>
  );
}