// Types de base pour les identifiants
type UUID = string;

// Types pour les prix et quantités
type Price = number;
type Quantity = number;

// Types pour les statuts
type CartStatus = 'ON_GOING' | 'VALIDATED' | 'ARCHIVED';
type CartType = 'CART' | 'WISHLIST';
type OrderStatus = 'INITIALIZED' | 'PAID' | 'CANCELLED';

// Réponse pour la liste des paniers
interface GetCartsResponse {
  carts: Cart[];
  total: number;
  page: number;
  size: number;
}

// Réponse pour un panier spécifique
interface GetCartResponse {
  cart: Cart;
}

// Réponse pour les lignes d'un panier
interface GetCartLinesResponse {
  lines: CartLine[];
}

// Réponse pour la création d'un panier
interface CreateCartResponse {
  cart: Cart;
}

// Réponse pour l'ajout de lignes
interface AddCartLinesResponse {
  lines: CartLine[];
}

// Réponse pour la mise à jour des lignes
interface UpdateCartLinesResponse {
  lines: CartLine[];
}

// Réponse pour la suppression des lignes
interface DeleteCartLinesResponse {
  success: boolean;
}

// Réponse pour la validation du panier
interface ValidateCartResponse {
  orderId: UUID;
}

// Panier
interface Cart {
  id: UUID;
  name: string;
  type: CartType;
  status: CartStatus;
  userId: UUID;
  createdAt: Date;
  updatedAt: Date;
  lineCount: number;
  total: Price;
  subtotal: Price;
  tax: Price;
  currency: string;
}

// Ligne de panier
interface CartLine {
  id: UUID;
  cartId: UUID;
  product: Product;
  quantity: Quantity;
  unitPrice: Price;
  total: Price;
  tax: Price;
  createdAt: Date;
  updatedAt: Date;
}

// Produit
interface Product {
  id: UUID;
  name: string;
  description: string;
  image: string;
  typeId: UUID;
  offerPriceId: UUID;
  price: Price;
  stock: Quantity;
  variants: ProductVariant[];
}

// Variante de produit
interface ProductVariant {
  id: UUID;
  productId: UUID;
  name: string;
  sku: string;
  price: Price;
  stock: Quantity;
}

// Paramètres de pagination
interface Pageable {
  page: number;
  size: number;
}

// Paramètres de création de panier
interface CreateCartRequest {
  name: string;
  type?: CartType;
}

// Paramètres d'ajout au panier
interface AddCartLinesRequest {
  typeId: UUID;
  lines: Array<{
    offerPriceId: UUID;
    quantity: Quantity;
    updateAction: 'ADD_QUANTITY' | 'REPLACE_QUANTITY';
  }>;
}

// Paramètres de mise à jour des lignes
interface UpdateCartLinesRequest {
  lines: Array<{
    lineId: UUID;
    quantity: Quantity;
  }>;
}

// Paramètres de mise à jour des variantes
interface UpdateCartLinesByVariantsRequest {
  variants: Array<{
    variantId: UUID;
    quantity: Quantity;
  }>;
}

// Paramètres de suppression des lignes
interface DeleteCartLinesRequest {
  lineIds: UUID[];
}

// Erreur API
interface ApiError {
  statusCode: number;
  message: string;
  details?: any;
}

// Résultat de validation
interface ValidationResult {
  isValid: boolean;
  message?: string;
  details?: any;
}

// État du store de panier
interface CartState {
  carts: Cart[];
  currentCart: Cart | null;
  cartLines: CartLine[];
  orderId: UUID | null;
  loading: boolean;
  error: ApiError | null;
}

// Actions du store de panier
interface CartActions {
  fetchCarts: (params?: {
    currency?: string;
    pageable?: Pageable;
    status?: CartStatus[];
    type?: CartType;
  }) => Promise<void>;

  fetchCartById: (
    cartId: UUID,
    params?: {
      currency?: string;
    }
  ) => Promise<void>;

  fetchCartLines: (
    cartId: UUID,
    params?: {
      currency?: string;
    }
  ) => Promise<void>;

  createCart: (data: CreateCartRequest) => Promise<void>;

  addProductToCart: (cartId: UUID, data: AddCartLinesRequest) => Promise<void>;

  updateCartLines: (cartId: UUID, data: UpdateCartLinesRequest) => Promise<void>;

  updateCartLinesByVariants: (
    cartId: UUID,
    data: UpdateCartLinesByVariantsRequest
  ) => Promise<void>;

  deleteCartLines: (cartId: UUID, data: DeleteCartLinesRequest) => Promise<void>;

  validateCart: (cartId: UUID) => Promise<void>;
}