const fastify = require("fastify")({
    logger: true,
  });
const boom = require("boom");
const customJwtAuth = require("../customAuthJwt");

const bcrypt = require("bcrypt");
const saltRounds = 10;



//Get the data models
const { RecurringRequestedBooking,RequestedBooking,Supplier , generateSupplierId, DeliveryBoy} = require('../models/supplier');

const { Tankerbooking} = require("../models/tankers")

// Get Data Models
const { User,Counter, generateBookingId,resetCounter,generateCustomerId,ProfilePicture, AddTeamMembers,Cart} = require('../models/User')
async function bcryptPassword(password) {
    encryptedPwd = bcrypt.hash(password, saltRounds);
    return encryptedPwd;
}

async function bcryptComparePassword(pwd, encpassword) {
    isSame = bcrypt.compare(pwd, encpassword);
    return isSame;
}
  


//Supplier Login Controller

exports.loginSupplier = async (req) => {
    try {
      const phone = req.body.phone;
      const password = req.body.password;
      
      const supplier = await Supplier.findOne({ phone: phone });
      // compare supplier password with what is supplied
      if (supplier) {
        isSame = await bcryptComparePassword(
          password,
          supplier.services.password.bcrypt
        );
        // if password supplied matches return object
        if (isSame) {
          return { same: true, supplier: supplier };
        } else {
          return { same: false };
        }
      } else {
        return { same: false };
      }
    } catch (err) {
      throw boom.boomify(err);
    }
  };
  



//DeliveryBoy Login Controller


exports.loginDeliveryBoy = async (req) => {
  try {
    const phone = req.body.phone;


    const delivery = await DeliveryBoy.findOne({ phone: phone });


      if (delivery) {
        return { same: true, delivery: delivery };
      } else {
        return { same: false };
      }
   
  } catch (err) {
    throw boom.boomify(err);
  }
};

  exports.addSupplier = async (req, reply) => {
    try {
    //  await resetCounter();//to set customer id back to 0
    var s_id = await generateSupplierId()
    var building= ((req.body.suppliername).slice(0, 3)).toUpperCase();
    var supplier_id = `AWSS${building}${s_id}`
      // console.log("This is the reply in the handler after the validations", reply);
      s_data = {   
        supplierId: supplier_id,
        suppliername: req.body.suppliername,
        emails: req.body.emails,
        password: req.body.password,
        phone: req.body.phone,
        description: req.body.description,
        bussinessname: req.body.description,
        registration_number: req.body.description,
        years_in_business: req.body.description,
        profile: {
          firstName: req.body.firstName,
          lastName: req.body.lastName,
          contactNumber: req.body.phone,
          alternativeContactNumber: req.body.alternativeContactNumber,
          office_address: req.body.office_address,
          country: req.body.country,
          state: req.body.state,
          city: req.body.city,
          office_adress: req.body.office_adress,
          zip: req.body.zip,
        },
        latitude: req.body.latitude,
        longitude: req.body.longitude,
        fcmId : req.body.fcmId
      };
      
      var supplier = new Supplier(s_data);
  
      //password is not at the top level in the collection.
      supplierpass = req.body.password;
  
      // If fields are sent via form encoding , capture the fields and assign them to the supplier Object.
  
      checkFormEncoding = isSupplierFormUrlEncoded(req);
      if (checkFormEncoding.isSupplierFormUrlEncoded) {
        suppliertobeInserted = checkFormEncoding.supplier;
        console.log("thsi true url string");  
        supplier.suppliername = suppliertobeInserted.suppliername;
        supplier.firstName = suppliertobeInserted.firstName;
        supplier.lastName = suppliertobeInserted.lastName;
        supplier.phone = suppliertobeInserted.phone;
        supplier.emails = suppliertobeInserted.emails;
        supplier.passsword = suppliertobeInserted.password;
        supplier.supplierId = suppliertobeInserted.supplier_id;
        supplier.office_adress = suppliertobeInserted.office_adress;
        supplier.alternativeContactNumber = suppliertobeInserted.alternativeContactNumber;
        supplier.latitude = suppliertobeInserted.latitude;
        supplier.longitude = suppliertobeInserted.longitude;
        supplier.fcmId = suppliertobeInserted.fcmId
        supplier.description = suppliertobeInserted.description
      }
  
      
      console.log("---------checkurl ecnoded string-----------------------");
  
      // Store hash in your password DB.
      hash = await bcryptPassword(supplierpass);
  
      if (hash) {
        supplier.services.password.bcrypt = hash;
        if (req.body.role) {
          supplier.profile.role = req.body.role;
          console.log("******************************************************");
          console.log(supplier);
        } else {
          role = ["supplier"];
          supplier.profile.role = role;
        }

        insertedSupplier = await supplier.save();
        console.log(insertedSupplier);
        if (insertedSupplier) {
          // Prepare supplier object and wrap it inside the armintatankdata
          var retSupplier = {
            armintatankdata: {
              suppliername: insertedSupplier.suppliername,
              phone: insertedSupplier.phone,
              supplierId: insertedSupplier.supplierId,
              office_adress: insertedSupplier.office_adress,
              emails: [
                {
                  email: insertedSupplier.emails[0].email,
                },
              ],
              profile: insertedSupplier.profile,
              latitude: insertedSupplier.latitude,
              longitude: insertedSupplier.longitude,
              fcmId : insertedSupplier.fcmId,
              description : insertedSupplier.description
            },
            status_code: 200,
          };
  
          return retSupplier;
        }
      }
    } catch (err) {
      throw boom.boomify(err);
    }
  };

  exports.editCuurentSupplierInfo = async (req, reply) => {
    try {
      const { supplierId } = req.params;
      const supplierInfo = await Supplier.findOne({ supplierId: supplierId.toString() });
      const updateData = req.body;
  
      if (updateData.firstName) supplierInfo.profile.firstName = updateData.firstName;
      if (updateData.lastName) supplierInfo.profile.lastName = updateData.lastName;
      if (updateData.suppliername) supplierInfo.suppliername = updateData.suppliername;
      if (updateData.phone) supplierInfo.profile.contactNumber = updateData.phone;
      if (updateData.office_address) supplierInfo.profile.office_address = updateData.office_address;
      if (updateData.alternativeContactNumber) supplierInfo.profile.alternativeContactNumber = updateData.alternativeContactNumber;
      if (updateData.city) supplierInfo.profile.city = updateData.city;
      if (updateData.state) supplierInfo.profile.state = updateData.state;
      if (updateData.country) supplierInfo.profile.country = updateData.country;
      if (updateData.zip) supplierInfo.profile.zip = updateData.zip;
       if (updateData.phone) supplierInfo.phone = updateData.phone;
       if (updateData.description) supplierInfo.description = updateData.description;
       if (updateData.startingPrice) supplierInfo.startingPrice = updateData.startingPrice;
       if (updateData.status) supplierInfo.status = updateData.status;
      if (updateData.emails) supplierInfo.emails = updateData.emails;
      console.log(supplierInfo.emails[0].email)
      if (updateData.role) supplierInfo.profile.role = updateData.role;
      
      if (updateData.phone) {
        const phoneNumber =  updateData.phone //libphonenumberjs.parsePhoneNumber(updateData.phone);
        if (phoneNumber) {
          // access returned collection
          if (!phoneNumber) {                     //if (!phoneNumber.isValid()) {
            error = {
              armintatankdata: {
                error: true,
                code: 10002,
                message:
                  "10002 - Phone # " +
                  updateData.phone +
                  " is not a valid phone number",
              },
            };
            req.body.regError = error;
            reply.status(406).send(error);
          }
        }
      }
  
      if (supplierInfo.phone == updateData.phone) {
        console.log("IF++++++++++++++=");
        supplierInfo.phone = updateData.phone;
        supplierInfo.phoneVerified = true;
      } else {
        console.log("Ilse++++++++++++++=");
        supplierInfo.phone = updateData.phone;
        supplierInfo.phoneVerified = false;
      }
      const supplier = await supplierInfo.save();
      return supplier;
    } catch (err) {
      throw boom.boomify(err);
    }
  };


  

const mongoose = require('mongoose');

exports.respondToRequestedBooking = async (req, reply) => {
  const { _id } = req.params;
  const { action, supplierId } = req.body;

  if (!mongoose.Types.ObjectId.isValid(_id)) {
    return reply.code(400).send({ message: "Invalid requested booking ID" });
  }

  if (!["accept", "reject"].includes(action)) {
    return reply.code(400).send({ message: "Action must be 'accept' or 'reject'" });
  }

  try {
    const booking = await RequestedBooking.findById(_id);

    if (!booking) {
      return reply.code(404).send({ message: "Requested booking not found" });
    }

    const supplierEntry = booking.requested_suppliers.find(s => s.supplierId === supplierId);

    if (!supplierEntry) {
      return reply.code(404).send({ message: "Supplier not found in this booking" });
    }

    // Update custom_field (status) for that supplier
    supplierEntry.status = action === "accept" ? "accepted_by_supplier" : "rejected_by_supplier";

    await booking.save();

    return reply.code(200).send({
      status_code: 200,
      message: `Booking ${action}ed by supplier successfully`,
      data: booking
    });

  } catch (err) {
    console.error(err);
    throw boom.internal("Failed to update supplier response", err);
  }
};


// controllers/supplier.controller.js
// const boom = require("@hapi/boom");
// const mongoose = require("mongoose");

// // MODELS (adjust paths/names to your project)
// const RecurringRequestedBooking = require("../models/recurringRequestedBooking.model");
// const TankerBooking = require("../models/tankerBooking.model");

// // Common party models you likely have in your DB:
// const Customer = require("../models/customer.model"); // e.g., { customerId, name, phone, address, latitude, longitude }
// const Supplier = require("../models/supplier.model"); // e.g., { supplierId, name, phone, tankerName, address, latitude, longitude }

// const parseNumber = (v, def = 0) => {
//   if (v === null || v === undefined) return def;
//   const n = parseFloat(String(v).replace(/,/g, ""));
//   return Number.isFinite(n) ? n : def;
// };
// const mkBookingId = (prefix = "RBK") => {
//   const ts = new Date().toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
//   const rnd = Math.floor(Math.random() * 1e6).toString().padStart(6, "0");
//   return `${prefix}-${ts}-${rnd}`;
// };
// const isIsoYMD = (s) => /^\d{4}-\d{2}-\d{2}$/.test(s);

// // "2025-10-21" -> "21-Oct-2025" (to match your old saved sample)
// const formatDDMonYYYY = (isoYmd) => {
//   if (!isIsoYMD(isoYmd)) return isoYmd;
//   const [y, m, d] = isoYmd.split("-").map(Number);
//   const mon = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"][(m || 1) - 1];
//   return `${String(d).padStart(2,"0")}-${mon}-${y}`;
// };

// exports.respondToRecurringRequestedBooking = async (req, reply) => {
//   const { _id } = req.params;
//   const { action, supplierId } = req.body;

//   if (!mongoose.Types.ObjectId.isValid(_id)) {
//     return reply.code(400).send({ message: "Invalid recurring requested booking ID" });
//   }
//   if (!["accept", "reject"].includes(action)) {
//     return reply.code(400).send({ message: "Action must be 'accept' or 'reject'" });
//   }

//   try {
//     const booking = await RecurringRequestedBooking.findById(_id);
//     if (!booking) {
//       return reply.code(404).send({ message: "Recurring requested booking not found" });
//     }

//     const supplierEntry = booking.requested_suppliers.find((s) => s.supplierId === supplierId);
//     if (!supplierEntry) {
//       return reply.code(404).send({ message: "Supplier not found in this booking" });
//     }

//     // Update supplier response on the recurring request
//     supplierEntry.status = action === "accept" ? "accepted" : "rejected";
//     await booking.save();

//     if (action === "reject") {
//       return reply.code(200).send({
//         status_code: 200,
//         message: "Recurring booking rejected by supplier successfully",
//         data: booking,
//       });
//     }

//     // ACCEPT: build per-date TankerBooking docs with rich fields
//     const allDates = Array.isArray(booking.dates) ? booking.dates.filter(isIsoYMD) : [];
//     if (!allDates.length) {
//       return reply.code(400).send({ message: "No valid ISO dates found in booking.dates" });
//     }

//     // Preload related party info to fill address/phones/names
//     const [customerDoc, supplierDoc] = await Promise.all([
//       User.findOne({ customerId: booking.customerId }).lean(),
//       Supplier.findOne({ supplierId: supplierId }).lean(),
//     ]);

//     // Pull commonly needed values (tolerant defaults to match legacy)
//     const customerPhone = customerDoc?.phone ?? null;
//     const supplierPhone = supplierDoc?.phone ?? null;

//     const customerName  = customerDoc?.username ?? customerDoc?.displayName ?? "";
//     const supplierName  = supplierDoc?.suppliername ?? supplierDoc?.companyName ?? "";

//     const tankerName    = supplierDoc?.tankerName ?? null;
//     const tankName      = null; // if you associate a tank per-customer, populate from your Tank model here
//     const tankLocation  = null; // same as above

//     // prefer customer address (your legacy sample stores a geocoded customer address)
//     const address       = customerDoc?.profile.address1 ?? null;
//     const latitude      = customerDoc?.latitude ?? null;
//     const longitude     = customerDoc?.longitude ?? null;

//     // price: from supplier’s quoted_amount in this request (fallback null)
//     const price         = (supplierEntry?.quoted_amount ?? null) !== null
//       ? String(supplierEntry.quoted_amount)
//       : null;

//     // numeric fields
//     const numericCapacity = parseNumber(booking.capacity);
//     const numericQuantity = parseNumber(booking.quantity);
//     const totalRequired   = Number.isFinite(booking.total_required_capacity)
//       ? booking.total_required_capacity
//       : numericCapacity * numericQuantity;

//     // dedupe check
//     const existing = await Tankerbooking.find(
//       {
//         customerId: booking.customerId,
//         supplierId: supplierId,
//         date: { $in: allDates },
//         time: booking.time, // keep your stored time format intact
//       },
//       { date: 1 }
//     ).lean();

//     const existingSet = new Set((existing || []).map(e => e.date));
//     const newDates = allDates.filter(d => !existingSet.has(d));
//     if (!newDates.length) {
//       return reply.code(200).send({
//         status_code: 200,
//         message: "All dates already have bookings; nothing to create.",
//         data: { created: 0, skippedExistingDates: allDates },
//       });
//     }

//     // ---------- BUILD ENRICHED DOCS (matches your legacy example fields) ----------
//     const todayIso = new Date().toISOString().slice(0, 10);

//     const docs = newDates.map((d) => ({
//       // Required/IDs
//       customerId: booking.customerId,
//       supplierId: supplierId,
//       bookingid: mkBookingId("RBK"),

//       // Legacy display & logistics
//       tankName,                        // null (fill if you link tank per-customer)
//       tankLocation,                    // null (fill if available)
//       tankerName,                      // from Supplier if present

//       // Dates/times (kept both ISO & legacy formats as you showed)
//       dateOfOrder: todayIso,           // "2025-09-10"
//       expectedDateOfDelivery: formatDDMonYYYY(d), // "21-Oct-2025" style (legacy sample)
//       date: d,                         // keep ISO in `date` too
//       time: booking.time,              // keep your request time as-is

//       // Water & capacity
//       type_of_water: booking.type_of_water,
//       typeofwater: booking.type_of_water,  // legacy field name kept too
//       capacity: booking.capacity,          // e.g., "100" or "10,000 L"
//       quantity: booking.quantity,          // string
//       total_required_capacity: totalRequired,

//       // Money / status
//       price: price,                    // from quoted_amount (string) or null
//       payment_status: "due",
//       orderStatus: "accepted",

//       // Contacts & names
//       address: address,                // from customer
//       customerPhone: customerPhone,
//       supplierPhone: supplierPhone,
//       customerName: customerName,
//       supplierName: supplierName,

//       // Delivery defaults (match your legacy doc)
//       delivery_agent: "null",
//       delivery_agent_mobile: "null",
//       delivery_agent_alternative_mobile: "null",

//       // Metering defaults
//       initial_water_level: "null",
//       final_water_level: "null",
//       start_time: "null",
//       stop_time: "null",
//       quantityDelivered: null,

//       // Accounting defaults
//       amount_paid: null,
//       amount_due: null,
//       distrubance_price: "none",
//       amount_difference: "none",
//       payment_mode: null,
//       remarks: null,

//       // Device/geo defaults
//       tankerRunningStatus: "0",
//       latitude: latitude ?? undefined,   // keep same field names as your legacy doc
//       longitude: longitude ?? undefined, // if not available, omit field

//       // Misc you already store
//       frequency: booking.frequency,
//       weekly_count: booking.weekly_count ?? 1,
//       deliveredDate: null,
//       distrubance_status: "0",
//     }));
//     // ---------------------------------------------------------------------------

//     // Insert without transactions, tolerate duplicates if unique index exists
//     let insertedCount = 0;
//     let duplicateErrors = 0;
//     try {
//       const res = await Tankerbooking.collection.insertMany(docs, { ordered: false });
//       insertedCount = res.insertedCount || 0;
//     } catch (e) {
//       if (e && e.writeErrors && Array.isArray(e.writeErrors)) {
//         insertedCount = e.result?.nInserted ?? 0;
//         duplicateErrors = e.writeErrors.length;
//       } else {
//         throw e;
//       }
//     }

//     return reply.code(200).send({
//       status_code: 200,
//       message: `Recurring booking accepted. Created ${insertedCount} tanker booking(s).`,
//       data: {
//         createdDates: newDates.slice(0, insertedCount),
//         skippedExistingDates: allDates.filter(d => existingSet.has(d)),
//         duplicateConflicts: duplicateErrors,
//       },
//     });
//   } catch (err) {
//     console.error(err);
//     throw boom.internal("Failed to update recurring supplier response", err);
//   }
// };


  

// controllers/supplier.controller.js (only the changed parts shown for brevity)
// const boom = require("@hapi/boom");
// const mongoose = require("mongoose");

// const RecurringRequestedBooking = require("../models/recurringRequestedBooking.model");
// const TankerBooking = require("../models/tankerBooking.model");
// const Customer = require("../models/customer.model");
// const Supplier = require("../models/supplier.model");

// ---------- helpers (IST + formatting) ----------
const parseNumber = (v, def = 0) => {
  if (v === null || v === undefined) return def;
  const n = parseFloat(String(v).replace(/,/g, ""));
  return Number.isFinite(n) ? n : def;
};
const mkBookingId = (prefix = "RBK") => {
  const ts = new Date().toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
  const rnd = Math.floor(Math.random() * 1e6).toString().padStart(6, "0");
  return `${prefix}-${ts}-${rnd}`;
};
const isIsoYMD = (s) => /^\d{4}-\d{2}-\d{2}$/.test(s);
const MON = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];

// Return a Date adjusted to IST (UTC+5:30) without changing the original instant
const toIST = (d = new Date()) => {
  const utc = d.getTime() + (d.getTimezoneOffset() * 60000);
  // IST = UTC + 5:30
  return new Date(utc + (5 * 60 + 30) * 60000);
};

// Format Date -> "DD-Mon-YYYY - HH:MM" in IST
const fmtDDMonYYYY_HHMM = (dateObj) => {
  const dd = String(dateObj.getDate()).padStart(2, "0");
  const mon = MON[dateObj.getMonth()];
  const yyyy = dateObj.getFullYear();
  const hh = String(dateObj.getHours()).padStart(2, "0");
  const mm = String(dateObj.getMinutes()).padStart(2, "0");
  return `${dd}-${mon}-${yyyy} - ${hh}:${mm}`;
};

// Extract "HH:MM" (24h) from arbitrary string like "21-Nov-2025 - 14:37" or "4:00 PM to 6:00 PM"
// If not found, default "00:00"
const extractHHMM = (timeStr) => {
  if (!timeStr) return "00:00";
  // First try 24h "14:37"
  const m24 = timeStr.match(/\b(\d{1,2}):(\d{2})\b/);
  if (m24) {
    const h = String(Math.min(23, parseInt(m24[1],10))).padStart(2,"0");
    const m = m24[2];
    return `${h}:${m}`;
  }
  // crude parse for "4:00 PM" → 16:00
  const ampm = timeStr.match(/(\d{1,2}):(\d{2})\s*(AM|PM)/i);
  if (ampm) {
    let h = parseInt(ampm[1],10);
    const m = ampm[2];
    const p = ampm[3].toUpperCase();
    if (p === "PM" && h !== 12) h += 12;
    if (p === "AM" && h === 12) h = 0;
    return `${String(h).padStart(2,"0")}:${m}`;
  }
  return "00:00";
};

// Combine ISO date "YYYY-MM-DD" + a time string → IST "DD-Mon-YYYY - HH:MM"
const fmtFromISOAndTime = (isoYmd, timeStr) => {
  if (!isIsoYMD(isoYmd)) return isoYmd; // fallback
  const [y, m, d] = isoYmd.split("-").map(Number);
  const [hh, mm] = extractHHMM(timeStr).split(":").map(Number);
  // Construct a Date in UTC for that local time, then convert to IST display
  const dt = new Date(Date.UTC(y, (m - 1), d, hh, mm, 0));
  // We only care about display in IST:
  return fmtDDMonYYYY_HHMM(toIST(dt));
};
// ----
// --------------------------------------------

// ---------- add these helpers near your other helpers ----------
const to12h = (h24, m) => {
  let h = h24 % 12 || 12;
  const ampm = h24 >= 12 ? "PM" : "AM";
  return `${h}:${String(m).padStart(2,"0")} ${ampm}`;
};

// Extract first time from any string: supports "14:37", "4:00 PM", "21-Nov-2025 - 14:37", "4:00 PM to 6:00 PM"
const parseFirstTimeToHM = (timeStr) => {
  if (!timeStr) return { h: 0, m: 0 };
  // Try explicit 12h with AM/PM
  const ampm = timeStr.match(/(\d{1,2}):(\d{2})\s*(AM|PM)/i);
  if (ampm) {
    let h = parseInt(ampm[1], 10);
    const m = parseInt(ampm[2], 10);
    const p = ampm[3].toUpperCase();
    if (p === "PM" && h !== 12) h += 12;
    if (p === "AM" && h === 12) h = 0;
    return { h, m };
  }
  // Try any 24h HH:MM in the string
  const m24 = timeStr.match(/\b(\d{1,2}):(\d{2})\b/);
  if (m24) {
    const h = Math.max(0, Math.min(23, parseInt(m24[1], 10)));
    const m = Math.max(0, Math.min(59, parseInt(m24[2], 10)));
    return { h, m };
  }
  return { h: 0, m: 0 };
};

// If already "X to Y" (case-insensitive), keep it. Otherwise, make a slot of `windowHours` starting at first parsed time.
const normalizeTimeForLegacy = (timeStr, windowHours = 2) => {
  if (typeof timeStr === "string" && / to /i.test(timeStr)) {
    return timeStr; // already in "4:00 PM to 6:00 PM"
  }
  const { h, m } = parseFirstTimeToHM(timeStr);
  const start = to12h(h, m);
  const endDate = new Date(Date.UTC(2000, 0, 1, h, m)); // dummy date, add hours
  endDate.setUTCHours(endDate.getUTCHours() + windowHours);
  const end = to12h(endDate.getUTCHours(), endDate.getUTCMinutes());
  return `${start} to ${end}`;
};

// ---- Booking ID helpers (IST-based) ----
// Get YYYYMMDD in IST (UTC+05:30)
const getISTDatePart = (d = new Date()) => {
  const utcMs = d.getTime() + d.getTimezoneOffset() * 60000;
  const ist = new Date(utcMs + (5 * 60 + 30) * 60000);
  const y = ist.getFullYear();
  const m = String(ist.getMonth() + 1).padStart(2, "0");
  const day = String(ist.getDate()).padStart(2, "0");
  return `${y}${m}${day}`; // YYYYMMDD
};

// Make ARM id with one random digit (0-9)
const mkArmBookingIdIST = () => `ARM${getISTDatePart()}${Math.floor(Math.random() * 10)}`;

// Ensure uniqueness in DB (recommended since you may create many in one day)
const generateUniqueArmId = async () => {
  // up to 20 tries with single digit; then fall back to two digits
  for (let i = 0; i < 20; i++) {
    const id = mkArmBookingIdIST();
    const exists = await Tankerbooking.exists({ bookingid: id });
    if (!exists) return id;
  }
  // fallback with two random digits to avoid collisions
  const fallback = `ARM${getISTDatePart()}${Math.floor(Math.random()*10)}${Math.floor(Math.random()*10)}`;
  return fallback;
};

exports.respondToRecurringRequestedBooking = async (req, reply) => {
  const { _id } = req.params;
  const { action, supplierId } = req.body;
  if (!mongoose.Types.ObjectId.isValid(_id)) {
    return reply.code(400).send({ message: "Invalid recurring requested booking ID" });
  }
  if (!["accept", "reject"].includes(action)) {
    return reply.code(400).send({ message: "Action must be 'accept' or 'reject'" });
  }

  try {
    const booking = await RecurringRequestedBooking.findById(_id);
    if (!booking) return reply.code(404).send({ message: "Recurring requested booking not found" });

    const supplierEntry = booking.requested_suppliers.find(s => s.supplierId === supplierId);
    if (!supplierEntry) {
      return reply.code(404).send({ message: "Supplier not found in this booking" });
    }

    supplierEntry.status = action === "accept" ? "accepted" : "rejected";
    await booking.save();
    // 🔽 ADD THIS
    const allAccepted = booking.requested_suppliers.every(s => s.status === "accepted");
  if (allAccepted) {
    booking.status = "processed";
    await booking.save();
  }

    if (action === "reject") {
      return reply.code(200).send({
        status_code: 200,
        message: "Recurring booking rejected by supplier successfully",
        data: booking,
      });
    }

    const allDates = Array.isArray(booking.dates) ? booking.dates.filter(isIsoYMD) : [];
    if (!allDates.length) {
      return reply.code(400).send({ message: "No valid ISO dates found in booking.dates" });
    }

    const [customerDoc, supplierDoc] = await Promise.all([
      User.findOne({ customerId: booking.customerId }).lean(),
      Supplier.findOne({ supplierId }).lean(),
    ]);

    const customerPhone = customerDoc?.phone ?? null;
    const supplierPhone = supplierDoc?.phone ?? null;
    const customerName  = customerDoc?.username ?? customerDoc?.displayName ?? "";
    const supplierName  = supplierDoc?.suppliername ?? supplierDoc?.companyName ?? "";
    const tankerName    = supplierDoc?.tankerName ?? null;
    const address       = customerDoc?.profile.address1 ?? null;
    const latitude      = customerDoc?.latitude ?? undefined;
    const longitude     = customerDoc?.longitude ?? undefined;

    const price = (supplierEntry?.quoted_amount ?? null) !== null
      ? String(supplierEntry.quoted_amount)
      : null;

    const numericCapacity = parseNumber(booking.capacity);
    const numericQuantity = parseNumber(booking.quantity);
    const totalRequired = Number.isFinite(booking.total_required_capacity)
      ? booking.total_required_capacity
      : numericCapacity * numericQuantity;

    // dedupe by (customerId, supplierId, date, time)
    const existing = await Tankerbooking.find(
      { customerId: booking.customerId, supplierId, date: { $in: allDates }, time: booking.time },
      { date: 1 }
    ).lean();
    const existingSet = new Set((existing || []).map(e => e.date));
    const newDates = allDates.filter(d => !existingSet.has(d));
    if (!newDates.length) {
      return reply.code(200).send({
        status_code: 200,
        message: "All dates already have bookings; nothing to create.",
        data: { created: 0, skippedExistingDates: allDates },
      });
    }
    const legacyTime = normalizeTimeForLegacy(booking.time); 
    // --- FORMAT THESE THREE FIELDS EXACTLY AS LEGACY EXPECTS ---
    const nowIST = toIST(new Date());
    const dateOfOrderFmt = fmtDDMonYYYY_HHMM(nowIST); // "DD-Mon-YYYY - HH:MM"
    const today = new Date();
const datePart = today.toISOString().slice(0, 10).replace(/-/g, ''); // YYYYMMDD
const randomDigit = Math.floor(Math.random() * 10); // 0–9
const bookingId = `ARM${datePart}${randomDigit}`;
    // ADD: pre-generate unique booking IDs (one per date)
const bookingIds = await Promise.all(newDates.map(() => generateUniqueArmId()));

    // -----------------------------------------------------------

    const docs = newDates.map((d,i) => ({
      // IDs
      customerId: booking.customerId,
      supplierId,
      bookingid: bookingIds[i],        

      // Legacy fields (match your old document)
      tankName: null,
      tankLocation: null,
      tankerName,

      dateOfOrder: dateOfOrderFmt,                          // e.g., "03-Sep-2025 - 13:25"
      expectedDateOfDelivery: fmtFromISOAndTime(d, booking.time), // "DD-Mon-YYYY - HH:MM"
      date: d,                                              // keep ISO for backend logic
      time: legacyTime,                               // keep whatever UI sent

      type_of_water: booking.type_of_water,
      typeofwater: booking.type_of_water,
      capacity: booking.capacity,
      quantity: booking.quantity,
      total_required_capacity: totalRequired,

      price,
      payment_status: "due",
      orderStatus: "accepted",

      address,
      customerPhone,
      supplierPhone,
      customerName,
      supplierName,

      delivery_agent: "null",
      delivery_agent_mobile: "null",
      delivery_agent_alternative_mobile: "null",

      initial_water_level: "null",
      final_water_level: "null",
      start_time: "null",
      stop_time: "null",
      quantityDelivered: null,

      amount_paid: null,
      amount_due: null,
      distrubance_price: "none",
      amount_difference: "none",
      payment_mode: null,
      remarks: null,

      tankerRunningStatus: "0",
      latitude,
      longitude,

      frequency: booking.frequency,
      weekly_count: booking.weekly_count ?? 1,
      deliveredDate: null,                 // new bookings: not delivered yet
      distrubance_status: "0",
    }));

    // insert (no transactions, ordered:false)
    let insertedCount = 0;
    let duplicateErrors = 0;
    try {
      const res = await Tankerbooking.collection.insertMany(docs, { ordered: false });
      insertedCount = res.insertedCount || 0;
    } catch (e) {
      if (e && e.writeErrors && Array.isArray(e.writeErrors)) {
        insertedCount = e.result?.nInserted ?? 0;
        duplicateErrors = e.writeErrors.length;
      } else {
        throw e;
      }
    }

    return reply.code(200).send({
      status_code: 200,
      message: `Recurring booking accepted. Created ${insertedCount} tanker booking(s).`,
      data: {
        createdDates: newDates.slice(0, insertedCount),
        skippedExistingDates: allDates.filter(d => existingSet.has(d)),
        duplicateConflicts: duplicateErrors,
      },
    });
  } catch (err) {
    console.error(err);
    throw boom.internal("Failed to update recurring supplier response", err);
  }
};