Project Final Setup Checklist

const functions = require('firebase-functions');

const admin = require('firebase-admin');
const { getFirestore } = require('firebase-admin/firestore');
admin.initializeApp();
const db = getFirestore(admin.app(), 'myconcierge');

// 1. GUEST LOGIC: Create Service Request
exports.createServiceRequest = functions.https.onRequest(async (req, res) => {
    // Basic Auth Check (In production, validate JWT from API Gateway)
    const { guest_id, service_type, details } = req.body;

    // Map service types to their specific collection names
    const serviceCollections = {
        'HOUSEKEEPING': 'housekeeping_details',
        'DINING': 'dining_orders',
        'TRANSPORT': 'transport_bookings',
        'FRONT_DESK': 'front_desk_requests',
        'MAINTENANCE': 'maintenance_tickets'
    };

    const collectionName = serviceCollections[service_type];
    if (!collectionName) {
        res.status(400).send(`Invalid service_type: ${service_type}`);
        return;
    }

    try {
        // Create Master Request
        const requestRef = await db.collection('master_requests').add({
            guest_id: guest_id,
            service_type: service_type,
            status: 'PENDING',
            created_at: admin.firestore.FieldValue.serverTimestamp(),
            assigned_staff_id: null
        });

        // Create Service Specific Detail
        await db.collection(collectionName).add({
            request_id: requestRef.id,
            ...details
        });

        res.status(200).json({ result: 'success', request_id: requestRef.id });
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 5. GUEST LOGIC: Retrieve Menu Items
exports.getMenuItems = functions.https.onRequest(async (req, res) => {
    try {
        const snapshot = await db.collection('menu_items')
            .where('available', '==', true)
            .get();

        const menu = [];
        snapshot.forEach(doc => {
            menu.push({ id: doc.id, ...doc.data() });
        });

        res.status(200).json(menu);
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 3. GUEST LOGIC: Retrieve Requests for a specific User
exports.getGuestRequests = functions.https.onRequest(async (req, res) => {
    const guest_id = req.query.guest_id || req.body.guest_id;

    if (!guest_id) {
        res.status(400).send('Missing guest_id');
        return;
    }

    try {
        const snapshot = await db.collection('master_requests')
            .where('guest_id', '==', guest_id)
            .orderBy('created_at', 'desc')
            .get();

        const serviceCollections = {
            'HOUSEKEEPING': 'housekeeping_details',
            'DINING': 'dining_orders',
            'TRANSPORT': 'transport_bookings',
            'FRONT_DESK': 'front_desk_requests',
            'MAINTENANCE': 'maintenance_tickets'
        };

        const promises = snapshot.docs.map(async (doc) => {
            const reqData = { id: doc.id, ...doc.data() };
            const collectionName = serviceCollections[reqData.service_type];
            if (collectionName) {
                const detailSnapshot = await db.collection(collectionName).where('request_id', '==', doc.id).limit(1).get();
                reqData.details = detailSnapshot.empty ? {} : detailSnapshot.docs[0].data();
            } else {
                reqData.details = {};
            }
            return reqData;
        });

        const requests = await Promise.all(promises);

        res.status(200).json(requests);
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 4. STAFF LOGIC: Retrieve Requests for Service Provider
exports.getServiceRequests = functions.https.onRequest(async (req, res) => {
    const service_type = req.query.service_type || req.body.service_type;
    
    if (!service_type) {
        res.status(400).send('Missing service_type');
        return;
    }

    try {
        const snapshot = await db.collection('master_requests')
            .where('service_type', '==', service_type)
            .orderBy('created_at', 'desc')
            .get();

        const serviceCollections = {
            'HOUSEKEEPING': 'housekeeping_details',
            'DINING': 'dining_orders',
            'TRANSPORT': 'transport_bookings',
            'FRONT_DESK': 'front_desk_requests',
            'MAINTENANCE': 'maintenance_tickets'
        };

        const promises = snapshot.docs.map(async (doc) => {
            const reqData = { id: doc.id, ...doc.data() };
            const collectionName = serviceCollections[reqData.service_type];
            if (collectionName) {
                console.log(`[DEBUG] Fetching details for Req ID: ${doc.id} Type: ${reqData.service_type} Collection: ${collectionName}`);
                const detailSnapshot = await db.collection(collectionName).where('request_id', '==', doc.id).limit(1).get();
                console.log(`[DEBUG] Found ${detailSnapshot.size} detail docs for ${doc.id}`);
                reqData.details = detailSnapshot.empty ? { _debug_message: "No details found in DB" } : detailSnapshot.docs[0].data();
            } else {
                console.log(`[DEBUG] Unknown service type: ${reqData.service_type} for Req ID: ${doc.id}`);
                reqData.details = {};
            }
            return reqData;
        });

        const requests = await Promise.all(promises);

        res.status(200).json(requests);
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 2. STAFF LOGIC: Update Request Status
exports.updateRequestStatus = functions.https.onRequest(async (req, res) => {
    const { request_id, staff_id, new_status } = req.body;

    try {
        const requestRef = db.collection('master_requests').doc(request_id);
        const doc = await requestRef.get();

        if (!doc.exists) {
            res.status(404).send('Request not found');
            return;
        }

        const updateData = { status: new_status }; // 'ASSIGNED' or 'COMPLETED'
        
        // If accepting task, lock it to staff member
        if (new_status === 'ASSIGNED') {
            updateData.assigned_staff_id = staff_id;
        }

        await requestRef.update(updateData);
        
        // Trigger Notification Logic
        if (new_status === 'COMPLETED') {
            console.log(`Notify Guest: Request ${request_id} (${doc.data().service_type}) is complete.`);
        }

        res.status(200).json({ result: 'updated' });
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 6. STAFF LOGIC: Create Guest User
// Staff creates the user manually since booking integration is pending
exports.createGuestUser = functions.https.onRequest(async (req, res) => {
    const { email, password, first_name, last_name, room_number, valid_from, valid_to } = req.body;

    if (!email || !password || !first_name || !last_name) {
        res.status(400).send('Missing required fields: email, password, first_name, last_name');
        return;
    }

    try {
        // 1. Create User in Firebase Auth
        const userRecord = await admin.auth().createUser({
            email: email,
            password: password,
            displayName: `${first_name} ${last_name}`
        });

        // 2. Create User Profile in Firestore
        await db.collection('users').doc(userRecord.uid).set({
            email: email,
            role: 'GUEST',
            first_name: first_name,
            last_name: last_name,
            room_number: room_number || null,
            valid_from: valid_from || null,
            valid_to: valid_to || null,
            created_at: admin.firestore.FieldValue.serverTimestamp(),
        });

        res.status(200).json({ result: 'success', uid: userRecord.uid, message: 'Guest user created' });
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 7. STAFF LOGIC: Update User Details
exports.updateUserDetails = functions.https.onRequest(async (req, res) => {
    // In production: Verify req.user.role === 'STAFF'
    const { target_user_id, first_name, last_name, room_number, valid_from, valid_to } = req.body;

    if (!target_user_id) {
        res.status(400).send('Missing target_user_id');
        return;
    }

    try {
        await db.collection('users').doc(target_user_id).update({
            first_name: first_name,
            last_name: last_name,
            room_number: room_number,
            valid_from: valid_from, // ISO Date String expected
            valid_to: valid_to,     // ISO Date String expected
            updated_at: admin.firestore.FieldValue.serverTimestamp()
        });
        
        res.status(200).json({ result: 'success', message: 'User details updated' });
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 8. STAFF LOGIC: Get a single user's profile
exports.getUserProfile = functions.https.onRequest(async (req, res) => {
    const { uid } = req.query;
    if (!uid) {
        return res.status(400).send('Missing uid query parameter.');
    }
    try {
        const userDoc = await db.collection('users').doc(uid).get();
        if (!userDoc.exists) {
            return res.status(404).send('User not found.');
        }
        res.status(200).json({ id: userDoc.id, ...userDoc.data() });
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 9. STAFF LOGIC: Get overview counts for the staff dashboard
exports.getStaffOverview = functions.https.onRequest(async (req, res) => {
    try {
        const overview = {
            'HOUSEKEEPING': { pending: 0, inProgress: 0 },
            'DINING': { pending: 0, inProgress: 0 },
            'TRANSPORT': { pending: 0, inProgress: 0 },
            'FRONT_DESK': { pending: 0, inProgress: 0 },
            'MAINTENANCE': { pending: 0, inProgress: 0 },
        };

        const snapshot = await db.collection('master_requests')
            .where('status', 'in', ['PENDING', 'ASSIGNED']).get();

        snapshot.forEach(doc => {
            const request = doc.data();
            if (overview[request.service_type]) {
                if (request.status === 'PENDING') {
                    overview[request.service_type].pending++;
                } else if (request.status === 'ASSIGNED') {
                    overview[request.service_type].inProgress++;
                }
            }
        });
        res.status(200).json(overview);
    } catch (error) {
        res.status(500).send(error.message);
    }
});

// 10. STAFF LOGIC: Get all active guests
exports.getActiveGuests = functions.https.onRequest(async (req, res) => {
    try {
        const snapshot = await db.collection('users').where('role', '==', 'GUEST').get();
        const guests = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
        // In a production app with many guests, this should be optimized,
        // for example by storing a request count on the user document itself.
        res.status(200).json(guests);
    } catch (error) {
        res.status(500).send(error.message);
    }
});