database.js

// ==================== API CONFIGURATION ====================
const API_URL = 'http://localhost:3000/api';

// ==================== HELPER FUNCTIONS ====================

// Get current user from localStorage
const getCurrentUser = () => {
    const userStr = localStorage.getItem('surron_current_user');
    return userStr ? JSON.parse(userStr) : null;
};

// Set current user to localStorage
const setCurrentUser = (user) => {
    localStorage.setItem('surron_current_user', JSON.stringify(user));
};

// Remove current user from localStorage
const removeCurrentUser = () => {
    localStorage.removeItem('surron_current_user');
};

// Generic API call function
const apiCall = async (endpoint, options = {}) => {
    try {
        const response = await fetch(`${API_URL}${endpoint}`, {
            headers: {
                'Content-Type': 'application/json',
                ...options.headers
            },
            ...options
        });

        const data = await response.json();

        if (!response.ok) {
            throw new Error(data.message || 'Request failed');
        }

        return data;
    } catch (error) {
        console.error('API Error:', error);
        throw error;
    }
};

// ==================== DATABASE OBJECT ====================

const DB = {
    
    // ==================== AUTH ====================
    
    async register(username, email, password) {
        const result = await apiCall('/auth/register', {
            method: 'POST',
            body: JSON.stringify({ username, email, password })
        });

        if (result.success && result.data.user) {
            setCurrentUser(result.data.user);
        }

        return result;
    },

    async login(username, password) {
        const result = await apiCall('/auth/login', {
            method: 'POST',
            body: JSON.stringify({ username, password })
        });

        if (result.success && result.data.user) {
            setCurrentUser(result.data.user);
        }

        return result;
    },

    logout() {
        removeCurrentUser();
    },

    getCurrentUser() {
        return getCurrentUser();
    },

    // ==================== PRODUCTS ====================
    
    async getAllProducts(category = null, search = null) {
        try {
            let url = '/products';
            const params = new URLSearchParams();
            
            if (category && category !== 'All') {
                params.append('category', category);
            }
            if (search) {
                params.append('search', search);
            }
            
            if (params.toString()) {
                url += `?${params.toString()}`;
            }

            const result = await apiCall(url);
            return result.success ? result.data : [];
        } catch (error) {
            console.error('Get products error:', error);
            return [];
        }
    },

    async getProduct(id) {
        try {
            const result = await apiCall(`/products/${id}`);
            return result.success ? result.data : null;
        } catch (error) {
            console.error('Get product error:', error);
            return null;
        }
    },

    async createProduct(productData) {
        return await apiCall('/products', {
            method: 'POST',
            body: JSON.stringify(productData)
        });
    },

    async updateProduct(id, productData) {
        return await apiCall(`/products/${id}`, {
            method: 'PUT',
            body: JSON.stringify(productData)
        });
    },

    async deleteProduct(id) {
        return await apiCall(`/products/${id}`, {
            method: 'DELETE'
        });
    },

    // ==================== CART ====================
    
    async getCart() {
        try {
            const user = getCurrentUser();
            if (!user) return { items: [] };

            const result = await apiCall(`/cart/${user.id}`);
            
            // Get full product details for cart items
            if (result.success && result.data.items.length > 0) {
                const cartItems = [];
                for (const item of result.data.items) {
                    const product = await this.getProduct(item.productId);
                    if (product) {
                        cartItems.push({
                            ...product,
                            quantity: item.quantity
                        });
                    }
                }
                return { ...result.data, items: cartItems };
            }

            return result.success ? result.data : { items: [] };
        } catch (error) {
            console.error('Get cart error:', error);
            return { items: [] };
        }
    },

    async addToCart(productId, quantity = 1) {
        const user = getCurrentUser();
        if (!user) {
            throw new Error('Нэвтрэх шаардлагатай');
        }

        return await apiCall(`/cart/${user.id}/add`, {
            method: 'POST',
            body: JSON.stringify({ productId, quantity })
        });
    },

    async updateCartItem(productId, quantity) {
        const user = getCurrentUser();
        if (!user) {
            throw new Error('Нэвтрэх шаардлагатай');
        }

        return await apiCall(`/cart/${user.id}/update`, {
            method: 'PUT',
            body: JSON.stringify({ productId, quantity })
        });
    },

    async removeFromCart(productId) {
        const user = getCurrentUser();
        if (!user) {
            throw new Error('Нэвтрэх шаардлагатай');
        }

        return await apiCall(`/cart/${user.id}/remove/${productId}`, {
            method: 'DELETE'
        });
    },

    async clearCart() {
        const user = getCurrentUser();
        if (!user) {
            throw new Error('Нэвтрэх шаардлагатай');
        }

        return await apiCall(`/cart/${user.id}/clear`, {
            method: 'DELETE'
        });
    },

    // ==================== ORDERS ====================
    
    async createOrder(items, totalAmount, shippingAddress = {}) {
        const user = getCurrentUser();
        if (!user) {
            throw new Error('Нэвтрэх шаардлагатай');
        }

        // Format items for order
        const orderItems = items.map(item => ({
            productId: item.id,
            name: item.name,
            price: item.price,
            quantity: item.quantity,
            image: item.image
        }));

        return await apiCall('/orders', {
            method: 'POST',
            body: JSON.stringify({
                userId: user.id,
                items: orderItems,
                totalAmount,
                shippingAddress
            })
        });
    },

    async getAllOrders() {
        try {
            const user = getCurrentUser();
            if (!user) return [];

            const params = new URLSearchParams({
                userId: user.id,
                role: user.role
            });

            const result = await apiCall(`/orders?${params.toString()}`);
            return result.success ? result.data : [];
        } catch (error) {
            console.error('Get orders error:', error);
            return [];
        }
    },

    async getOrder(id) {
        try {
            const result = await apiCall(`/orders/${id}`);
            return result.success ? result.data : null;
        } catch (error) {
            console.error('Get order error:', error);
            return null;
        }
    },

    async updateOrderStatus(id, status) {
        return await apiCall(`/orders/${id}/status`, {
            method: 'PUT',
            body: JSON.stringify({ status })
        });
    },

    async getDashboardStats() {
        try {
            const result = await apiCall('/orders/stats/dashboard');
            return result.success ? result.data : {
                totalOrders: 0,
                pendingOrders: 0,
                totalRevenue: 0,
                productCount: 0
            };
        } catch (error) {
            console.error('Get stats error:', error);
            return {
                totalOrders: 0,
                pendingOrders: 0,
                totalRevenue: 0,
                productCount: 0
            };
        }
    },

    // ==================== HELPER METHODS ====================

    getCategories() {
        return ['All', 'Electronics', 'Battery', 'Suspension', 'Brakes', 'Wheels', 'Accessories'];
    },

    // Compatibility method for cart badge
    async getCartCount() {
        const cart = await this.getCart();
        return cart.items.reduce((total, item) => total + item.quantity, 0);
    }
};

// Export for use in other files
if (typeof module !== 'undefined' && module.exports) {
    module.exports = DB;
}