// Webflow CMS API integration for headless usage
class WebflowCMSService {
    constructor(apiToken, siteId) {
        this.apiToken = apiToken;
        this.siteId = siteId;
        this.baseURL = 'https://api.webflow.com';
        this.headers = {
            'Authorization': `Bearer ${apiToken}`,
            'Accept-Version': '1.0.0',
            'Content-Type': 'application/json'
        };
    }
    
    async getSiteInfo() {
        try {
            const response = await fetch(`${this.baseURL}/sites/${this.siteId}`, {
                headers: this.headers
            });
            
            const data = await response.json();
            return {
                id: data._id,
                name: data.name,
                shortName: data.shortName,
                domains: data.domains,
                timezone: data.timezone,
                database: data.database
            };
        } catch (error) {
            console.error('Failed to get site info:', error);
            throw new Error('Unable to retrieve site information');
        }
    }
    
    async getCollections() {
        try {
            const response = await fetch(`${this.baseURL}/sites/${this.siteId}/collections`, {
                headers: this.headers
            });
            
            const data = await response.json();
            return data.map(collection => ({
                id: collection._id,
                name: collection.name,
                slug: collection.slug,
                singularName: collection.singularName,
                fields: collection.fields
            }));
        } catch (error) {
            console.error('Failed to get collections:', error);
            throw new Error('Unable to retrieve collections');
        }
    }
    
    async getCollectionItems(collectionId, limit = 100, offset = 0) {
        try {
            const params = new URLSearchParams({
                limit: limit.toString(),
                offset: offset.toString()
            });
            
            const response = await fetch(
                `${this.baseURL}/collections/${collectionId}/items?${params}`,
                { headers: this.headers }
            );
            
            const data = await response.json();
            return {
                items: data.items,
                count: data.count,
                limit: data.limit,
                offset: data.offset,
                total: data.total
            };
        } catch (error) {
            console.error('Failed to get collection items:', error);
            throw new Error('Unable to retrieve collection items');
        }
    }
    
    async createCollectionItem(collectionId, itemData, live = false) {
        try {
            const response = await fetch(
                `${this.baseURL}/collections/${collectionId}/items?live=${live}`,
                {
                    method: 'POST',
                    headers: this.headers,
                    body: JSON.stringify({ fields: itemData })
                }
            );
            
            const data = await response.json();
            return data;
        } catch (error) {
            console.error('Failed to create collection item:', error);
            throw new Error('Unable to create collection item');
        }
    }
    
    async updateCollectionItem(collectionId, itemId, itemData, live = false) {
        try {
            const response = await fetch(
                `${this.baseURL}/collections/${collectionId}/items/${itemId}?live=${live}`,
                {
                    method: 'PATCH',
                    headers: this.headers,
                    body: JSON.stringify({ fields: itemData })
                }
            );
            
            const data = await response.json();
            return data;
        } catch (error) {
            console.error('Failed to update collection item:', error);
            throw new Error('Unable to update collection item');
        }
    }
    
    async deleteCollectionItem(collectionId, itemId) {
        try {
            const response = await fetch(
                `${this.baseURL}/collections/${collectionId}/items/${itemId}`,
                {
                    method: 'DELETE',
                    headers: this.headers
                }
            );
            
            return response.ok;
        } catch (error) {
            console.error('Failed to delete collection item:', error);
            throw new Error('Unable to delete collection item');
        }
    }
    
    async publishSite(domains = []) {
        try {
            const response = await fetch(
                `${this.baseURL}/sites/${this.siteId}/publish`,
                {
                    method: 'POST',
                    headers: this.headers,
                    body: JSON.stringify({ domains })
                }
            );
            
            const data = await response.json();
            return data;
        } catch (error) {
            console.error('Site publishing failed:', error);
            throw new Error('Unable to publish site');
        }
    }
    
    async getEcommerceSettings() {
        try {
            const response = await fetch(
                `${this.baseURL}/sites/${this.siteId}/ecommerce/settings`,
                { headers: this.headers }
            );
            
            const data = await response.json();
            return data;
        } catch (error) {
            console.error('Failed to get ecommerce settings:', error);
            throw new Error('Unable to retrieve ecommerce settings');
        }
    }
    
    async getOrders(status = 'all', limit = 100, offset = 0) {
        try {
            const params = new URLSearchParams({
                status,
                limit: limit.toString(),
                offset: offset.toString()
            });
            
            const response = await fetch(
                `${this.baseURL}/sites/${this.siteId}/orders?${params}`,
                { headers: this.headers }
            );
            
            const data = await response.json();
            return data;
        } catch (error) {
            console.error('Failed to get orders:', error);
            throw new Error('Unable to retrieve orders');
        }
    }
    
    async updateOrderStatus(orderId, status) {
        try {
            const response = await fetch(
                `${this.baseURL}/sites/${this.siteId}/order/${orderId}/fulfill`,
                {
                    method: 'PATCH',
                    headers: this.headers,
                    body: JSON.stringify({ status })
                }
            );
            
            const data = await response.json();
            return data;
        } catch (error) {
            console.error('Failed to update order status:', error);
            throw new Error('Unable to update order status');
        }
    }
    
    async syncProductsFromExternal(products) {
        try {
            const collections = await this.getCollections();
            const productsCollection = collections.find(c => c.slug === 'products');
            
            if (!productsCollection) {
                throw new Error('Products collection not found');
            }
            
            const results = [];
            
            for (const product of products) {
                const itemData = {
                    name: product.name,
                    slug: product.slug,
                    price: product.price,
                    description: product.description,
                    'main-image': product.imageUrl,
                    'in-stock': product.inStock,
                    'sku': product.sku
                };
                
                const result = await this.createCollectionItem(
                    productsCollection.id,
                    itemData,
                    true // Publish live
                );
                
                results.push(result);
            }
            
            return results;
        } catch (error) {
            console.error('Product sync failed:', error);
            throw new Error('Unable to sync products');
        }
    }
}

// Usage example
const webflowCMS = new WebflowCMSService(
    process.env.WEBFLOW_API_TOKEN,
    process.env.WEBFLOW_SITE_ID
);

async function manageWebflowContent() {
    try {
        // Get site information
        const siteInfo = await webflowCMS.getSiteInfo();
        console.log('Site info:', siteInfo);
        
        // Get all collections
        const collections = await webflowCMS.getCollections();
        console.log('Collections:', collections.length);
        
        // Get blog posts
        const blogCollection = collections.find(c => c.slug === 'blog-posts');
        if (blogCollection) {
            const posts = await webflowCMS.getCollectionItems(blogCollection.id);
            console.log('Blog posts:', posts.total);
        }
        
        // Create new blog post
        const newPost = await webflowCMS.createCollectionItem(
            blogCollection.id,
            {
                name: 'New Blog Post',
                slug: 'new-blog-post',
                'post-body': '<p>This is the content of the blog post.</p>',
                'meta-description': 'A new blog post created via API',
                'featured-image': 'https://example.com/image.jpg'
            },
            true
        );
        
        console.log('New post created:', newPost._id);
        
        // Publish site
        await webflowCMS.publishSite();
        console.log('Site published successfully');
        
    } catch (error) {
        console.error('Webflow management failed:', error);
    }
}