import { defineStore } from 'pinia';
import cashRegisterService from '@Services/cashRegisterService';

/**
 * Helper para extraer mensaje de error de diferentes formatos
 * @param {Error|Object} error - Error object
 * @param {String} defaultMessage - Mensaje por defecto
 * @returns {String}
 */
const extractErrorMessage = (error, defaultMessage) => {
    return error?.response?.data?.message ||
           error?.message ||
           error?.error ||
           defaultMessage;
};

const useCashRegister = defineStore('cashRegister', {
    state: () => ({
        currentRegister: null,     // Caja actualmente abierta
        isOpen: false,              // Estado de la caja
        loading: false,             // Indicador de carga
        error: null                 // Error al cargar
    }),

    getters: {
        // Verificar si hay caja abierta
        hasOpenRegister: (state) => state.isOpen && state.currentRegister !== null,

        // ID de la caja actual
        currentRegisterId: (state) => state.currentRegister?.id || null,

        // Usuario que abrió la caja
        openedBy: (state) => state.currentRegister?.user?.name || 'N/A',

        // Fecha y hora de apertura
        openedAt: (state) => state.currentRegister?.opened_at || null,

        // Efectivo inicial
        initialCash: (state) => parseFloat(state.currentRegister?.initial_cash || 0),

        // Total de ventas realizadas
        totalSales: (state) => parseFloat(state.currentRegister?.total_sales || 0),

        // Número de transacciones
        transactionCount: (state) => parseInt(state.currentRegister?.transaction_count || 0),

        // Efectivo esperado (inicial + ventas en efectivo)
        expectedCash: (state) => {
            const initial = parseFloat(state.currentRegister?.initial_cash || 0);
            const cashSales = parseFloat(state.currentRegister?.cash_sales || 0);
            return initial + cashSales;
        },

        // Ventas con tarjeta
        cardSales: (state) => parseFloat(state.currentRegister?.card_sales || 0),

        // Balance actual estimado
        currentBalance: (state) => {
            const initial = parseFloat(state.currentRegister?.initial_cash || 0);
            const total = parseFloat(state.currentRegister?.total_sales || 0);
            return initial + total;
        }
    },

    actions: {
        /**
         * Cargar la caja registradora actual desde el backend
         */
        async loadCurrentRegister() {
            this.loading = true;
            this.error = null;

            try {
                const register = await cashRegisterService.getCurrentCashRegister();

                // El servicio ya maneja el 404 y devuelve null
                // También verifica que el status sea 'open'
                if (register === null) {
                    this.currentRegister = null;
                    this.isOpen = false;
                } else if (register && register.id) {
                    // El servicio ya devuelve el objeto register directamente
                    this.currentRegister = register;
                    // Verificar que el status sea 'open'
                    this.isOpen = register.status === 'open';
                } else {
                    this.currentRegister = null;
                    this.isOpen = false;
                }
            } catch (error) {
                // Si no hay caja abierta (404), no es un error
                if (error.status === 404 || error.response?.status === 404) {
                    this.currentRegister = null;
                    this.isOpen = false;
                } else {
                    this.error = error.message || 'Error al cargar la caja registradora';
                    // Aún así limpiamos el estado
                    this.currentRegister = null;
                    this.isOpen = false;
                }
            } finally {
                this.loading = false;
            }
        },

        /**
         * Abrir una nueva caja registradora
         * @param {Number} initialCash - Monto inicial en efectivo
         */
        async openRegister(initialCash) {
            // Validar que no haya caja ya abierta
            if (this.isOpen) {
                this.error = 'Ya hay una caja abierta';
                return { success: false, error: this.error };
            }

            this.loading = true;
            this.error = null;

            try {
                const register = await cashRegisterService.openCashRegister(initialCash);

                if (register && register.id) {
                    // El servicio ya devuelve el objeto register directamente
                    this.currentRegister = register;
                    this.isOpen = register.status === 'open';
                    return { success: true, data: register };
                } else {
                    this.error = 'Respuesta inválida del servidor';
                    return { success: false, error: this.error };
                }
            } catch (error) {
                this.error = extractErrorMessage(error, 'Error al abrir la caja');
                return { success: false, error: this.error };
            } finally {
                this.loading = false;
            }
        },

        /**
         * Cerrar la caja registradora actual
         * @param {Object} closeData - Datos del cierre (final_cash, notes)
         */
        async closeRegister(closeData) {
            if (!this.currentRegister?.id) {
                this.error = 'No hay caja abierta para cerrar';
                return { success: false, error: this.error };
            }

            this.loading = true;
            this.error = null;

            try {
                const register = await cashRegisterService.closeCashRegister(
                    this.currentRegister.id,
                    closeData
                );

                if (register) {
                    // Limpiar estado
                    this.currentRegister = null;
                    this.isOpen = false;
                    return { success: true, data: register };
                } else {
                    this.error = 'Respuesta inválida del servidor';
                    return { success: false, error: this.error };
                }
            } catch (error) {
                this.error = extractErrorMessage(error, 'Error al cerrar la caja');
                return { success: false, error: this.error };
            } finally {
                this.loading = false;
            }
        },

        /**
         * Actualizar datos de la caja actual (útil después de una venta)
         */
        async refreshCurrentRegister() {
            if (this.isOpen) {
                await this.loadCurrentRegister();
            }
        },

        /**
         * Limpiar el estado
         */
        reset() {
            this.currentRegister = null;
            this.isOpen = false;
            this.loading = false;
            this.error = null;
        }
    }
});

export default useCashRegister;
