// Square Web Payments SDK integration
async function initializeSquarePayments() {
    if (!window.Square) {
        throw new Error('Square.js failed to load properly');
    }
    
    const payments = Square.payments(applicationId, locationId);
    let card;
    
    try {
        // Initialize card payment method
        card = await payments.card();
        await card.attach('#card-container');
        
        // Initialize Google Pay
        const googlePay = await payments.googlePay({
            // Google Pay configuration
        });
        
        // Initialize Apple Pay
        const applePay = await payments.applePay({
            // Apple Pay configuration
        });
        
        // Handle payment form submission
        document.getElementById('card-button').addEventListener('click', async () => {
            await handlePaymentMethodSubmission(card, 'card');
        });
        
    } catch (e) {
        console.error('Initializing payments failed', e);
    }
}

async function handlePaymentMethodSubmission(paymentMethod, type) {
    try {
        const result = await paymentMethod.tokenize();
        
        if (result.status === 'OK') {
            // Send token to server
            const paymentResponse = await fetch('/process-payment', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    sourceId: result.token,
                    amount: 1000, // $10.00 in cents
                    currency: 'USD'
                }),
            });
            
            const paymentResult = await paymentResponse.json();
            
            if (paymentResult.success) {
                window.location.href = '/success';
            } else {
                displayPaymentError(paymentResult.error);
            }
        } else {
            displayPaymentError(result.errors);
        }
    } catch (e) {
        console.error('Payment tokenization failed', e);
        displayPaymentError(['Payment failed. Please try again.']);
    }
}

function displayPaymentError(errors) {
    const errorDiv = document.getElementById('payment-errors');
    errorDiv.innerHTML = errors.map(error => `<p>${error.message || error}</p>`).join('');
}

// Initialize on page load
document.addEventListener('DOMContentLoaded', initializeSquarePayments);

// Square server-side integration
const { Client, Environment, ApiError } = require('squareup');
const { randomBytes } = require('crypto');

class SquarePaymentService {
    constructor() {
        this.client = new Client({
            accessToken: process.env.SQUARE_ACCESS_TOKEN,
            environment: process.env.NODE_ENV === 'production' 
                ? Environment.Production 
                : Environment.Sandbox
        });
        
        this.paymentsApi = this.client.paymentsApi;
        this.ordersApi = this.client.ordersApi;
        this.customersApi = this.client.customersApi;
    }
    
    async createPayment(sourceId, amount, currency = 'USD') {
        const requestBody = {
            sourceId: sourceId,
            idempotencyKey: randomBytes(32).toString('hex'),
            amountMoney: {
                amount: amount, // Amount in smallest currency unit
                currency: currency
            },
            locationId: process.env.SQUARE_LOCATION_ID,
            note: 'Payment processed via Square API'
        };
        
        try {
            const response = await this.paymentsApi.createPayment(requestBody);
            
            if (response.result.payment) {
                return {
                    success: true,
                    payment: response.result.payment,
                    transactionId: response.result.payment.id
                };
            } else {
                throw new Error('Payment creation failed');
            }
        } catch (error) {
            if (error instanceof ApiError) {
                return {
                    success: false,
                    error: error.errors || ['Payment processing failed']
                };
            }
            throw error;
        }
    }
    
    async createOrder(items, customerId = null) {
        const lineItems = items.map(item => ({
            quantity: item.quantity.toString(),
            basePriceMoney: {
                amount: Math.round(item.price * 100),
                currency: 'USD'
            },
            name: item.name
        }));
        
        const requestBody = {
            order: {
                locationId: process.env.SQUARE_LOCATION_ID,
                lineItems: lineItems
            },
            idempotencyKey: randomBytes(32).toString('hex')
        };
        
        if (customerId) {
            requestBody.order.customerId = customerId;
        }
        
        try {
            const response = await this.ordersApi.createOrder(requestBody);
            return response.result.order;
        } catch (error) {
            console.error('Order creation failed:', error);
            throw new Error('Failed to create order');
        }
    }
    
    async createCustomer(customerData) {
        const requestBody = {
            givenName: customerData.firstName,
            familyName: customerData.lastName,
            emailAddress: customerData.email,
            phoneNumber: customerData.phone
        };
        
        try {
            const response = await this.customersApi.createCustomer(requestBody);
            return response.result.customer;
        } catch (error) {
            console.error('Customer creation failed:', error);
            throw new Error('Failed to create customer');
        }
    }
    
    async refundPayment(paymentId, amount) {
        const requestBody = {
            idempotencyKey: randomBytes(32).toString('hex'),
            amountMoney: {
                amount: amount,
                currency: 'USD'
            },
            paymentId: paymentId
        };
        
        try {
            const response = await this.client.refundsApi.refundPayment(requestBody);
            return response.result.refund;
        } catch (error) {
            console.error('Refund failed:', error);
            throw new Error('Failed to process refund');
        }
    }
    
    async getPayment(paymentId) {
        try {
            const response = await this.paymentsApi.getPayment(paymentId);
            return response.result.payment;
        } catch (error) {
            console.error('Get payment failed:', error);
            throw new Error('Failed to retrieve payment');
        }
    }
}

// Express.js routes
const squareService = new SquarePaymentService();

app.post('/api/square/process-payment', async (req, res) => {
    try {
        const { sourceId, amount, currency } = req.body;
        
        const result = await squareService.createPayment(sourceId, amount, currency);
        res.json(result);
    } catch (error) {
        res.status(500).json({ 
            success: false, 
            error: 'Payment processing failed' 
        });
    }
});

app.post('/api/square/create-order', async (req, res) => {
    try {
        const { items, customerId } = req.body;
        
        const order = await squareService.createOrder(items, customerId);
        res.json({ success: true, order });
    } catch (error) {
        res.status(500).json({ 
            success: false, 
            error: error.message 
        });
    }
});

app.post('/api/square/refund', async (req, res) => {
    try {
        const { paymentId, amount } = req.body;
        
        const refund = await squareService.refundPayment(paymentId, amount);
        res.json({ success: true, refund });
    } catch (error) {
        res.status(500).json({ 
            success: false, 
            error: error.message 
        });
    }
});

// Square Point of Sale API integration
class SquarePOSIntegration {
    constructor() {
        this.baseUrl = 'square-commerce-v1://payment/create';
    }
    
    generatePOSRequest(amount, currency = 'USD', note = '') {
        const request = {
            amount_money: {
                amount: Math.round(amount * 100),
                currency_code: currency
            },
            callback_url: 'myapp://payment-complete',
            client_id: process.env.SQUARE_APPLICATION_ID,
            version: '1.3',
            notes: note,
            options: {
                supported_tender_types: ['CREDIT_CARD', 'CASH', 'OTHER'],
                auto_return_timeout_ms: 10000
            }
        };
        
        const requestData = btoa(JSON.stringify(request));
        return `${this.baseUrl}?data=${requestData}`;
    }
    
    launchSquarePOS(amount, description) {
        const posUrl = this.generatePOSRequest(amount, 'USD', description);
        
        if (this.isMobile()) {
            // Mobile app deep link
            window.location.href = posUrl;
        } else {
            // Web integration
            this.showMobilePOSInstructions(posUrl);
        }
    }
    
    isMobile() {
        return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i
            .test(navigator.userAgent);
    }
    
    showMobilePOSInstructions(posUrl) {
        // Display QR code or instructions for mobile POS
        const qrCode = this.generateQRCode(posUrl);
        document.getElementById('pos-instructions').innerHTML = `
            <div class="pos-integration">
                <h3>Complete Payment with Square POS</h3>
                <p>Scan this QR code with your Square POS app:</p>
                <div class="qr-code">${qrCode}</div>
                <p>Or click this link on your mobile device:</p>
                <a href="${posUrl}" class="pos-link">Open in Square POS</a>
            </div>
        `;
    }
    
    handlePOSCallback(transactionData) {
        // Handle response from Square POS
        if (transactionData.status === 'ok') {
            this.processPOSTransaction(transactionData);
        } else {
            this.handlePOSError(transactionData.error_code);
        }
    }
}

// Usage
const squarePOS = new SquarePOSIntegration();

document.getElementById('pos-payment-btn').addEventListener('click', () => {
    squarePOS.launchSquarePOS(29.99, 'Coffee and pastry');
});