import { defineStore } from 'pinia';

const useCart = defineStore('cart', {
    state: () => ({
        items: [],           // Productos en el carrito
        paymentMethod: 'cash' // Método de pago por defecto
    }),
    
    getters: {
        // Total de items
        itemCount: (state) => state.items.reduce((sum, item) => sum + item.quantity, 0),
        
        // Subtotal (sin impuestos)
        subtotal: (state) => state.items.reduce((sum, item) => sum + (item.unit_price * item.quantity), 0),
        
        // Total de impuestos
        tax: (state) => {
            return state.items.reduce((sum, item) => {
                const itemSubtotal = item.unit_price * item.quantity;
                const itemTax = (itemSubtotal * item.tax_rate) / 100;
                return sum + itemTax;
            }, 0);
        },
        
        // Total final
        total: (state) => {
            const subtotal = state.items.reduce((sum, item) => sum + (item.unit_price * item.quantity), 0);
            const tax = state.items.reduce((sum, item) => {
                const itemSubtotal = item.unit_price * item.quantity;
                const itemTax = (itemSubtotal * item.tax_rate) / 100;
                return sum + itemTax;
            }, 0);
            return subtotal + tax;
        },
        
        // Verificar si el carrito está vacío
        isEmpty: (state) => state.items.length === 0
    },
    
    actions: {
        // Agregar producto al carrito
        addProduct(product, serialConfig = null) {
            const existingItem = this.items.find(item => item.inventory_id === product.id);

            if (existingItem) {
                // Si ya existe y tiene seriales, abrir selector de nuevo
                if (existingItem.track_serials) {
                    window.Notify.warning('Este producto requiere selección de seriales');
                    // Emitir evento para que Point.vue abra el selector
                    window.dispatchEvent(new CustomEvent('open-serial-selector', {
                        detail: { productId: product.id }
                    }));
                    return;
                }

                // Si NO tiene seriales, incrementar normalmente
                if (existingItem.quantity < product.stock) {
                    existingItem.quantity++;
                } else {
                    window.Notify.warning('No hay suficiente stock disponible');
                }
            } else {
                // Agregar nuevo item
                this.items.push({
                    inventory_id: product.id,
                    product_name: product.name,
                    sku: product.sku,
                    quantity: 1,
                    unit_price: parseFloat(product.price?.retail_price || 0),
                    tax_rate: parseFloat(product.price?.tax || 16),
                    max_stock: product.stock,
                    // Campos para seriales
                    track_serials: product.track_serials || false,
                    serial_numbers: serialConfig?.serialNumbers || [],
                    serial_selection_mode: serialConfig?.selectionMode || null
                });
            }
        },

        // Agregar producto con seriales ya configurados
        addProductWithSerials(product, quantity, serialConfig) {
            const existingItem = this.items.find(item => item.inventory_id === product.id);
            const newSerials = serialConfig.serialNumbers || [];

            if (existingItem) {
                    // COMBINAR seriales con los existentes
                    const combinedSerials = [...existingItem.serial_numbers, ...newSerials];
                    // Eliminar duplicados
                    existingItem.serial_numbers = [...new Set(combinedSerials)];
                    existingItem.quantity = existingItem.serial_numbers.length;
                } else {
                // Agregar nuevo item con seriales
                this.items.push({
                    inventory_id: product.id,
                    product_name: product.name,
                    sku: product.sku,
                    quantity: quantity,
                    unit_price: parseFloat(product.price?.retail_price || 0),
                    tax_rate: parseFloat(product.price?.tax || 16),
                    max_stock: product.stock,
                    track_serials: product.track_serials,
                    serial_numbers: newSerials
                });
            }
        },

        // Actualizar seriales de un item
        updateSerials(inventoryId, serialConfig) {
            const item = this.items.find(i => i.inventory_id === inventoryId);
            if (item) {
                item.serial_numbers = serialConfig.serialNumbers || [];
                item.serial_selection_mode = serialConfig.selectionMode;
            }
        },

        // Obtener seriales ya seleccionados (para excluir del selector)
        getSelectedSerials() {
            return this.items
                .filter(item => item.track_serials && item.serial_numbers?.length > 0)
                .flatMap(item => item.serial_numbers);
        },

        // Verificar si un item necesita selección de seriales
        needsSerialSelection(inventoryId) {
            const item = this.items.find(i => i.inventory_id === inventoryId);
            if (!item || !item.track_serials) return false;
            // Necesita selección si es manual y no tiene suficientes seriales
            if (item.serial_selection_mode === 'manual') {
                return (item.serial_numbers?.length || 0) < item.quantity;
            }
            return false;
        },
        
        // Actualizar cantidad de un item
        updateQuantity(inventoryId, quantity) {
            const item = this.items.find(i => i.inventory_id === inventoryId);
            if (item) {
                if (quantity <= 0) {
                    this.removeProduct(inventoryId);
                } else if (quantity <= item.max_stock) {
                    item.quantity = quantity;
                } else {
                    window.Notify.warning('No hay suficiente stock disponible');
                }
            }
        },
        
        // Remover producto
        removeProduct(inventoryId) {
            const index = this.items.findIndex(i => i.inventory_id === inventoryId);
            if (index !== -1) {
                this.items.splice(index, 1);
            }
        },
        
        // Limpiar carrito
        clear() {
            this.items = [];
            this.paymentMethod = 'cash';
        },
        
        // Cambiar método de pago
        setPaymentMethod(method) {
            this.paymentMethod = method;
        }
    }
});

export default useCart;