System Architecture

// User document structure in Firestore
{
  "uid": "user_firebase_uid",
  "email": "[email protected]",
  "role": "admin" | "customer",
  "displayName": "John Doe",
  "createdAt": Timestamp,
  "photoURL": "https://..."
}

// Email notifications via Nodemailer
exports.sendOrderConfirmation = emailModule.sendOrderConfirmation;
exports.sendDispatchNotification = emailModule.sendDispatchNotification;

// WhatsApp Business API
exports.whatsappWebhook = whatsappModule.webhook;
exports.sendWhatsappMessage = whatsappModule.sendMessage;

// Scheduled maintenance (runs every 24 hours)
exports.cleanupOldOrders = onSchedule("every 24 hours", ...);
exports.processScheduledTransfers = schedulerModule.processScheduledTransfers;
exports.cancelAbandonedPayments = schedulerModule.cancelAbandonedPayments;
exports.checkExpiredPromotions = schedulerModule.checkExpiredPromotions;

// Firestore trigger: Auto-update product timestamps
exports.touchProductTimestamp = onDocumentWritten("products/{productId}", ...);

// Google Merchant Center feed
exports.generateProductFeed = merchantModule.generateProductFeed;

// Dynamic sitemap generation
exports.sitemap = sitemapModule.sitemap;

{
  "hosting": {
    "public": "public",
    "rewrites": [
      {
        "source": "/sitemap.xml",
        "function": "sitemap"
      },
      {
        "source": "/google-feed.xml",
        "function": "generateProductFeed"
      },
      {
        "source": "**",
        "destination": "/index.html"
      }
    ],
    "headers": [
      {
        "source": "**",
        "headers": [
          {
            "key": "Content-Security-Policy",
            "value": "default-src 'self' https: data: blob: 'unsafe-inline' 'unsafe-eval'"
          }
        ]
      }
    ]
  }
}

const SmartProductSync = {
    STORAGE_KEY: 'pixeltech_master_catalog',
    
    async init() {
        // 1. Instant load from localStorage (0ms)
        const localData = localStorage.getItem(this.STORAGE_KEY);
        if (localData) {
            const parsed = JSON.parse(localData);
            runtimeProductsMap = parsed.map || {};
            lastSyncTime = parsed.lastSync || 0;
            console.log(`📂 Loaded ${Object.keys(runtimeProductsMap).length} products from cache`);
        }

        // 2. Listen for updates since last sync
        this.listenForUpdates(lastSyncTime);
    },

    listenForUpdates(lastSyncTime) {
        const collectionRef = collection(db, "products");
        let q;

        // CASE 1: First visit -> Download all active products
        if (lastSyncTime === 0) {
            q = query(collectionRef, where("status", "==", "active"));
        } 
        // CASE 2: Returning user -> Listen ONLY for changes since last visit
        else {
            q = query(collectionRef, where("updatedAt", ">", new Date(lastSyncTime)));
        }

        onSnapshot(q, (snapshot) => {
            snapshot.docChanges().forEach(change => {
                const data = change.doc.data();
                const id = change.doc.id;

                if (change.type === 'added' || change.type === 'modified') {
                    if (data.status === 'active') {
                        runtimeProductsMap[id] = { id, ...data };
                    } else {
                        delete runtimeProductsMap[id];
                    }
                } else if (change.type === 'removed') {
                    delete runtimeProductsMap[id];
                }
            });

            // Save to localStorage and trigger UI update
            this.saveState();
            window.dispatchEvent(new Event('catalogUpdated'));
        });
    },

    saveState() {
        const state = {
            map: runtimeProductsMap,
            lastSync: Date.now()
        };
        localStorage.setItem(this.STORAGE_KEY, JSON.stringify(state));
    }
};

export async function checkCacheVersion(db) {
    const configRef = doc(db, "config", "system");
    const snap = await getDoc(configRef);
    
    if (snap.exists()) {
        const serverVersion = snap.data().cacheVersion || 1;
        const localVersion = parseInt(localStorage.getItem('pixeltech_cache_version') || '0');

        // If server version is higher, clear all caches
        if (serverVersion > localVersion) {
            console.warn(`🔄 New version detected (v${serverVersion}). Clearing cache...`);
            
            Object.keys(localStorage).forEach(key => {
                if (key.includes('pixeltech_')) {
                    localStorage.removeItem(key);
                }
            });
            
            localStorage.setItem('pixeltech_cache_version', serverVersion.toString());
            window.location.reload(true);
        }
    }
}

exports.createPreference = async (data, context) => {
    // 1. Authenticate user
    const uid = context.auth.uid;
    
    // 2. Validate cart items against DB prices (security)
    for (const item of data.items) {
        const pDoc = await db.collection('products').doc(item.id).get();
        const realPrice = pDoc.data().price;
        // Use realPrice, not client-provided price
    }
    
    // 3. Create order in Firestore with PENDING_PAYMENT status
    const orderRef = await db.collection('orders').add({
        userId: uid,
        items: validatedItems,
        total: calculatedTotal,
        status: 'pending',
        paymentStatus: 'PENDING_PAYMENT',
        createdAt: admin.firestore.Timestamp.now()
    });
    
    // 4. Create MercadoPago preference
    const preference = await client.preference.create({
        items: mpItems,
        external_reference: orderRef.id,
        notification_url: WEBHOOK_URL,
        expires: true,
        expiration_date_from: now,
        expiration_date_to: now + 30 minutes
    });
    
    // 5. Return checkout URL
    return { 
        orderId: orderRef.id, 
        checkoutUrl: preference.init_point 
    };
};

exports.webhook = async (req, res) => {
    // 1. Verify webhook signature
    // 2. Get payment status from MercadoPago
    const payment = await client.payment.get(paymentId);
    
    // 3. Update order status
    await db.collection('orders').doc(orderId).update({
        paymentStatus: payment.status === 'approved' ? 'PAID' : 'FAILED',
        status: payment.status === 'approved' ? 'confirmed' : 'cancelled',
        mercadopagoPaymentId: paymentId
    });
    
    // 4. Trigger email notification (Firestore trigger)
    // sendOrderConfirmation function automatically fires
    
    res.status(200).send('OK');
};

exports.sendOrderConfirmation = onDocumentCreated(
    "orders/{orderId}", 
    async (event) => {
        const order = event.data.data();
        
        // Generate beautiful HTML email
        const html = getBeautifulEmailTemplate('CONFIRMATION', order);
        
        // Send via Nodemailer
        await transporter.sendMail({
            from: process.env.SMTP_EMAIL,
            to: order.shippingInfo.email,
            subject: `Pedido Confirmado #${orderId}`,
            html: html
        });
    }
);

exports.sendDispatchNotification = onDocumentUpdated(
    "orders/{orderId}",
    async (change) => {
        const before = change.data.before.data();
        const after = change.data.after.data();
        
        // Only send if status changed to 'shipped'
        if (before.status !== 'shipped' && after.status === 'shipped') {
            const html = getBeautifulEmailTemplate('DISPATCH', after);
            await transporter.sendMail({...});
        }
    }
);

exports.cleanupOldOrders = onSchedule("every 24 hours", async (event) => {
    // Delete orders older than 90 days with status 'cancelled'
    const cutoff = new Date();
    cutoff.setDate(cutoff.getDate() - 90);
    
    const snapshot = await db.collection('orders')
        .where('status', '==', 'cancelled')
        .where('createdAt', '<', cutoff)
        .get();
    
    const batch = db.batch();
    snapshot.docs.forEach(doc => batch.delete(doc.ref));
    await batch.commit();
    
    console.log(`🗑️ Deleted ${snapshot.size} old orders`);
});

exports.cancelAbandonedPayments = async () => {
    // Find orders pending payment for >30 minutes
    const cutoff = new Date(Date.now() - 30 * 60 * 1000);
    
    const snapshot = await db.collection('orders')
        .where('paymentStatus', '==', 'PENDING_PAYMENT')
        .where('createdAt', '<', cutoff)
        .get();
    
    // Cancel and restore stock
    for (const doc of snapshot.docs) {
        await doc.ref.update({ status: 'cancelled' });
        // Restore inventory...
    }
};

service firebase.storage {
  match /b/{bucket}/o {
    // Products: Public read, authenticated write
    match /products/{allPaths=**} {
      allow read: if true;
      allow write: if request.auth != null;
    }
    
    // Warranties: Only for authenticated users
    match /warranties/{orderId}/{fileName} {
      allow read, write: if request.auth != null;
    }
    
    // Invoices: Only authenticated users
    match /invoices/{fileName} {
      allow read, write: if request.auth != null;
    }
  }
}

// Callable functions automatically include context.auth
exports.createMercadoPagoPreference = functions.https.onCall(
    async (data, context) => {
        // Verify user is authenticated
        if (!context.auth) {
            throw new functions.https.HttpsError(
                'unauthenticated', 
                'User must be logged in'
            );
        }
        
        const uid = context.auth.uid;
        // ... process with uid
    }
);

// HTTP functions require manual verification
exports.mercadoPagoWebhook = functions.https.onRequest(
    async (req, res) => {
        // Verify webhook signature
        const signature = req.headers['x-signature'];
        if (!verifyWebhookSignature(signature, req.body)) {
            return res.status(403).send('Invalid signature');
        }
        // ... process webhook
    }
);