const { Tanker, Tankerbooking,Bore,GovtPipeLine } = require('../models/tankers')
const { User,Counter, generateBookingId,resetCounter,generateCustomerId } = require('../models/User')
const { Tank } = require('../models/tanks')

const { FriendRequest } = require('../models/supplier')
//const User = require("../models/User");
const boom = require("boom");


const fastify = require("fastify")({
  logger: true,
});




exports.addTankers = async (req, reply) => {
  try {

    //const username = req.params.username;

console.log(req.params);
    const supplierId = req.params.supplierId;
    //console.log(loginObject.user.username)
    // const userInfo = await User.findOne({ username: username.toString() });
    // const updateData = req.body;
    

    // console.log("This is the reply in the handler after the validations", reply);
    tankersData = {
      supplierId:supplierId,

      supplier_name:req.body.supplier_name,
      supplier_address : req.body.supplier_address,
      tankerName: req.body.tankerName,
      phoneNumber: req.body.phoneNumber,
      alternative_phoneNumber: req.body.alternative_phoneNumber,
      typeofwater: req.body.typeofwater,
      capacity: req.body.capacity,
      price: req.body.price,
      status: req.body.status
    };
   console.log(req.body.typeofwater,req.body.capacity)

    var tanker_Name = req.body.tankerName
    var i_tank = await Tanker.findOne({ tankerName: tanker_Name,supplierId:supplierId})
    if(i_tank){
    throw new Error('tankername already exists');
            }
  else {

    var tankers = new Tanker(tankersData);

    checkFormEncoding = isUserFormUrlEncoded(req);
    if (checkFormEncoding.isUserFormUrlEncoded) {
      usertobeInserted = checkFormEncoding.tankers;
      console.log("thsi true url string");
      tankers.supplier_name = usertobeInserted.supplier_name;
      tankers.supplier_address = usertobeInserted.supplier_address;
      tankers.tankerName = usertobeInserted.tankerName;
      tankers.phoneNumber = usertobeInserted.phoneNumber;
      tankers.alternative_phoneNumber = usertobeInserted.alternative_phoneNumber;
      tankers.capacity = usertobeInserted.capacity;
      tankers.typeofwater = usertobeInserted.typeofwater;
      tankers.price = usertobeInserted.price;
      tankers.status = usertobeInserted.status;
    }
  }
    const insertedTanker = await tankers.save();

    return insertedTanker;
  

  } catch (err) {
    throw boom.boomify(err);
  }
};




exports.deleteTankerInfo1 = async (req, reply) => {
  try {

    //const username = req.params.username;

console.log(req.params);
    const supplierId = req.params.supplierId;
    //console.log(loginObject.user.username)
    // const userInfo = await User.findOne({ username: username.toString() });
    // const updateData = req.body;
    

    // console.log("This is the reply in the handler after the validations", reply);
    tankersData = {
      supplierId:supplierId,

      supplier_name:req.body.supplier_name,
      supplier_address : req.body.supplier_address,
      tankerName: req.body.tankerName,
      phoneNumber: req.body.phoneNumber,
      alternative_phoneNumber: req.body.alternative_phoneNumber,
      typeofwater: req.body.typeofwater,
      capacity: req.body.capacity,
      price: req.body.price,
      status: req.body.status
    };
   console.log(req.body.typeofwater,req.body.capacity)

    var tanker_Name = req.body.tankerName
    var i_tank = await Tanker.findOne({ tankerName: tanker_Name,supplierId:supplierId})
    if(i_tank){
    throw new Error('tankername already exists');
            }
  else {

    var tankers = new Tanker(tankersData);

    checkFormEncoding = isUserFormUrlEncoded(req);
    if (checkFormEncoding.isUserFormUrlEncoded) {
      usertobeInserted = checkFormEncoding.tankers;
      console.log("thsi true url string");
      tankers.supplier_name = usertobeInserted.supplier_name;
      tankers.supplier_address = usertobeInserted.supplier_address;
      tankers.tankerName = usertobeInserted.tankerName;
      tankers.phoneNumber = usertobeInserted.phoneNumber;
      tankers.alternative_phoneNumber = usertobeInserted.alternative_phoneNumber;
      tankers.capacity = usertobeInserted.capacity;
      tankers.typeofwater = usertobeInserted.typeofwater;
      tankers.price = usertobeInserted.price;
      tankers.status = usertobeInserted.status;
    }
  }
    const insertedTanker = await tankers.save();

    return insertedTanker;
  

  } catch (err) {
    throw boom.boomify(err);
  }
};

//update selected tanker
exports.updateTankersInfo = async (req, reply) =>  {

  try {
    var supplierId = req.params.supplierId;
    var tankerName = req.query.tankerName;
    var tanker = req.body;
    const { ...updateData } = tanker;
    const update = await Tanker.findOneAndUpdate({ supplierId:supplierId,tankerName: tankerName, }, updateData, { new: true });
    //console.log(update.username)
    //return update;

    reply.send({ status_code: 200, data: update });


  } 
  catch (err) {
    throw boom.boomify(err);
  }
};

//delete selected tanker
exports.deleteTankerInfo = async (req, reply) => {
  try {
    var supplierId = req.params.supplierId;
    var tankerName = req.query.tankerName;
    const tanker = await Tanker.findOneAndDelete({ supplierId:supplierId,tankerName: tankerName, });
    reply.send({ status_code: 200, data: tanker});
   // return tanker;
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.tankerBooking = async (req, reply) => {

  try {
    const customerId = req.params.customerId;
    const tankerName = req.body.tankerName;
    var b_id = await generateBookingId()
    const date = new Date()
    const year = date.getFullYear()
    const month = (date.getMonth() + 1).toString().padStart(2, '0')
    const day = date.getDate().toString().padStart(2, '0')
    const bookingId = `ARM${year}${month}${day}${b_id}`
  
    var booking_id = await Tankerbooking.findOne({ bookingid: bookingId})
    if(booking_id){
      b_id= await generateBookingId()
           }
   else {
   
    bookingsData = {
      tankname:req.body.tankname,
      tankLocation:req.body.tankLocation,
      tankerName:tankerName,
      customerId:customerId,
      bookingid : bookingId,
      typeofwater: req.body.typeofwater,
      capacity: req.body.capacity,
      address: req.body.address,
      dateOfOrder: req.body.dateOfOrder,
     //date: req.body.date,
     // time: req.body.time,

    };
 
    var tankersBookingData = new Tankerbooking(bookingsData);

    checkFormEncoding = isUserFormUrlEncoded(req);
    if (checkFormEncoding.isUserFormUrlEncoded) {
      usertobeInserted = checkFormEncoding.tankersBookingData;
      console.log("thsi true url string");
      tankersBookingData.customerId = customerId;
      tankersBookingData.tankname = usertobeInserted.tankname;
      tankersBookingData.tankLocation = usertobeInserted.tankLocation;
      tankersBookingData.tankerName = tankerName;
      tankersBookingData.bookingid = bookingId;
      tankersBookingData.capacity = usertobeInserted.capacity;
      tankersBookingData.typeofwater = usertobeInserted.typeofwater;
      tankersBookingData.address = usertobeInserted.address;
      tankersBookingData.dateOfOrder = usertobeInserted.dateOfOrder;
     //tankersBookingData.date = usertobeInserted.date;
      //tankersBookingData.time = usertobeInserted.time;

    }
  }
  
    const booking_data = await tankersBookingData.save();
    reply.send({ status_code: 200, data: booking_data });

    return booking_data;
    
  

  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getTanker = async (req, reply) => {
  try {
    await Tanker.find({supplierId: req.query.supplierId})
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getallTanker = async (req, reply) => {
  try {
    await Tanker.find()
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};






exports.getTankersBookingdetails = async (req, reply) => {
  try {
    const customerId = req.params.customerId
    const tankerName = req.query.tankerName

    await Tankerbooking.find({ customerId:customerId,tankerName: tankerName, })
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })



      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });


      
      
  } catch (err) {
    throw boom.boomify(err);
  }
};


exports.addBores = async (req, reply) => {
  try {

   
    var customerId = req.params.customerId;
    //console.log(customerId);
    //const  username  = loginObject.user.username;
    
    boresData = {
      customerId:customerId,
      boreName: req.body.boreName,
      capacity: req.body.capacity,
      typeofwater: req.body.typeofwater,
      description: req.body.description,
    };
   

    var bore_Name = req.body.boreName
    var i_bore = await Bore.findOne({ boreName: bore_Name,customerId:customerId})
    if(i_bore){
    throw new Error('Bore already exists');
            }
  else {

    var bores = new Bore(boresData);

    checkFormEncoding = isUserFormUrlEncoded(req);
    if (checkFormEncoding.isUserFormUrlEncoded) {
      usertobeInserted = checkFormEncoding.bores;
      console.log("thsi true url string");
      bores.customerId = usertobeInserted.customerId
      bores.boreName = usertobeInserted.boreName;
      bores.capacity = usertobeInserted.capacity;     
      bores.typeofwater = usertobeInserted.typeofwater;
      bores.description = usertobeInserted.description;
    }
  }
    const insertedBore = await bores.save();

    return insertedBore;
  

  } catch (err) {
    throw boom.boomify(err);
  }
};

exports.getBores = async (req, reply) => {
  try {
    await Bore.find({customerId: req.query.customerId})
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};


exports.deleteBoresInfo = async (req, reply) => {
  try {
   
    
    await Bore.findOneAndDelete({customerId: req.params.customerId,boreName: req.query.boreName});
    //console.log(Bore)

    reply.send({ status_code: 200},);
   // return Bore;
  } catch (err) {
    throw boom.boomify(err);
  }
};


exports.updateBoresInfo = async (req, reply) => {

  try {
    var customerId = req.params.customerId;
    var boreName = req.query.boreName;
    const bore = req.body;
    const { ...updateData } = bore;
    const update = await Bore.findOneAndUpdate({ customerId:customerId,boreName: boreName, }, updateData, { new: true });
    //console.log(update.username)
    //return update;

    reply.send({ status_code: 200, data: update });


  } 
  catch (err) {
    throw boom.boomify(err);
  }
};


exports.addGovtPIpeline = async (req, reply) => {
  try {

   
    var customerId = req.params.customerId;
    //console.log(customerId);
    //const  username  = loginObject.user.username;
    
    pipelineData = {
      customerId:customerId,
      Name: req.body.Name,
      capacity: req.body.capacity,
      typeofwater: req.body.typeofwater,
      description: req.body.description,
    };
   

    var pipeline_Name = req.body.Name
    var i_pipe = await GovtPipeLine.findOne({ Name: pipeline_Name,customerId:customerId})
    if(i_pipe){
    throw new Error('Pipeline already exists');
            }
  else {

    var pipe_line = new GovtPipeLine(pipelineData);

    checkFormEncoding = isUserFormUrlEncoded(req);
    if (checkFormEncoding.isUserFormUrlEncoded) {
      usertobeInserted = checkFormEncoding.pipe_line;
      console.log("thsi true url string");
      pipe_line.customerId = usertobeInserted.customerId
      pipe_line.Name = usertobeInserted.Name;
      pipe_line.capacity = usertobeInserted.capacity;       
      pipe_line.typeofwater = usertobeInserted.typeofwater;
      pipe_line.description = usertobeInserted.description;
    }
  }
    const insertedpipeline = await pipe_line.save();

    return insertedpipeline;
  

  } catch (err) {
    throw boom.boomify(err);
  }
};



exports.getPipeline = async (req, reply) => {
  try {
    await GovtPipeLine.find({customerId: req.query.customerId})
      .exec()
      .then((docs) => {
        reply.send({ status_code: 200, data: docs, count: docs.length });
      })
      .catch((err) => {
        console.log(err);
        reply.send({ error: err });
      });
  } catch (err) {
    throw boom.boomify(err);
  }
};



exports.deletePipelineInfo = async (req, reply) => {
  try {
   
    
    await GovtPipeLine.findOneAndDelete({customerId: req.params.customerId,Name: req.query.Name});
    //console.log(Bore)

    reply.send({ status_code: 200});
   // return Bore;
  } catch (err) {
    throw boom.boomify(err);
  }
}




exports.updatePipelineInfo = async (req, reply) => {

  try {
    var customerId = req.params.customerId;
    var Name = req.query.Name;
    const pipeline = req.body;
    const { ...updateData } = pipeline;
    const update = await GovtPipeLine.findOneAndUpdate({ customerId:customerId,Name: Name, }, updateData, { new: true });
    //console.log(update.username)
    //return update;

    reply.send({ status_code: 200, data: update });


  } 
  catch (err) {
    throw boom.boomify(err);
  }
};

exports.status = async (req, reply) => {

  try {
    var status = req.query.status;

    if (status === 'connected') {
      try {
        const tankers = await Tanker.find({});
        console.log("tankers...", tankers)
        reply.send(tankers);
      } catch (err) {
        reply.send({ message: err });
      }
    } else {
      reply.send({ message: 'Not Connected' });
    }

  } 
  catch (err) {
    throw boom.boomify(err);
  }
};

exports.connectionStatus = async (req, reply) => {
  try {
    // query the database to check if the customer and supplier are connected
    const isConnected = await User.findOne({ customerId: req.query.customerId })
      .populate('supplier', null, { supplierId: req.query.supplierId })
      .exec()
      .then(customer => customer.supplier !== null);

      console.log("isconne..", isConnected)
    
      if (isConnected) {
        // if customer and supplier are connected, return list of tankers
        const tankers = await Tanker.find({ }).exec();
        console.log("tankers..", tankers)
        reply.send({ tankers });
      } else {
        // if customer and supplier are not connected, return error
        reply.status(403).send({ error: 'Forbidden' });
      }
    //res.send({ tankers });
  } catch (err) {
    console.error(err);
    reply.status(500).send({ error: 'Internal server error' });
  }
}




exports.connectstatus = async (req, reply) => {
  
  
  



  try {
    const customerId = req.params.customerId;
    const supplierId = req.query.supplierId;
    
    console.log(req.params.customerId)
    console.log(req.query.supplierId)
    const data = await FriendRequest.findOne({ customerId: customerId, supplierId: supplierId });
    let connection_status = "not requested";
    if (data) {
      connection_status = data.status;
    }
    reply.send({ status_code: 200, customerId: customerId, supplierId: supplierId, status: connection_status });
  } catch (err) {
    throw boom.boomify(err);
  }
};




exports.deliveryboystart = async (req, reply) => {
  try {
    //let start_time,stop_time
    const customerId = req.params.customerId;
    const tankLocation = req.body.tankLocation;
    const action = req.body.action
    const receiver_tank = req.body.tankname
    const receiver_tank_info = await Tank.findOne({ customerId ,tankName:receiver_tank,tankLocation:tankLocation.toLowerCase()});
    const receiver_capacity =  parseInt((receiver_tank_info.capacity).replace(/,/g, ''), 10)
    const desired_water_percentage =  parseInt((req.body.percentage).replace(/,/g, ''), 10)
    const intervals = {};
    
      
    if(action === "start"){
     start_time = new Date().toLocaleString('en-US', {timeZone: 'Asia/Kolkata'})
      
      const supplier_tank = req.body.from
      const supplier_tank_type = (req.body.from_type).toLowerCase()
      const receiver_type = (req.body.to_type).toLowerCase()
      console.log(supplier_tank)


     if(supplier_tank_type==="sump" && receiver_type === "overhead"){
      await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { motor_status: "1" } });

       const supplier_tank_info1 = await Tank.findOne({ customerId ,tankName:supplier_tank,tankLocation:supplier_tank_type});
       //console.log(supplier_tank_info1)
        //const initial_update = parseInt(supplier_tank_info1.waterlevel.replace(/,/g, ''), 10)-200;
       // await Tank.findOneAndUpdate({customerId, tankName: supplier_tank,tankLocation:supplier_tank_type}, { $set: { waterlevel: initial_update } });
        const supplier_tank_info = await Tank.findOne({ customerId ,tankName:supplier_tank,tankLocation:supplier_tank_type});

       // await changingfrom_tankwaterlevel(customerId,initial_update,supplier_tank_info);
        let supplier_waterlevel = parseInt(supplier_tank_info.waterlevel.replace(/,/g, ''), 10)
       // console.log(supplier_waterlevel)
         let receiver_waterlevel = parseInt(receiver_tank_info.waterlevel.replace(/,/g, ''), 10)
         intervals[receiver_tank] = setInterval(async function () {
          // Calculate new water levels
          const supplier_tank_info2 = await Tank.findOne({ customerId ,tankName:supplier_tank,tankLocation:supplier_tank_type});
          const rcvr_info = await Tank.findOne({ customerId ,tankName:receiver_tank,tankLocation:receiver_type});
          const newWaterLevel = receiver_waterlevel  + 350//Math.floor(supplier_waterlevel  * 0.1);
          const newSupplierWaterLevel = supplier_waterlevel//Math.floor(supplier_waterlevel  * 0.1);
          const supplier_capacity = parseInt(supplier_tank_info.capacity.replace(/,/g, ''), 10)
          console.log((newSupplierWaterLevel/supplier_capacity)*100)
          // Check if updating should stop
          if ((newSupplierWaterLevel/supplier_capacity)*100 <= 5 || (newWaterLevel/receiver_capacity)*100 >= 95  || (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage || rcvr_info.motor_status === "0") {
            clearInterval(intervals[receiver_tank]); // Clear the interval for this tank
            delete intervals[receiver_tank]; 
            await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { motor_status: "0" } });

            console.log("end for"+receiver_tank);
          } else {
            // Update water levels in database
            //supplier_waterlevel = newSupplierWaterLevel;
            receiver_waterlevel = newWaterLevel;
            console.log((newSupplierWaterLevel/supplier_capacity)*100)
           // console.log((newWaterLevel/receiver_capacity)*100)
            console.log(receiver_tank+""+newWaterLevel+""+"bore to sump")
            await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { waterlevel: newWaterLevel } })
            if (supplier_tank_info2.motor_status==="0"){
              supplier_waterlevel =  parseInt(supplier_tank_info2.waterlevel.replace(/,/g, ''), 10)-350
              console.log(supplier_tank+""+newSupplierWaterLevel+""+"s to oh")
            await  Tank.findOneAndUpdate({customerId, tankName: supplier_tank,tankLocation:supplier_tank_type}, { $set: { waterlevel: supplier_waterlevel } })
            }

          }
        }, 2000);

      }



      //    if(supplier_tank_type==="sump" && receiver_type === "overhead"){
      //   await Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { motor_status: 1 } });
        
      //  // console.log(rcvr_info.motor_status)
      //   const supplier_tank_info1 = await Tank.findOne({ customerId ,tankName:supplier_tank});
      //   initial_update = parseInt(supplier_tank_info1.capacity.replace(/,/g, ''), 10)/2;

      //   await Tank.findOneAndUpdate({customerId, tankName: supplier_tank}, { $set: { waterlevel: initial_update } });
      //   const supplier_tank_info = await Tank.findOne({ customerId ,tankName:supplier_tank});
        
      //   let supplier_waterlevel = parseInt(supplier_tank_info.waterlevel.replace(/,/g, ''), 10)
      //    let receiver_waterlevel = parseInt(receiver_tank_info.waterlevel.replace(/,/g, ''), 10)
      //    intervalId = setInterval(async function () {
      //     const rcvr_info = await Tank.findOne({ customerId ,tankName:receiver_tank});
      //     const supplier_capacity = parseInt(supplier_tank_info.capacity.replace(/,/g, ''), 10)
      //     // Calculate new water levels
      //     const newWaterLevel = receiver_waterlevel  + 200//Math.floor(supplier_waterlevel  * 0.1);
      //     const newSupplierWaterLevel = Math.min(supplier_capacity, supplier_waterlevel + 350);// Math.floor(supplier_waterlevel * 0.15));
      //   //  console.log(newWaterLevel)
      //   //  console.log(newSupplierWaterLevel)
      //   //  console.log(rcvr_info.motor_status)
      //   //  console.log(rcvr_info.tankName)

      //     // Check if updating should stop
      //     if ( (newWaterLevel/receiver_capacity)*100 >= 95   ||  (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage || rcvr_info.motor_status === 0) {

      //       clearInterval(intervalId)
      //       await Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { motor_status: 0 } });
            
      //       console.log("end");
      //     } else {
      //       // Update water levels in database
      //       supplier_waterlevel = newSupplierWaterLevel;
      //       receiver_waterlevel = newWaterLevel;
      //     //  console.log((newSupplierWaterLevel/supplier_capacity)*100)
      //      // console.log((newWaterLevel/receiver_capacity)*100)
      //       await Promise.all([
      //         Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { waterlevel: newWaterLevel } }),
      //         Tank.findOneAndUpdate({customerId, tankName: supplier_tank}, { $set: { waterlevel: newSupplierWaterLevel } })
      //       ]);
      //     }
      //   }, 2000);


      // }

      if(supplier_tank_type==="bore" && receiver_type === "sump"){
          const receiver_capacity =   parseInt(receiver_tank_info.capacity.replace(/,/g, ''), 10)
         // console.log(receiver_capacity,"0",receiver_tank_info.tankName)
          await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { motor_status: "1" } });

         let receiver_waterlevel = parseInt(receiver_tank_info.waterlevel.replace(/,/g, ''), 10)
        // console.log(receiver_waterlevel,"1")
         intervals[receiver_tank] = setInterval(async function () {
          // Calculate new water levels
          const rcvr_info = await Tank.findOne({ customerId ,tankName:receiver_tank,tankLocation:receiver_type});
          //console.log(rcvr_info)
          //console.log(rcvr_info.motor_status)
          const newWaterLevel = receiver_waterlevel+450;
          //console.log(newWaterLevel,"2",receiver_tank_info.tankName)
          // Check if updating should stop
          if ((newWaterLevel/receiver_capacity)*100 >= 97 || (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage || rcvr_info.motor_status === "0"   ) {
            
            await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { motor_status: "0" } });
            clearInterval(intervals[receiver_tank]); // Clear the interval for this tank
            delete intervals[receiver_tank]; 
            console.log("end for" + receiver_tank);
          } else {
            // Update water levels in database
            
            receiver_waterlevel = newWaterLevel;
            console.log(receiver_tank+""+newWaterLevel+""+"bore to sump")
            //console.log((newWaterLevel/receiver_capacity)*100,"4",receiver_tank_info.tankName)
            await  Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:receiver_type}, { $set: { waterlevel: newWaterLevel } })
          }
        }, 2000);

      }
     // console.log(customerId,req.body.from,req.body.from_type,receiver_tank,req.body.to_type,)
      motorData = {
        
        customerId:customerId,
        supplierTank : req.body.from,
        supplier_type: req.body.from_type,
        receiverTank: receiver_tank,
        receiver_type: req.body.to_type,
        startTime: req.body.startTime,
        stopTime: req.body.stopTime,
        
      
  
      };
      var motorData = new MotorData(motorData);

    checkFormEncoding = isUserFormUrlEncoded(req);
    if (checkFormEncoding.isUserFormUrlEncoded) {
      usertobeInserted = checkFormEncoding.motorData;
      console.log("thsi true url string");
      motorData.customerId = customerId;
      motorData.supplierTank = req.body.from;
      motorData.receiverTank = receiver_tank;
      motorData.supplier_type = req.body.from_type;
      motorData.receiver_type = req.body.to_type;
      motorData.startTime = usertobeInserted.startTime;
      motorData.stopTime = usertobeInserted.stopTime;
     

    }
    const motor_data = await motorData.save();
   // reply.send({ status_code: 200, data: motor_data });
   


 
      reply.send({ status_code: 200, "start time": start_time, data: motor_data});
      console.log(start_time)
      return motor_data


    }
    
    else if (action === "stop") {
     stop_time = new Date().toLocaleString('en-US', {timeZone: 'Asia/Kolkata'})
     // console.log(stop_time)
         // clearInterval(intervalId);
          await Tank.findOneAndUpdate({customerId, tankName: receiver_tank,tankLocation:(req.body.to_type).toLowerCase()}, { $set: { motor_status: "0" } });

       reply.send({ status_code: 200, "stop time": stop_time});
      } else {
          throw new Error("Invalid action");
      }
      
      return { message: 'Water level updates started' };
      
  } catch (err) {
      throw new Error(`Failed to start/stop water level updates: ${err.message}`);

  };
};