const _ = require('lodash');
const { BookingAppointment } = require('../../models/booking');
const { apiResponse } = require("../../core/response/response")
const { SUCCESS, REDIRECTION, CLIENT_ERROR, SERVER_ERROR } = require("../../core/response/statusCode")
const { ERROR_MSG, SUCCESS_MSG } = require("../../core/response/messages")
const { dateFormat } = require('../../core/utilities/commonService');
const mongoose = require("mongoose");

const { User } = require('../../models/user');
const { Role } = require('../../models/role');
const axios = require('axios');
const DAILY_API_KEY = process.env.DAILY_API_KEY;

export { }


exports.appointmentListing = async (req, res) => {
    var title_lang = 'en';
    const lang = req.headers["accept-language"] || 'en';

    let startDate = new Date();
    let endDate = new Date(startDate.getFullYear(), startDate.getMonth() + 1, 0);



    try {
        const {patient_name, doctor_hospital_name, list_type, custom_booking_date, custom_slot, doctor_hospital_id, patient_id , createdAt , updatedAt } = req.body;

        let filteredQuery = {
        }

        let concatFilter = {

        }

        let filteredQueryWithRescheduled = {
        }

        let patient_name_regex = new RegExp(patient_name,'i');
        let doctor_hospital_name_regex = new RegExp(doctor_hospital_name,'i');
        let custom_slot_regex = new RegExp(custom_slot,'i');

        let booking_date = new Date(dateFormat(custom_booking_date, 'yyyy-MM-dd'));
        booking_date.setDate(booking_date.getDate() + 1)


        const filter_createdAtBooking = (custom_booking_date && custom_booking_date != 'undefined') ? { booking_date: {$gte: new Date(dateFormat(custom_booking_date, 'yyyy-MM-dd')), $lt:  new Date(dateFormat(booking_date, 'yyyy-MM-dd'))} } : {};

        const filter_createdAtRescheduled = (custom_booking_date && custom_booking_date != 'undefined') ? { reschedule_date: {$gte: new Date(dateFormat(custom_booking_date, 'yyyy-MM-dd')), $lt:  new Date(dateFormat(booking_date, 'yyyy-MM-dd'))} } : {};

        const filter_custom_slot = (custom_slot && custom_slot != 'undefined')  ? { slot: custom_slot_regex } : {};
        const filter_custom_reschedule_slot = (custom_slot && custom_slot != 'undefined')  ? { reschedule_slot: custom_slot_regex } : {};

        
         if(createdAt)
            {
                filteredQuery["createdAt"] = { $gte : new Date( (new Date(createdAt)).setUTCHours(0 , 0 , 0)) , $lte :  new Date((new Date(createdAt)).setUTCHours(23 , 59 , 59))};
            }

            if(updatedAt)
            {
                filteredQuery["updatedAt"] = { $gte : new Date((new Date(updatedAt)).setUTCHours(0 , 0 , 0)) , $lte :  new Date((new Date(updatedAt)).setUTCHours(23 , 59 , 59))};
            }

        if(createdAt)
            {
                filteredQueryWithRescheduled["createdAt"] = { $gte : new Date( (new Date(createdAt)).setUTCHours(0 , 0 , 0)) , $lte :  new Date((new Date(createdAt)).setUTCHours(23 , 59 , 59))};
            }

            if(updatedAt)
            {
                filteredQueryWithRescheduled["updatedAt"] = { $gte : new Date((new Date(updatedAt)).setUTCHours(0 , 0 , 0)) , $lte :  new Date((new Date(updatedAt)).setUTCHours(23 , 59 , 59))};
            }


        filteredQuery = {...filter_createdAtBooking, ...filter_custom_slot , ...filteredQuery}
        filteredQueryWithRescheduled = {...filter_createdAtRescheduled, ...filter_custom_reschedule_slot , ...filteredQueryWithRescheduled}

        if (list_type == "All") {

            //Don't need to check status in all case
        } else if (list_type == "UPCOMING") {

            filteredQuery['booking_date'] = { $gte: startDate, $lte: endDate }
            filteredQuery['status'] = "APPROVED";

            filteredQueryWithRescheduled['reschedule_date'] = { $gte: startDate, $lte: endDate }
            filteredQueryWithRescheduled['status'] = "APPROVED";
        }else if (list_type == "TODAY") {

            const today = new Date(); // This gets the current date and time
            today.setUTCHours(0, 0, 0, 0); // Set time to the beginning of the day in UTC
            const tomorrow = new Date(today); // Clone the today date object
            tomorrow.setUTCDate(today.getUTCDate() + 1); 
            
            filteredQuery['booking_date'] = { $gte: today, $lt: tomorrow }
            filteredQuery['status'] = "APPROVED";

            filteredQueryWithRescheduled['reschedule_date'] = { $gte: today, $lt: tomorrow }
            filteredQueryWithRescheduled['status'] = "APPROVED";
        } else {
            // PENDING | APPROVED | REJECTED | COMPLETED
            filteredQuery['status'] = list_type;
            filteredQueryWithRescheduled['status'] = list_type;
        }

        if(doctor_hospital_id){
            filteredQuery['hospital_doctor_id'] = new mongoose.Types.ObjectId(doctor_hospital_id);
            filteredQueryWithRescheduled['hospital_doctor_id'] = new mongoose.Types.ObjectId(doctor_hospital_id);
        }

        if(patient_id){
            filteredQuery['patient_id'] = new mongoose.Types.ObjectId(patient_id);
            filteredQueryWithRescheduled['patient_id'] = new mongoose.Types.ObjectId(patient_id);
        }


        


        let matchCondition = {
            $or: [
                filteredQuery,
                filteredQueryWithRescheduled
            ]
        }



        let page, limit: number;
        page = req.query.page ? parseInt(req.query.page) - 1 : 0;
        limit = req.query.limit ? parseInt(req.query.limit) : 10;
        let skip = parseInt(page) * limit;


        


        const filter_patient_name = (patient_name && patient_name != 'undefined')  ? { patient_name: patient_name_regex } : {};

        const filter_doctor_hospital_name = (doctor_hospital_name && doctor_hospital_name != 'undefined')  ? { doctor_hospital_name: doctor_hospital_name_regex } : {};

        concatFilter = {...filter_patient_name, ...filter_doctor_hospital_name}

        const [data, count] = await Promise.all([
            BookingAppointment.aggregate([
                { $match: matchCondition },
                { $sort: { createdAt: -1 } },
                { $skip: skip },
                { $limit: limit },
                {
                    $lookup: {
                        from: "users",
                        as: "patient",
                        let: { patient_id: "$patient_id" },
                        pipeline: [
                            {
                                $match: {
                                    $and: [
                                        {
                                            $expr: { $eq: ["$$patient_id", "$_id"] },
                                        },
                                        // filteredQueryUsersTable
                                    ]
                                },
                            },
                            {
                                $project: {
                                    _id: 1,
                                    first_name: 1,
                                    last_name: 1,
                                    email: 1,
                                    phone_number:1,
                                    social_security_number:1,
                                    dob:1,
                                    profile_pic:1,
                                    qualification: 1,
                                    clinic_contact:1,
                                    additional_qualification: 1,
                                    year_of_practice: 1, country: 1,
                                    state: 1,
                                    gender:1,
                                    street_address: 1,
                                    zip_code: 1,
                                    concat_name: {
                                        $concat: [
                                            {
                                              $cond: {
                                                if: {
                                                  $eq: ['$first_name', null]
                                                },
                                                then: '',  // Replace with your default value or an empty string
                                                else: '$first_name'
                                              }
                                            },
                                            ' ',
                                            {
                                              $cond: {
                                                if: {
                                                  $eq: ['$last_name', null]
                                                },
                                                then: '',  // Replace with your default value or an empty string
                                                else: '$last_name'
                                              }
                                            }
                                          ]
                                    }
                                }
                            },

                        ],
                    },
                },
                { "$unwind": "$patient" },
                {
                    $lookup: {
                        from: "categories",
                        as: "booking_speciality",
                        let: { booking_speciality: "$booking_speciality" },
                        pipeline: [
                            {
                                $match: {
                                    $expr: { $eq: ["$$booking_speciality", "$_id"] },
                                }
                            },
                            {
                                $project: {
                                    _id: 1,
                                    title_en: 1,
                                    title_ar: 1,
                                    title_fr: 1,
                                    image: 1
                                }
                            }
                        ],
                    },

                },
                {
                    $unwind: {
                        path: '$booking_speciality',
                        preserveNullAndEmptyArrays: true,
                    },
                },
                {
                    $lookup: {
                        from: "users",
                        as: "doctor_hospital",
                        let: { hospital_doctor_id: "$hospital_doctor_id" },
                        pipeline: [
                            {
                                $match: {

                                    $expr: { $eq: ["$$hospital_doctor_id", "$_id"] },
                                }
                            },
                            {
                                $lookup: {
                                    from: "roles",
                                    as: "userRole",
                                    let: { userRole_id: "$user_role" },
                                    pipeline: [
                                        {
                                            $match: {
                                                $and: [
                                                    {
                                                        $expr: { $eq: ["$$userRole_id", "$_id"] },
                                                    },
                                                    // filteredQueryUsersTable
                                                ]
                                            },
                                        },
                                        { $project: { _id: 1, title: 1 } },

                                    ],
                                },
                            },
                            { "$unwind": "$userRole" },
                            {
                                $lookup: {
                                    from: "categories",
                                    as: "selected_speciality",
                                    let: { primary_specialty: "$primary_specialty" },
                                    pipeline: [
                                        {
                                            $match: {
                                                //$expr: { $in: ["$_id", "$$primary_specialty"] }
                                                "$expr": {
                                                    "$cond": {
                                                        "if": { "$isArray": "$$primary_specialty" },
                                                        "then": { "$in": ["$_id", "$$primary_specialty"] },
                                                        "else": { "$eq": ["$primary_specialty", "$_id"] }
                                                    }
                                                }
                                            }
                                        },
                                        {
                                            $project: {
                                                _id: 1,
                                                title_ar: 1,
                                                title_en: 1,
                                                title_fr: 1,
                                                image: 1
                                            }
                                        }
                                    ],
                                },

                            },
                            {
                                $lookup: {
                                    from: "languages",
                                    as: "selected_language",
                                    let: { spoken_language: "$spoken_language" },
                                    pipeline: [
                                        {
                                            $match: {
                                                "$expr": {
                                                    "$cond": {
                                                        "if": { "$isArray": "$$spoken_language" },
                                                        "then": { "$in": ["$_id", "$$spoken_language"] },
                                                        "else": { "$eq": ["$spoken_language", "$_id"] }
                                                    }
                                                }
                                            }
                                        },
                                        {
                                            $project: {
                                                _id: 1,
                                                title: 1
                                            }
                                        }
                                    ],
                                },

                            },

                            {
                                $project: {
                                    _id: 1,
                                    first_name: 1,
                                    last_name: 1,
                                    email: 1,
                                    phone_number:1,
                                    social_security_number:1,
                                    dob:1,
                                    qualification: 1,
                                    additional_qualification: 1,
                                    year_of_practice: 1, country: 1,
                                    city:1,
                                    clinic_contact:1,
                                    state: 1,
                                    gender:1,
                                    profile_pic:1,
                                    street_address: 1,
                                    spoken_language:1,
                                    zip_code: 1, branch_of_medicines: 1,
                                    additional_specialty:1,
                                    selected_speciality: "$selected_speciality",
                                    selected_language: "$selected_language",
                                    user_role: "$userRole.title",
                                    clinic_name: 1,
                                    clinic_open_time: 1,
                                    clinic_close_time: 1,
                                    clinic_timing:1,
                                    is_fulltime:1,
                                    doctor_hospital_name: {
                                        
                                        $cond : {
                                            if : {
                                                $eq:['$userRole.title','doctor']
                                            },
                                            then : {
                                                $concat: [
                                                    {
                                                      $cond: {
                                                        if: {
                                                          $eq: ['$first_name', null]
                                                        },
                                                        then: '',  // Replace with your default value or an empty string
                                                        else: '$first_name'
                                                      }
                                                    },
                                                    ' ',
                                                    {
                                                      $cond: {
                                                        if: {
                                                          $eq: ['$last_name', null]
                                                        },
                                                        then: '',  // Replace with your default value or an empty string
                                                        else: '$last_name'
                                                      }
                                                    }
                                                  ]
                                            },
                                            else: '$clinic_name'
                                        }

                                        
                                    },
                                    platform_booking_status : 1
                                }
                            }
                        ]
                    }
                },

                {
                    $unwind: {
                        path: '$doctor_hospital',
                        preserveNullAndEmptyArrays: true,
                    },
                },
                {
                    $lookup : 
                    {
                        from : "users",
                        localField : "guardian_id",
                        foreignField : "_id",
                        as : "guardian_details"
                    }
                },
                {
                    $unwind : { path : "$guardian_details" , preserveNullAndEmptyArrays : true}
                },

                { $project: { _id: 1, booking_id: 1, slot: 1, booking_date: 1, status: 1, createdAt: 1, rejected_reason: 1, doctor_hospital: "$doctor_hospital", document_file_from_doctor: 1, rejected_by: 1, booking_speciality: "$booking_speciality", reschedule_date: 1, reschedule_slot: 1, reschedule_by: 1,patient:"$patient", patient_name : "$patient.concat_name", doctor_hospital_name : "$doctor_hospital.doctor_hospital_name", document_file:1 , guardian_details : {last_name :1 , first_name : 1 , profile_pic : 1 , email : 1 , dob : 1 , social_security_number : 1 , phone_number : 1 , gender : 1 }} },
                {
                    $match : concatFilter
                },


                
            ]),
            ( await BookingAppointment.aggregate([
                { $match: matchCondition },
                { $sort: { createdAt: -1 } },
                {
                    $lookup: {
                        from: "users",
                        as: "patient",
                        let: { patient_id: "$patient_id" },
                        pipeline: [
                            {
                                $match: {
                                    $and: [
                                        {
                                            $expr: { $eq: ["$$patient_id", "$_id"] },
                                        },
                                        // filteredQueryUsersTable
                                    ]
                                },
                            },

                        ],
                    },
                },
                { "$unwind": "$patient" },
                {
                    $lookup: {
                        from: "categories",
                        as: "booking_speciality",
                        let: { booking_speciality: "$booking_speciality" },
                        pipeline: [
                            {
                                $match: {
                                    $expr: { $eq: ["$$booking_speciality", "$_id"] },
                                }
                            },
                            {
                                $project: {
                                    _id: 1,
                                    title_en: 1,
                                    title_ar: 1,
                                    title_fr: 1,
                                    image: 1
                                }
                            }
                        ],
                    },

                },
                {
                    $unwind: {
                        path: '$booking_speciality',
                        preserveNullAndEmptyArrays: true,
                    },
                },
                {
                    $lookup: {
                        from: "users",
                        as: "doctor_hospital",
                        let: { hospital_doctor_id: "$hospital_doctor_id" },
                        pipeline: [
                            {
                                $match: {

                                    $expr: { $eq: ["$$hospital_doctor_id", "$_id"] },
                                }
                            },
                            {
                                $lookup: {
                                    from: "roles",
                                    as: "userRole",
                                    let: { userRole_id: "$user_role" },
                                    pipeline: [
                                        {
                                            $match: {
                                                $and: [
                                                    {
                                                        $expr: { $eq: ["$$userRole_id", "$_id"] },
                                                    },
                                                    // filteredQueryUsersTable
                                                ]
                                            },
                                        },
                                        { $project: { _id: 1, title: 1 } },

                                    ],
                                },
                            },
                            { "$unwind": "$userRole" },
                            {
                                $lookup: {
                                    from: "categories",
                                    as: "selected_speciality",
                                    let: { primary_specialty: "$primary_specialty" },
                                    pipeline: [
                                        {
                                            $match: {
                                                //$expr: { $in: ["$_id", "$$primary_specialty"] }
                                                "$expr": {
                                                    "$cond": {
                                                        "if": { "$isArray": "$$primary_specialty" },
                                                        "then": { "$in": ["$_id", "$$primary_specialty"] },
                                                        "else": { "$eq": ["$primary_specialty", "$_id"] }
                                                    }
                                                }
                                            }
                                        },
                                        {
                                            $project: {
                                                _id: 1,
                                                title_ar: 1,
                                                title_en: 1,
                                                title_fr: 1,
                                                image: 1
                                            }
                                        }
                                    ],
                                },

                            },
                            {
                                $lookup: {
                                    from: "languages",
                                    as: "selected_language",
                                    let: { spoken_language: "$spoken_language" },
                                    pipeline: [
                                        {
                                            $match: {
                                                "$expr": {
                                                    "$cond": {
                                                        "if": { "$isArray": "$$spoken_language" },
                                                        "then": { "$in": ["$_id", "$$spoken_language"] },
                                                        "else": { "$eq": ["$spoken_language", "$_id"] }
                                                    }
                                                }
                                            }
                                        },
                                        {
                                            $project: {
                                                _id: 1,
                                                title: 1
                                            }
                                        }
                                    ],
                                },

                            },
                        ]
                    }
                },

                {
                    $unwind: {
                        path: '$doctor_hospital',
                        preserveNullAndEmptyArrays: true,
                    },
                },
                {
                    $match : concatFilter
                },
                { $count: "totalCount" }


                
            ]))[0]?.totalCount || 0
        ]);


        //change filteredquery status acccording to count
        let approved_count = await BookingAppointment.countDocuments({ status: 'APPROVED' })


        //change filteredquery status acccording to count

        let pending_count = await BookingAppointment.countDocuments({ status: 'PENDING' })


        //change filteredquery status acccording to count

        let rejected_count = await BookingAppointment.countDocuments({ status: 'REJECTED' })



        //change filteredquery status acccording to count

        let completed_count = await BookingAppointment.countDocuments({ status: 'COMPLETED' })



        //upcoming count case

        let upcomingFiltered = filteredQuery;
        let upcomingFilteredWithRescheduled = filteredQueryWithRescheduled;

        
        upcomingFiltered['booking_date'] = { $gte: startDate, $lte: endDate }
        upcomingFiltered['status'] = "APPROVED";

        upcomingFilteredWithRescheduled['reschedule_date'] = { $gte: startDate, $lte: endDate }
        upcomingFilteredWithRescheduled['status'] = "APPROVED";

        let upcomingCountCondition = {
            $or: [
                upcomingFiltered,
                upcomingFilteredWithRescheduled
            ]
        }

        let upcoming_count = await BookingAppointment.countDocuments(upcomingCountCondition)



        //case of today count

        let today = new Date(); // This gets the current date and time
        today.setUTCHours(0, 0, 0, 0); // Set time to the beginning of the day in UTC
        let tomorrow = new Date(today); // Clone the today date object
        tomorrow.setUTCDate(today.getUTCDate() + 1); 
        
        filteredQuery['booking_date'] = { $gte: today, $lt: tomorrow }
        filteredQuery['status'] = "APPROVED";

        filteredQueryWithRescheduled['reschedule_date'] = { $gte: today, $lt: tomorrow }
        filteredQueryWithRescheduled['status'] = "APPROVED";

        let todayCountCondition = {
            $or: [
                filteredQuery,
                filteredQueryWithRescheduled
            ]
        }

        let today_count = await BookingAppointment.countDocuments(todayCountCondition)


        return res.json({
            count: count,
            pending_count: pending_count,
            approved_count:approved_count,
            rejected_count:rejected_count,
            completed_count:completed_count,
            today_count:today_count,
            upcoming_count:upcoming_count,
            data: data,
            errors: [],
            is_error: false,
            message: "",
            responseCode: 200
        })

        //return res.json({count : count, pending_count: pending_count, data : data, errors:[], is_error:false, message: "", responseCode:200})
     //   return apiResponse(res, false, [], '', SUCCESS.OK, count, pending_count, data, req)



    } catch (error) {
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}

exports.getAllDoctorHospital = async (req,res) => {
    var title_lang = 'en';
    const lang = req.headers["accept-language"] || 'en';

    try {

        let patientRole = await Role.findOne({title:"patient"});
        
        const findDoctorHospitalCondition = {
            user_role : {
                $ne : new mongoose.Types.ObjectId(patientRole._id.toString())
            },
            user_account_status: "APPROVED",
            is_completed: true,
            is_deleted: false
        }

        let doctorHospital = await User.aggregate([
            { $match: findDoctorHospitalCondition },

            {
                $lookup: {
                    from: "roles",
                    as: "role_of_user",
                    let: { user_role: "$user_role" },
                    pipeline: [
                        {
                            $match: {

                                $expr: { $eq: ["$$user_role", "$_id"] },
                            }
                        },
                    ],
                },
            },
            {
                $unwind: {
                    path: '$role_of_user',
                    preserveNullAndEmptyArrays: true,
                },
            },
            {
                $project : {
                    _id : 1,
                    first_name: 1,
                    last_name : 1,
                    role_name : "$role_of_user.title",
                    hospital_name : 1
                }
            }

        ]);


        return res.json({count : 0, data : doctorHospital, errors:[], is_error:false, message: "", responseCode:200})

    }catch (error) {
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}

exports.getAllPatient = async(req,res) => {
    var title_lang = 'en';
    const lang = req.headers["accept-language"] || 'en';

    try {

        let patientRole = await Role.findOne({title:"patient"});
        
        const findPatientCondition = {
            user_role : {
                $eq : new mongoose.Types.ObjectId(patientRole._id.toString())
            },
            user_account_status: "APPROVED",
            is_completed: true,
            is_deleted: false
        }

        let patientRecords = await User.aggregate([
            { $match: findPatientCondition },

            {
                $lookup: {
                    from: "roles",
                    as: "role_of_user",
                    let: { user_role: "$user_role" },
                    pipeline: [
                        {
                            $match: {

                                $expr: { $eq: ["$$user_role", "$_id"] },
                            }
                        },
                    ],
                },
            },
            {
                $unwind: {
                    path: '$role_of_user',
                    preserveNullAndEmptyArrays: true,
                },
            },
            {
                $project : {
                    _id : 1,
                    first_name: 1,
                    last_name : 1,
                    role_name : "$role_of_user.title"
                }
            }

        ]);


        return res.json({count : 0, data : patientRecords, errors:[], is_error:false, message: "", responseCode:200})

    }catch (error) {
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}

exports.checkDoctorOrHospitalOrPatient = async(req,res) => {
    var title_lang = 'en';
    const lang = req.headers["accept-language"] || 'en';

    try {

        const {id} = req.body;


        let record = await User.aggregate([
            { $match: {
                _id : new mongoose.Types.ObjectId(id)
            } },

            {
                $lookup: {
                    from: "roles",
                    as: "role_of_user",
                    let: { user_role: "$user_role" },
                    pipeline: [
                        {
                            $match: {

                                $expr: { $eq: ["$$user_role", "$_id"] },
                            }
                        },
                    ],
                },
            },
            {
                $unwind: {
                    path: '$role_of_user',
                    preserveNullAndEmptyArrays: true,
                },
            },
            {
                $project : {
                    _id : 1,
                    first_name: 1,
                    last_name : 1,
                    role_name : "$role_of_user.title"
                }
            }

        ]);


        return res.json({count : 0, data : record[0], errors:[], is_error:false, message: "", responseCode:200})

    }catch (error) {
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}

// Create Daily.co room and attach to a booking
exports.createDailyRoomForBooking = async (req, res) => {
    const lang = req.headers["accept-language"] || 'en';
    try {
        const { id } = req.params; // booking id
        if(!id){
            return res.status(400).json({ is_error:true, message:'Missing booking id', errors:[], data:null });
        }
        let booking = await BookingAppointment.findById(id);
        if(!booking){
            return res.status(404).json({ is_error:true, message:'Booking not found', errors:[], data:null });
        }

        // If already has a room, reuse it
        if(booking.daily_room_url){
            return res.json({ is_error:false, message:'Room already exists', data:{
                url: booking.daily_room_url,
                name: booking.daily_room_name,
                token: booking.daily_room_token || null
            }});
        }

        if(!DAILY_API_KEY){
            return res.status(500).json({ is_error:true, message:'Daily API key not configured', data:null });
        }

        const payload = {
            properties: {
                enable_screenshare: true,
                enable_chat: true,
                start_video_off: true,
                start_audio_off: true
            }
        };

        const roomResp = await axios.post('https://api.daily.co/v1/rooms', payload, {
            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${DAILY_API_KEY}` }
        });

        const room = roomResp.data;
        booking.daily_room_name = room?.name;
        booking.daily_room_url = room?.url;
        booking.daily_room_created_at = new Date();
        // token creation optional; skipping for now unless needed via separate endpoint
        await booking.save();

        return res.json({ is_error:false, message:'Room created', data:{ url: room.url, name: room.name, token: null } });
    } catch (error){
        console.error('Daily room create error', error?.response?.data || error.message);
        return res.status(500).json({ is_error:true, message:'Failed to create room', errors:[error?.response?.data || error.message], data:null });
    }
}