Google Sheets Integration

function handleSaveSchedule(spreadsheet, scheduleObject) {
    const sheetName = 'Schedule';
    const headers = ['day', 'isOpen', 'slots'];
    
    // Transform schedule object to array format
    const scheduleArray = Object.keys(scheduleObject).map(day => {
        const dayData = scheduleObject[day];
        return {
            day: day,
            isOpen: dayData.isOpen,
            slots: JSON.stringify(dayData.slots || [])
        };
    });

    return syncSheet(spreadsheet, sheetName, scheduleArray, headers);
}

function getOrders(sheet) {
    const { headers, data } = getSheetDataWithHeaders(sheet);
    const statusIndex = headers.indexOf('status');
    const finishedStatuses = [
        'Completado (Retirado)',
        'Completado (Entregado)',
        'Completado (En Mesa)',
        'Cancelado'
    ];
    
    return data
        .filter(row => !finishedStatuses.includes(row[statusIndex]))
        .map(row => convertRowToObject(row, headers));
}

function sheetToJSON(sheet) {
    const data = sheet.getDataRange().getValues();
    const headers = data.shift();

    return data.map(row => {
        const obj = {};
        headers.forEach((header, i) => {
            let value = row[i];
            
            // Convert string booleans
            if (typeof value === 'string') {
                if (value.toLowerCase() === 'true') value = true;
                else if (value.toLowerCase() === 'false') value = false;
                
                // Convert numbers
                else if (!isNaN(value) && value.trim() !== '') {
                    if (String(parseFloat(value)) === value) {
                        value = parseFloat(value);
                    }
                }
                
                // Parse JSON objects/arrays
                else if (
                    (value.startsWith('{') && value.endsWith('}')) ||
                    (value.startsWith('[') && value.endsWith(']'))
                ) {
                    try {
                        value = JSON.parse(value);
                    } catch (e) { /* Keep as string */ }
                }
            }
            
            obj[header] = value;
        });
        return obj;
    });
}

function updateRowById(sheet, payload) {
    const { id, updates } = payload;
    const { headers, data } = getSheetDataWithHeaders(sheet);
    const idIndex = headers.indexOf('id');
    
    // Find row by ID
    const rowIndexInData = data.findIndex(
        row => String(row[idIndex]) === String(id)
    );
    
    if (rowIndexInData === -1) {
        throw new Error(`No se encontró un item con el ID: ${id}`);
    }
    
    const sheetRowIndex = rowIndexInData + 2; // Account for header row
    const updatedRowData = convertRowToObject(data[rowIndexInData], headers);
    
    // Merge updates
    for (const key in updates) {
        if (headers.includes(key)) {
            updatedRowData[key] = updates[key];
        }
    }
    
    // Write back to sheet
    const newRowValues = headers.map(header => {
        let value = updatedRowData[header];
        return (typeof value === 'object' && value !== null)
            ? JSON.stringify(value)
            : (value ?? '');
    });
    
    sheet.getRange(sheetRowIndex, 1, 1, headers.length)
         .setValues([newRowValues]);
    
    return updatedRowData;
}

function authenticate(params) {
    if (params.secret !== SECRET_KEY) {
        throw new Error('Autenticación fallida: Clave secreta inválida.');
    }
}

function createErrorResponse(error) {
    Logger.log(error.stack);
    return ContentService.createTextOutput(
        JSON.stringify({
            status: 'error',
            message: error.message
        })
    ).setMimeType(ContentService.MimeType.JSON);
}

function getOrCreateSheet(spreadsheet, name) {
    let sheet = spreadsheet.getSheetByName(name);
    if (!sheet) {
        sheet = spreadsheet.insertSheet(name);
    }
    return sheet;
}

function syncSheet(spreadsheet, sheetName, dataArray, headers) {
    const sheet = getOrCreateSheet(spreadsheet, sheetName);
    sheet.clear(); // Clear existing data
    
    // Prepare all rows at once
    const rows = [headers];
    dataArray.forEach(item => {
        const row = headers.map(header => {
            let value = item[header];
            if (value === null || value === undefined) return '';
            if (typeof value === 'object') return JSON.stringify(value);
            return value;
        });
        rows.push(row);
    });
    
    // Single batch write
    sheet.getRange(1, 1, rows.length, headers.length).setValues(rows);
    
    return { status: 'success', written: dataArray.length };
}

const API_URL = 'https://script.google.com/macros/s/.../exec';
const SECRET_KEY = 'your-secret-key';

export const syncAllData = async (data: any) => {
    const response = await fetch(API_URL, {
        method: 'POST',
        body: JSON.stringify({
            secret: SECRET_KEY,
            action: 'syncAllData',
            sheetId: SHEET_ID,
            payload: data
        })
    });
    return response.json();
};

export const getData = async (sheetName: string) => {
    const params = new URLSearchParams({
        secret: SECRET_KEY,
        action: 'getAllData',
        sheetId: SHEET_ID,
        sheetName: sheetName
    });
    
    const response = await fetch(`${API_URL}?${params}`);
    return response.json();
};