import type { ProductDetail, Cart, CheckoutInput } from "@behio/storefront-sdk";

interface BehioStorefrontConfig {
  /** API key (public: pk_live_xxx or private: sk_live_xxx) */
  apiKey: string;
  /** Backend base URL. Default: https://api.behio.com */
  baseUrl?: string;
  /** Default locale for catalog requests. Default: none (uses shop default) */
  locale?: string;
  /** Default currency for price resolution. Default: none (uses shop default) */
  currency?: string;
  /** Custom fetch implementation (for Node.js < 18 or testing) */
  fetch?: typeof fetch;
  /** Request timeout in milliseconds. Default: 30000 (30s) */
  timeout?: number;
  /** Number of retries on network/5xx errors. Default: 1 */
  retries?: number;
  /** Base delay between retries in ms (multiplied by attempt). Default: 1000 */
  retryDelay?: number;
}

interface ProductListItem {
  id: string;
  slug: string;
  name: string;
  shortDescription?: string;
  sku: string;
  gtin?: string;
  price: ProductPrice;
  inStock: boolean;
  stockQuantity?: number;
  image?: string | null;
  labels: ProductLabel[];
  isFeatured: boolean;
}

interface ProductDetail extends ProductListItem {
  longDescription?: string;
  images: Array<{ url: string; alt?: string; order: number }>;
  categories: Array<{ id: string; slug: string; name: string }>;
  variants: ProductVariant[];
  volumePricing: ProductVolumePrice[];
  customFields: Record<string, unknown>;
  seo: {
    title?: string | null;
    description?: string | null;
    keywords?: string | null;
  };
  productGroups?: Array<{
    slug: string;
    name: string;
    products: ProductListItem[];
  }>;
  /** Product weight (from warehouse item) */
  weight?: number | null;
  /** Weight unit: GRAM, KILOGRAM, TONNE */
  weightUnit?: string | null;
}

interface ProductPrice {
  amount: number;
  currency: string;
  compareAtPrice?: number | null;
}

interface ProductVolumePrice {
  minQuantity: number;
  price: number;
  currency?: string;
}

interface ProductVariant {
  id: string;
  sku: string;
  name: string;
  attributes: Record<string, string>;
  price: ProductPrice;
  inStock: boolean;
  stockQuantity?: number;
}

interface ProductLabel {
  id: string;
  slug: string;
  name: string;
  color?: string;
}

interface ProductsQuery {
  page?: number;
  limit?: number;
  /** Single category slug (OR logic with categories array) */
  category?: string;
  /** Multiple category slugs (OR logic) */
  categories?: string[];
  /** Single label slug */
  label?: string;
  priceMin?: number;
  priceMax?: number;
  currency?: string;
  locale?: string;
  sort?: ProductSortValue;
  inStock?: boolean;
  search?: string;
  customFields?: Record<string, unknown>;
  /** Filter by specific product IDs */
  ids?: string[];
  /** Filter by specific product slugs */
  slugs?: string[];
  /** Multiple labels (AND logic — product must have ALL) */
  labels?: string[];
  /** Exclude specific product IDs */
  excludeIds?: string[];
  /** Exclude products in specific categories */
  excludeCategories?: string[];
  /** Only products with compareAtPrice (on sale) */
  hasDiscount?: boolean;
  /** Only featured products */
  isFeatured?: boolean;
  /** Products created after timestamp (epoch ms) */
  createdAfter?: number;
}

const ProductSort = {
  PRICE_ASC: "price_asc",
  PRICE_DESC: "price_desc",
  NAME_ASC: "name_asc",
  NAME_DESC: "name_desc",
  NEWEST: "newest",
  FEATURED: "featured",
} as const;

type ProductSortValue = (typeof ProductSort)[keyof typeof ProductSort];

interface FilterField {
  key: string;
  name: string;
  type: DataGroupFieldType | string;
  groupKey: string;
  groupName: string;
  values?: string[];
}

type DataGroupFieldType =
  | "TEXT" | "NUMBER" | "DECIMAL" | "BOOLEAN"
  | "DATE" | "TIME" | "DATETIME"
  | "PERCENTAGE" | "MONEY" | "ASSET"
  | "ITEM_LIST" | "DYNAMIC_NUMBER_CALCULATION_FROM_OTHERS";

interface Category {
  id: string;
  slug: string;
  name: string;
  description?: string;
  imageUrl?: string;
  children: Category[];
  productCount?: number;
}

interface CategoryDetail extends Category {
  seoTitle?: string;
  seoDescription?: string;
}

interface Cart {
  id: string;
  sessionToken?: string;
  items: CartItem[];
  subtotal: number;
  discountTotal: number;
  discount?: CartDiscount;
  grandTotal: number;
  currency: string;
  itemCount: number;
}

interface CartItem {
  id: string;
  product: CartItemProduct;
  quantity: number;
  unitPrice: number;
  totalPrice: number;
  priceChanged: boolean;
  volumePriceApplied: boolean;
}

interface CartItemProduct {
  slug: string;
  name: string;
  sku: string;
  imageUrl?: string;
  inStock: boolean;
  currentPrice: number;
}

interface CartDiscount {
  code: string;
  type: string;
  value: number;
}

interface AddToCartInput {
  /** Product ID (eshop product ID or warehouse item ID) */
  productId: string;
  quantity: number;
}

interface CheckoutInput {
  shippingAddress: CheckoutAddress;
  billingAddress: CheckoutAddress;
  email: string;
  phone?: string;
  customerNote?: string;
}

interface CheckoutAddress {
  firstName: string;
  lastName: string;
  company?: string;
  street: string;
  city: string;
  zip: string;
  country: string;
  phone?: string;
}

interface OrderDetail extends OrderListItem {
  items: OrderItem[];
  shippingAddress: CheckoutAddress;
  billingAddress: CheckoutAddress;
  email: string;
  phone?: string;
  customerNote?: string;
  subtotal: number;
  taxTotal: number;
  shippingTotal: number;
  discountTotal: number;
  fulfillmentStatus: FulfillmentStatus;
  statusHistory: OrderStatusHistory[];
  trackingToken?: string;
}

interface OrderListItem {
  id: string;
  orderNumber: string;
  status: OrderStatus;
  paymentStatus: PaymentStatus;
  grandTotal: number;
  currency: string;
  itemCount: number;
  createdAt: number;
}

interface OrderItem {
  productName: string;
  sku: string;
  imageUrl?: string;
  quantity: number;
  unitPrice: number;
  totalPrice: number;
  totalPriceWithTax: number;
}

interface OrderStatusHistory {
  fromStatus?: OrderStatus;
  toStatus: OrderStatus;
  note?: string;
  changedBy?: string;
  createdAt: number;
}

const OrderStatuses = {
  PENDING: "PENDING",
  CONFIRMED: "CONFIRMED",
  PROCESSING: "PROCESSING",
  SHIPPED: "SHIPPED",
  DELIVERED: "DELIVERED",
  CANCELLED: "CANCELLED",
  REFUNDED: "REFUNDED",
} as const;
type OrderStatus = (typeof OrderStatuses)[keyof typeof OrderStatuses];

const PaymentStatuses = {
  UNPAID: "UNPAID",
  PAID: "PAID",
  PARTIALLY_REFUNDED: "PARTIALLY_REFUNDED",
  REFUNDED: "REFUNDED",
} as const;
type PaymentStatus = (typeof PaymentStatuses)[keyof typeof PaymentStatuses];

const FulfillmentStatuses = {
  UNFULFILLED: "UNFULFILLED",
  PARTIALLY_FULFILLED: "PARTIALLY_FULFILLED",
  FULFILLED: "FULFILLED",
} as const;
type FulfillmentStatus = (typeof FulfillmentStatuses)[keyof typeof FulfillmentStatuses];

interface AuthTokens {
  accessToken: string;
  refreshToken: string;
}

interface RegisterInput {
  email: string;
  password: string;
  firstName?: string;
  lastName?: string;
}

interface LoginInput {
  email: string;
  password: string;
}

interface CustomerProfile {
  id: string;
  email: string;
  firstName?: string;
  lastName?: string;
  phone?: string;
  emailVerified: boolean;
}

interface CustomerAddress {
  id: string;
  type: AddressType;
  isDefault: boolean;
  firstName: string;
  lastName: string;
  company?: string;
  street: string;
  city: string;
  zip: string;
  country: string;
  phone?: string;
}

const AddressTypes = {
  SHIPPING: "SHIPPING",
  BILLING: "BILLING",
} as const;
type AddressType = (typeof AddressTypes)[keyof typeof AddressTypes];

interface Bundle {
  id: string;
  slug: string;
  name: string;
  description: string | null;
  bundlePrice: number;
  currency: string;
  coverImage: string | null;
  endsAt: number | null;
  itemsSum: number;
  savings: number;
  savingsPercent: number;
  items: BundleItem[];
}

interface BundleItem {
  productId: string;
  slug: string | null;
  name: string;
  sku: string;
  quantity: number;
  imageUrl: string | null;
  defaultPrice: number | null;
}

interface CrossSellItem {
  productId: string;
  slug: string | null;
  name: string;
  sku: string;
  price: number | null;
  imageUrl: string | null;
  stockCached: number;
}

interface ActivePromotion {
  id: string;
  name: string;
  slug: string;
  type: string;
  discountType: string;
  discountValue: number;
  startsAt: number;
  endsAt: number | null;
  badgeText: string | null;
  badgeColor: string | null;
  showCountdown: boolean;
  couponRequired: boolean;
}

interface GiftCardBalance {
  valid: boolean;
  balance: number;
  currency: string;
}

interface WishlistItem {
  id: string;
  productId: string;
  productName: string;
  productSku: string;
  productSlug: string | null;
  imageUrl: string | null;
  price: number | null;
  stockCached: number;
  createdAt: number;
}

interface ProductReviewsResponse {
  items: ProductReview[];
  averageRating: number;
  reviewCount: number;
  page: number;
  totalPages: number;
}

interface ProductReview {
  id: string;
  authorName: string;
  rating: number;
  title: string | null;
  content: string | null;
  imageUrls: string[];
  isVerifiedPurchase: boolean;
  helpfulCount: number;
  unhelpfulCount: number;
  replyContent: string | null;
  createdAt: number;
}

interface SubmitReviewInput {
  productId: string;
  rating: number;
  title?: string;
  content?: string;
  authorName: string;
  authorEmail?: string;
  imageUrls?: string[];
}

interface ReturnRequest {
  id: string;
  orderId: string;
  status: string;
  reason: string;
  customerNote: string | null;
  refundAmount: number | null;
  refundMethod: string | null;
  createdAt: number;
}

interface SubmitReturnInput {
  orderId: string;
  reason: string;
  customerNote?: string;
  items: {
    orderItemId: string;
    productName: string;
    quantity: number;
    reason?: string;
    imageUrls?: string[];
  }[];
}

interface CookieConsent {
  necessary: boolean;
  analytics: boolean;
  marketing: boolean;
  preferences: boolean;
  consentedAt: number;
}

interface CookieConsentInput {
  visitorId: string;
  analytics: boolean;
  marketing: boolean;
  preferences: boolean;
}

interface QuoteRequest {
  id: string;
  status: string;
  contactName: string;
  contactEmail: string;
  companyName: string | null;
  quotedTotal: number | null;
  createdAt: number;
}

interface SubmitQuoteInput {
  contactName: string;
  contactEmail: string;
  contactPhone?: string;
  companyName?: string;
  companyIco?: string;
  message?: string;
  items: {
    productId: string;
    quantity: number;
    requestedPrice?: number;
  }[];
}

interface Page {
  slug: string;
  title: string;
  isActive: boolean;
}

interface PageDetail {
  slug: string;
  title: string;
  content: unknown;
  seoTitle?: string;
  seoDescription?: string;
}

interface ShopInfo {
  id: string;
  name: string;
  domain: string;
  logo?: string;
  favicon?: string;
  isActive: boolean;
  defaultLanguage: string;
  supportedLanguages: string[];
  defaultCurrency: string;
  supportedCurrencies: string[];
  metaTitle?: string;
  metaDescription?: string;
  allowGuestCheckout: boolean;
}

interface ShopSeo {
  locale: string;
  title: string | null;
  description: string | null;
  keywords: string | null;
  ogTitle: string | null;
  ogDescription: string | null;
  ogImage: string | null;
}

class BehioApiError extends Error {
  readonly code: BehioErrorCode;
  readonly status: number;
  readonly body: unknown;
  readonly isRetryable: boolean;

  constructor(status: number, body: unknown, message?: string);

  /** Check if this is a specific error type */
  is(code: BehioErrorCode): boolean;
}

class BehioNetworkError extends Error {
  readonly code: "NETWORK_ERROR" | "TIMEOUT";
  readonly isRetryable: true;

  constructor(message: string, isTimeout?: boolean);
}

type BehioErrorCode =
  | "UNAUTHORIZED"
  | "FORBIDDEN"
  | "NOT_FOUND"
  | "VALIDATION_ERROR"
  | "CONFLICT"
  | "RATE_LIMITED"
  | "CART_EMPTY"
  | "PRODUCT_NOT_FOUND"
  | "INVALID_CREDENTIALS"
  | "INVALID_DISCOUNT"
  | "DISCOUNT_EXPIRED"
  | "TOKEN_EXPIRED"
  | "TOKEN_INVALID"
  | "EMAIL_ALREADY_EXISTS"
  | "ORDER_NOT_CANCELLABLE"
  | "INTERNAL_ERROR"
  | "NETWORK_ERROR"
  | "TIMEOUT"
  | "UNKNOWN";

type BehioEventType =
  | "auth:login"
  | "auth:logout"
  | "auth:token-refresh"
  | "auth:token-refresh-failed"
  | "cart:updated"
  | "cart:cleared"
  | "order:created"
  | "error"
  | "request"
  | "response"
  | "rate-limit-warning";

type BehioEventHandler = (data?: unknown) => void;

interface RequestInterceptorConfig {
  url: string;
  method: string;
  headers: Record<string, string>;
  body?: string;
}

type RequestInterceptor = (
  config: RequestInterceptorConfig,
) => RequestInterceptorConfig | Promise<RequestInterceptorConfig>;

interface ResponseInterceptorData {
  status: number;
  data: unknown;
  headers: Headers;
}

type ResponseInterceptor = (
  response: ResponseInterceptorData,
) => void | Promise<void>;

interface PaginatedResponse<T> {
  items: T[];
  total: number;
  page: number;
  limit: number;
  totalPages: number;
}

interface MessageResponse {
  message: string;
}