diff --git a/src/controllers/tanksController.js b/src/controllers/tanksController.js
index f7ddbe18..c244ba51 100644
--- a/src/controllers/tanksController.js
+++ b/src/controllers/tanksController.js
@@ -160,23 +160,53 @@ exports.updateTanksInfo = async (req, reply) => {
   }
 };
 
-//delete selected tank
+
+
+
+
 exports.deleteTanksInfo = async (req, reply) => {
   try {
-    const customerId = req.params.customerId;
-   
-    const tankName = req.query.tankName;
+    const { customerId } = req.params;
+    const { tankName } = req.query;
     const tankLocation = req.body.tankLocation.toLowerCase();
-    const tank = await Tank.findOneAndDelete({ tankName: tankName,customerId:customerId,tankLocation:tankLocation });
+    if (!tankName || !tankLocation) {
+      return reply.code(400).send({ message: "Tank name and location are required" });
+    }
 
-    reply.send({ status_code: 200, data: tank});
-   // return tank;
-  } catch (err) {
-    throw boom.boomify(err);
+    // Convert tankLocation to lowercase (for case-insensitive match)
+    const normalizedTankLocation = tankLocation.toLowerCase();
+
+    // Find and delete the main tank
+    const deletedTank = await Tank.findOneAndDelete({ 
+      customerId, 
+      tankName, 
+      tankLocation: normalizedTankLocation 
+    });
+
+    if (!deletedTank) {
+      return reply.code(404).send({ message: "Tank not found" });
+    }
+
+    // Remove the deleted tank from inputConnections and outputConnections in all other tanks
+    await Tank.updateMany(
+      { customerId },
+      {
+        $pull: {
+          "connections.inputConnections": { inputConnections: tankName },
+          "connections.outputConnections": { outputConnections: tankName }
+        }
+      }
+    );
+
+    return reply.send({ message: "Tank deleted successfully" });
+  } catch (error) {
+    console.error("Error deleting tank:", error);
+    return reply.code(500).send({ message: "Internal Server Error" });
   }
 };
 
 
+
 exports.getConnectionsInfoOfParticularTank = async (req, reply) => {
   try {
     const customerId = req.params.customerId;
@@ -349,24 +379,68 @@ exports.getTanksofParticularInstaller = async (req, reply) => {
  //   throw boom.boomify(err);
  // }
 //};
+// const boom = require("@hapi/boom"); // Assuming you are using boom for error handling
+
+
 
 exports.getTankmotordata = async (req, reply) => {
   try {
-    await MotorData.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 });
+    const { startDate, stopDate } = req.body;
+    const { customerId } = req.params;
+
+    // Validate and format the input dates
+    if (!moment(startDate, "DD-MMM-YYYY - HH:mm", true).isValid() || !moment(stopDate, "DD-MMM-YYYY - HH:mm", true).isValid()) {
+      return reply.send({ status_code: 400, message: "Invalid date format" });
+    }
+
+    // Convert input dates to ISO 8601 format for Date comparison
+    const startISODate = moment(startDate, "DD-MMM-YYYY - HH:mm").toDate();
+    const stopISODate = moment(stopDate, "DD-MMM-YYYY - HH:mm").toDate();
+
+    // Convert input dates to string format for string-based comparison
+    const startStringDate = moment(startDate, "DD-MMM-YYYY - HH:mm").format("DD-MMM-YYYY - HH:mm");
+    const stopStringDate = moment(stopDate, "DD-MMM-YYYY - HH:mm").format("DD-MMM-YYYY - HH:mm");
+
+    // Fetch the username based on customerId
+    const user = await User.findOne({ customerId }).select("username");
+
+    if (user) {
+      const userName = user.username || "N/A";
+
+      // Query the MotorData collection
+      const motorDataDocs = await MotorData.find({
+        customerId,
+        $or: [
+          {
+            startTime: { $gte: startISODate, $lte: stopISODate }, // Date-based comparison
+          },
+          {
+            startTime: { $gte: startStringDate, $lte: stopStringDate }, // String-based comparison
+          },
+        ],
+      }).exec();
+
+      reply.send({
+        status_code: 200,
+        data: motorDataDocs,
+        count: motorDataDocs.length,
+        customerName: userName,
       });
+    } else {
+      reply.send({ status_code: 404, message: "User not found" });
+    }
   } catch (err) {
+    console.error("Error in getTankmotordata:", err);
     throw boom.boomify(err);
   }
 };
 
 
+
+
+
+
+
 exports.updateTanklevels = async (req, reply) => {
   try {
     const customerId = req.params.customerId;
@@ -376,7 +450,7 @@ exports.updateTanklevels = async (req, reply) => {
 
     for (const tank of tanks) {
       const tankId = tank._id;
-      const tank_name = tank.tankName
+      const tank_name = tank.tankName 
       let capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);
      //let waterLevel = parseInt(tank.waterlevel.replace(/,/g, ''), 10);
 
@@ -1051,50 +1125,52 @@ let supplier_tanks = [];
 
 
 
+
 exports.consumption = async (request, reply) => {
   try {
     const { customerId } = request.params;
     const { startDate, stopDate, block } = request.body;
     let { typeofwater } = request.body;
-    
-    
+
     // Convert typeofwater to lowercase
     typeofwater = typeofwater.toLowerCase();
     const start = moment(startDate, "DD-MMM-YYYY - HH:mm").toDate();
     const end = moment(stopDate, "DD-MMM-YYYY - HH:mm").toDate();
 
-    // Construct the query object based on block and typeofwater inputs
+    // Construct the query object
     const tankQuery = { customerId, tankLocation: "overhead" };
+    if (block !== "All") tankQuery.blockName = block;
 
-    if (block !== "All") {
-      tankQuery.blockName = block; // Filter by specific block if not "all"
-    }
-
-    if (typeofwater !== "all") {
-      tankQuery.typeOfWater = typeofwater; // Filter by specific type of water if not "all"
+    // Add typeofwater filter
+    if (typeofwater === "bore") {
+      tankQuery.typeOfWater = { $in: ["bore", "Bore Water"] };
+    } else if (typeofwater === "drinking") {
+      tankQuery.typeOfWater = { $in: ["drinking", "Drinking Water"] };
     }
 
     const tanks = await Tank.find(tankQuery);
     const tankData = [];
     const tankconsumptionData = [];
-    // Variable to track total consumption for the selected block and typeofwater
     let totalConsumptionForSelectedBlockAndTypeOfWater = 0;
-    let totalCapacityForSelectedBlockAndTypeOfWater=0;
+    let totalBoreConsumptionForSelectedBlockAndTypeOfWater = 0;
+    let totalBoreCapacityForSelectedBlockAndTypeOfWater = 0;
+    let totalDrinkingConsumptionForSelectedBlockAndTypeOfWater = 0;
+    let totalDrinkingCapacityForSelectedBlockAndTypeOfWater = 0;
 
     for (const tank of tanks) {
       const waterlevel_at_midnight = parseInt(tank.waterlevel_at_midnight.replace(/,/g, ''), 10);
       const total_water_added_from_midnight = parseInt(tank.total_water_added_from_midnight.replace(/,/g, ''), 10);
       const waterlevel = parseInt(tank.waterlevel.replace(/,/g, ''), 10);
       const tankname = tank.tankName;
-      const capacity =    parseInt(tank.capacity.replace(/,/g, ''), 10);
+      const capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);
 
       const tankConsumptions = await TankConsumptionOriginalSchema.find({
         customerId,
         tankName: tank.tankName,
         tankLocation: tank.tankLocation,
-
-        ...(block !== "All" && { block: tank.blockName }), // Ensure correct field names
-        ...(typeofwater !== "all" && { typeofwater: tank.typeOfWater }) // Ensure correct field names
+        ...(block !== "All" && { block: tank.blockName }),
+        ...(typeofwater === "bore" && { typeofwater: { $in: ["bore", "Bore Water"] } }),
+        ...(typeofwater === "drinking" && { typeofwater: { $in: ["drinking", "Drinking Water"] } }),
       });
 
       const filteredConsumptions = tankConsumptions.filter((record) => {
@@ -1105,36 +1181,75 @@ exports.consumption = async (request, reply) => {
       const total_consumption_from_records = filteredConsumptions.reduce((acc, record) => {
         return acc + parseInt(record.consumption, 10);
       }, 0);
-      tankconsumptionData.push({
-        tankname,
-        consumptionRecordsdatewise: filteredConsumptions
-      })
 
       const consumption = (waterlevel_at_midnight + total_water_added_from_midnight) - waterlevel + total_consumption_from_records;
-
-      // Add to the total consumption for the selected block and typeofwater
       totalConsumptionForSelectedBlockAndTypeOfWater += consumption;
-      totalCapacityForSelectedBlockAndTypeOfWater += capacity;
+     
+      // Add to the total consumption and capacities based on water type
+      if (tank.typeOfWater === "bore" || tank.typeOfWater === "Bore Water") {
+        totalBoreConsumptionForSelectedBlockAndTypeOfWater += consumption;
+        totalBoreCapacityForSelectedBlockAndTypeOfWater += capacity;
+      } else if (tank.typeOfWater === "drinking" || tank.typeOfWater === "Drinking Water") {
+        totalDrinkingConsumptionForSelectedBlockAndTypeOfWater += consumption;
+        totalDrinkingCapacityForSelectedBlockAndTypeOfWater += capacity;
+      }
 
       tankData.push({
         tankname,
-       
         totalConsumption: consumption,
         block: tank.blockName,
         TypeofWater: tank.typeOfWater,
         location: tank.tankLocation,
         capacity: tank.capacity,
-        waterlevel: tank.waterlevel
+        waterlevel: tank.waterlevel,
+      });
+
+      tankconsumptionData.push({
+        tankname,
+        consumptionRecordsdatewise: filteredConsumptions,
       });
     }
-    const totalConsumptionPercentage =  ((totalConsumptionForSelectedBlockAndTypeOfWater / totalCapacityForSelectedBlockAndTypeOfWater) * 100).toFixed(2) ;
+
+    // Calculate total consumption percentages
+    const boreConsumptionPercentage = totalBoreCapacityForSelectedBlockAndTypeOfWater
+      ? ((totalBoreConsumptionForSelectedBlockAndTypeOfWater / totalBoreCapacityForSelectedBlockAndTypeOfWater) * 100).toFixed(2)
+      : 0;
+
+    const drinkingConsumptionPercentage = totalDrinkingCapacityForSelectedBlockAndTypeOfWater
+      ? ((totalDrinkingConsumptionForSelectedBlockAndTypeOfWater / totalDrinkingCapacityForSelectedBlockAndTypeOfWater) * 100).toFixed(2)
+      : 0;
+
+    const totalConsumptionPercentage =
+      typeofwater === "bore"
+        ? boreConsumptionPercentage
+        : typeofwater === "drinking"
+        ? drinkingConsumptionPercentage
+        : ((totalBoreConsumptionForSelectedBlockAndTypeOfWater + totalDrinkingConsumptionForSelectedBlockAndTypeOfWater) /
+           (totalBoreCapacityForSelectedBlockAndTypeOfWater + totalDrinkingCapacityForSelectedBlockAndTypeOfWater) *
+           100
+          ).toFixed(2);
 
     // Include the total consumption in the response
     const response = {
       status_code: 200,
-      tankData,consumptiorecordsdatewise:tankconsumptionData,
-      totalConsumptionPercentage:totalConsumptionPercentage,
-      [`total consumption of ${typeofwater} and selected block`]: totalConsumptionForSelectedBlockAndTypeOfWater
+      tankData,
+      consumptiorecordsdatewise: tankconsumptionData,
+      totalConsumptionPercentage,
+      ...(typeofwater === "all"
+        ? {
+            totalConsumptionPercentageForBore: boreConsumptionPercentage,
+            totalConsumptionPercentageForDrinking: drinkingConsumptionPercentage,
+            totalConsumptionForBore: totalBoreConsumptionForSelectedBlockAndTypeOfWater,
+            totalConsumptionForDrinking: totalDrinkingConsumptionForSelectedBlockAndTypeOfWater,
+          }
+        : {
+            [`total consumption of ${typeofwater} and selected block`]:
+              typeofwater === "bore"
+                ? totalBoreConsumptionForSelectedBlockAndTypeOfWater
+                : totalDrinkingConsumptionForSelectedBlockAndTypeOfWater,
+          }
+        ),
+        [`total consumption of ${typeofwater} and selected block`]: totalConsumptionForSelectedBlockAndTypeOfWater
     };
 
     reply.send(response);
@@ -1143,6 +1258,8 @@ exports.consumption = async (request, reply) => {
   }
 };
 
+
+
 exports.consumptiondatewiseofalltanks = async (request, reply) => {
   try {
     const { customerId } = request.params;
@@ -1575,25 +1692,64 @@ admin.initializeApp({
 //   await sendNotification(fcmTokens, 'Motor Started', `Motor ID: ${motorId} started successfully at ${timestamp}. Current Water Level: ${waterLevel} Ltrs`);
 // });
 
+// eventEmitter.on(
+//   'motorStart', 
+//   async (fcmTokens, timestamp, motorId, waterLevel, blockName, tankName, startTime, motorOnType, stopCriteria, manual_threshold_time) => {
+//     try {
+//       // Retrieve the user information
+//       const users = await User.find({ fcmIds: { $in: fcmTokens } });
+//       console.log("users", users);
+//       const userNames = users.map(user => user.username).join(', ');
+//       console.log("userNames", userNames);
+//       const startMethod = motorOnType === "APP" ? "via the App" : "Manual";
+
+//       // Prepare the message
+//       const message = 
+//         `🚰 Tank Name: '${tankName}'\n` +
+//         `🕒 Pump started at: '${startTime}'\n` +
+//         `👤 Started by : ${userNames}\n` +
+//         // `Pump started by: '${motorOnType.toUpperCase()}'\n` +
+//         `Mode : '${startMethod}'\n` +
+//         `Will stop at after: '${manual_threshold_time}' mins`;
+
+//       // Send the notification
+//       await sendNotification(fcmTokens, 'Arminta Water Management', message);
+//     } catch (error) {
+//       console.error('Error in motorStart event:', error);
+//     }
+//   }
+// );
+
+// Event listener for motorStart
 eventEmitter.on(
   'motorStart', 
-  async (fcmTokens, timestamp, motorId, waterLevel, blockName, tankName, startTime, motorOnType, stopCriteria, manual_threshold_time) => {
+  async (fcmTokens, tankName, blockName, startTime, motorOnType, manual_threshold_time, typeOfWater) => {
     try {
       // Retrieve the user information
       const users = await User.find({ fcmIds: { $in: fcmTokens } });
       console.log("users", users);
       const userNames = users.map(user => user.username).join(', ');
       console.log("userNames", userNames);
-      const startMethod = motorOnType.toUpperCase() === "APP" ? "via the App" : "Manual";
+      
+      const startMethod = motorOnType === "Mobile APP" ? "Mobile APP" : "Manual";
+
+      // Generate motor name dynamically based on tank name, block name, and type of water
+      const motorName = `${tankName}-${blockName}-${typeOfWater}`;
+
+      // Get current date and time for the motor start time
+      const currentDateTime = new Date();
+      const formattedDate = currentDateTime.toLocaleDateString(); // Customize this format as needed
+      const formattedTime = currentDateTime.toLocaleTimeString(); // Customize this format as needed
 
       // Prepare the message
       const message = 
-        `Tank Name: '${tankName}'\n` +
-        `Pump started at: '${startTime}'\n` +
-        `Initiated by : ${userNames}\n` +
-        // `Pump started by: '${motorOnType.toUpperCase()}'\n` +
-        `Pump started by: '${startMethod}'\n` +
-        `Will stop at after: '${manual_threshold_time}' mins`;
+        `🚰 Motor Name: ${motorName}\n` +
+        `🚰 Tank Name: '${tankName}'\n` +
+        `🏢 Block Name: '${blockName}'\n` +
+        `👤 Started by: ${userNames}\n` +
+        `📱 Mode: '${startMethod}'\n` +
+        `🕒 Pump started at: ${startTime} \n` +
+        `Will stop after: '${manual_threshold_time}' mins`;
 
       // Send the notification
       await sendNotification(fcmTokens, 'Arminta Water Management', message);
@@ -1603,33 +1759,108 @@ eventEmitter.on(
   }
 );
 
+// Event listener for motorStop
+eventEmitter.on(
+  'motorStop',
+  async (fcmTokens, tankName, blockName, stopTime, motorOnType, totalWaterPumped, typeOfWater) => {
+    try {
+      // Retrieve the user information
+      const users = await User.find({ fcmIds: { $in: fcmTokens } });
+      const userNames = users.map(user => user.username).join(', ');
+
+      const stopMethod = motorOnType === "Mobile APP" ? "Mobile APP" : "Manual";
 
-eventEmitter.on('motorStop', async (fcmTokens,  tankName,stopTime, motorOnType) => {
-  try {
-    // Retrieve the user information
-    const users = await User.find({ fcmIds: { $in: fcmTokens } });
-    console.log("users",users)
-    const userNames = users.map(user => user.username).join(', ');
-    console.log("userNames",userNames)
-
-    const stopMethod = motorOnType.toUpperCase() === "APP" ? "via the App" : "manual";
-
-    // Prepare the message
-    // const message = `Tank Name: '${tankName}', Pump stopped at '${stopTime}' by Initiated by user(s): ${userNames} '${motorOnType}'`;
-    const message = 
-    `Tank Name: '${tankName}'\n` +
-    `Pump stopped at: '${stopTime}'\n` +
-    `Initiated by : ${userNames}\n` +
-    // `Motor Off Type: '${motorOnType}'`;
-    `Motor Off Type: '${stopMethod}'`;
+      // Generate motor name dynamically based on tank name, block name, and type of water
+      const motorName = `${tankName}-${blockName}-${typeOfWater}`;
 
-  
-    // Send the notification
-    await sendNotification(fcmTokens, 'Arminta Water Management', message);
-  } catch (error) {
-    console.error('Error in motorStart event:', error);
+      // Get current date and time for the motor stop time
+      const currentDateTime = new Date();
+      const formattedDate = currentDateTime.toLocaleDateString(); // Customize this format as needed
+      const formattedTime = currentDateTime.toLocaleTimeString(); // Customize this format as needed
+
+      // Prepare the message
+      const message = 
+        `🚰 Motor Name: ${motorName}\n` +
+        `🛢️ Tank Name: '${tankName}'\n` +
+        `🏢 Block Name: '${blockName}'\n` +
+        `👤 Stopped by: ${userNames}\n` +
+        `📱 Mode: '${stopMethod}'\n` +
+        `🕒 Pump stopped at: ${stopTime}\n` +
+        `💧 Total water pumped: ${totalWaterPumped} liters\n`; // Ensure this line is properly terminated
+
+      // Send the notification
+      await sendNotification(fcmTokens, 'Arminta Water Management', message);
+    } catch (error) {
+      console.error('Error in motorStop event:', error);
+    }
   }
-});
+);
+
+eventEmitter.on(
+  'motorStartAutomatic', 
+  async (fcmTokens, tankName, blockName, startTime, motorOnType, manual_threshold_time, typeOfWater,threshold) => {
+    try {
+      // Retrieve the user information
+      const users = await User.find({ fcmIds: { $in: fcmTokens } });
+      console.log("users", users);
+      const userNames = users.map(user => user.username).join(', ');
+      console.log("userNames", userNames);
+      
+      const startMethod = motorOnType === "Automatic" ? "Automatic" : "Manual";
+
+      // Generate motor name dynamically based on tank name, block name, and type of water
+      const motorName = `${tankName}-${blockName}-${typeOfWater}`;
+
+      // Get current date and time for the motor start time
+      const currentDateTime = new Date();
+      const formattedDate = currentDateTime.toLocaleDateString(); // Customize this format as needed
+      const formattedTime = currentDateTime.toLocaleTimeString(); // Customize this format as needed
+
+      // Prepare the message
+      const message = 
+        `🚰 Motor Name: ${motorName}\n` +
+        `🛢️ Tank Name: '${tankName}'\n` +
+        `🏢 Block Name: '${blockName}'\n` +
+        `👤 Started by: '${startMethod}' \n` +
+        `📱 Mode: "Atomatic System" \n` +
+        `🕒 Pump started at: ${startTime} \n` +
+        `Will stop after: '${threshold}' `;
+
+      // Send the notification
+      await sendNotification(fcmTokens, 'Arminta Water Management', message);
+    } catch (error) {
+      console.error('Error in motorStart event:', error);
+    }
+  }
+);
+
+
+// eventEmitter.on('motorStop', async (fcmTokens,  tankName,stopTime, motorOnType) => {
+//   try {
+//     // Retrieve the user information
+//     const users = await User.find({ fcmIds: { $in: fcmTokens } });
+//     console.log("users",users)
+//     const userNames = users.map(user => user.username).join(', ');
+//     console.log("userNames",userNames)
+
+//     const stopMethod = motorOnType === "Mobile APP" ? "via the App" : "manual";
+
+//     // Prepare the message
+//     // const message = `Tank Name: '${tankName}', Pump stopped at '${stopTime}' by Initiated by user(s): ${userNames} '${motorOnType}'`;
+//     const message = 
+//     `🚰 Tank Name: '${tankName}'\n` +
+//     `🕒 Pump stopped at: '${stopTime}'\n` +
+//     `👤 Initiated by : ${userNames}\n` +
+//     // `Motor Off Type: '${motorOnType}'`;
+//     `Motor Off Type: '${stopMethod}'`;
+
+  
+//     // Send the notification
+//     await sendNotification(fcmTokens, 'Arminta Water Management', message);
+//   } catch (error) {
+//     console.error('Error in motorStart event:', error);
+//   }
+// });
 
 // Emit motor stop event with motorId
 // eventEmitter.on('motorStop', async (fcmTokens, timestamp, motorId,  waterLevel, blockName, tankName,stopTime,motorOnType) => {
@@ -1638,39 +1869,39 @@ eventEmitter.on('motorStop', async (fcmTokens,  tankName,stopTime, motorOnType)
 // });
 
 // Event listener to handle notification
-eventEmitter.on('sendLowWaterNotification', async (fcmToken, tankInfo) => {
-  const message = formatWaterLevelMessage(tankInfo, 'low');
-  sendNotification(fcmToken, message);
-});
+// eventEmitter.on('sendLowWaterNotification', async (fcmToken, tankInfo) => {
+//   const message = formatWaterLevelMessage(tankInfo, 'low');
+//   sendNotification(fcmToken, message);
+// });
 
-eventEmitter.on('sendVeryLowWaterNotification', async (fcmToken, tankInfo) => {
-  const message = formatWaterLevelMessage(tankInfo, 'very low');
-  sendNotification(fcmToken, message);
-});
+// eventEmitter.on('sendVeryLowWaterNotification', async (fcmToken, tankInfo) => {
+//   const message = formatWaterLevelMessage(tankInfo, 'very low');
+//   sendNotification(fcmToken, message);
+// });
 
-eventEmitter.on('sendCriticalLowWaterNotification', async (fcmToken, tankInfo) => {
-  const message = formatWaterLevelMessage(tankInfo, 'critically low');
-  sendNotification(fcmToken, message);
-});
+// eventEmitter.on('sendCriticalLowWaterNotification', async (fcmToken, tankInfo) => {
+//   const message = formatWaterLevelMessage(tankInfo, 'critically low');
+//   sendNotification(fcmToken, message);
+// });
 
-const formatWaterLevelMessage = (tankInfo, levelType) => {
-  const tankName = tankInfo.tankName;
-  const tankLocation = tankInfo.tankLocation;
-  const waterLevel = parseInt(tankInfo.waterlevel, 10);
-  const capacity = parseInt(tankInfo.capacity, 10);
-  const volumeInLitres = (capacity * waterLevel) / 100; // assuming the capacity is in litres
-
-  let levelDescription = '';
-  if (levelType === 'low') {
-    levelDescription = `${waterLevel}% (${volumeInLitres.toFixed(2)} L)`;
-  } else if (levelType === 'very low') {
-    levelDescription = `${waterLevel}% (${volumeInLitres.toFixed(2)} L)`;
-  } else if (levelType === 'critically low') {
-    levelDescription = `${waterLevel}% (${volumeInLitres.toFixed(2)} L)`;
-  }
+// const formatWaterLevelMessage = (tankInfo, levelType) => {
+//   const tankName = tankInfo.tankName;
+//   const tankLocation = tankInfo.tankLocation;
+//   const waterLevel = parseInt(tankInfo.waterlevel, 10);
+//   const capacity = parseInt(tankInfo.capacity, 10);
+//   const volumeInLitres = (capacity * waterLevel) / 100; // assuming the capacity is in litres
+
+//   let levelDescription = '';
+//   if (levelType === 'low') {
+//     levelDescription = `${waterLevel}% (${volumeInLitres.toFixed(2)} L)`;
+//   } else if (levelType === 'very low') {
+//     levelDescription = `${waterLevel}% (${volumeInLitres.toFixed(2)} L)`;
+//   } else if (levelType === 'critically low') {
+//     levelDescription = `${waterLevel}% (${volumeInLitres.toFixed(2)} L)`;
+//   }
 
-  return `Water level in '${tankName}', located at '${tankLocation}', type of water: ${tankInfo.waterType} is ${levelType} at ${levelDescription}. Action: start motor now.`;
-};
+//   return `Water level in '${tankName}', located at '${tankLocation}', type of water: ${tankInfo.waterType} is ${levelType} at ${levelDescription}. Action: start motor now.`;
+// };
 
 // Emit low water level event with motorId
 // eventEmitter.on('lowWaterLevel', async (fcmTokens, timestamp, motorId, waterLevel) => {
@@ -1707,24 +1938,255 @@ eventEmitter.on('sendThresholdTimeNotification', async (fcmTokens, message) => {
   }
 });
 
-eventEmitter.on('sendMotorStartNotification', async (fcmTokens, message) => {
-  try {
-    await  sendNotification(fcmTokens, "Motor Started", message);
-    console.log("Manual method time notification sent successfully.");
-  } catch (error) {
-    console.error("Error sending thresmanual method time notification:", error);
+// eventEmitter.on(
+//   'sendMotorStartNotification',
+//   async (fcmTokens, motorId, waterLevel, blockName, tankName, motorOnType, stopCriteria, manual_threshold_time) => {
+//     try {
+//       // Get the latest timestamp
+//       const startTime = new Date().toLocaleString('en-IN', { timeZone: 'Asia/Kolkata' });
+
+//       // Retrieve the user information
+//       const users = await User.find({ fcmIds: { $in: fcmTokens } });
+//       const userNames = users.map(user => user.username).join(', ');
+//       const startMethod = motorOnType.toUpperCase() === "Forced Manual";
+
+//       // Prepare the message
+//       const message =
+//         `🚰 Tank Name: '${tankName}'\n` +
+//         `🕒 Pump started at: '${startTime}'\n` +
+//         `👤 Initiated by: ${userNames}\n` +
+//         `🔄 Pump started by: '${startMethod}'`;
+
+//       // Send the notification
+//       await sendNotification(fcmTokens, 'Motor Started 🚀', message);
+//       console.log('Motor start notification sent successfully!');
+//     } catch (error) {
+//       console.error('Error in sendMotorStartNotification event:', error);
+//     }
+//   }
+// );
+
+eventEmitter.on(
+  'sendMotorStartNotification',
+  async (
+    fcmTokens,
+    blockName,
+    tankName,
+    motorOnType,
+    stopCriteria,
+    typeOfWater,
+    highThreshold // Add the high threshold as a parameter
+  ) => {
+    try {
+      // Get the latest timestamp
+      const currentDateTime = new Date();
+      const startTime = currentDateTime.toLocaleString('en-IN', { timeZone: 'Asia/Kolkata' });
+      const formattedDate = currentDateTime.toLocaleDateString('en-IN', { timeZone: 'Asia/Kolkata' });
+      const formattedTime = currentDateTime.toLocaleTimeString('en-IN', { timeZone: 'Asia/Kolkata' });
+
+      // Retrieve the user information
+      const users = await User.find({ fcmIds: { $in: fcmTokens } });
+      const userNames = users.map(user => user.username).join(', ');
+
+      // Determine the pump initiation method
+      const startMethod = motorOnType ===  "Forced Manual" ? "Physically" : "Manually"
+
+      // Dynamically generate the motor name
+      const motorName = `${tankName}-${blockName}-${typeOfWater}`;
+
+      // Determine the stop condition message
+      let stopConditionMessage = "";
+      if (stopCriteria === "manual") {
+        stopConditionMessage = `Will stop at Manually \n`;
+      } else if (stopCriteria === "highThreshold") {
+        stopConditionMessage = `🚨 Pump will stop when the water level reaches the high threshold of ${highThreshold}%.\n`;
+      }
+
+      // Prepare the notification message
+      const message =
+        `🚰 Motor Name: ${motorName}\n` +
+        `🛢️ Tank Name: '${tankName}'\n` +
+        `🏢 Block Name: '${blockName}'\n` +
+        `👤 Started by: ${userNames}\n` +
+        `📱 Mode: '${startMethod}'\n` +
+        `🕒 Pump started at: ${startTime} \n` +
+        stopConditionMessage; // Add only the relevant stop condition
+
+      // Send the notification
+      await sendNotification(fcmTokens, 'Motor Started 🚀', message);
+      console.log('Motor start notification with stop criteria sent successfully!');
+    } catch (error) {
+      console.error('Error in sendMotorStartNotification event:', error);
+    }
   }
-});
+);
 
-eventEmitter.on('sendMotorStopNotification', async (fcmTokens, message) => {
-  try {
-    await  sendNotification(fcmTokens, "Motor Stopped", message);
-    console.log("Manual method time notification sent successfully.");
-  } catch (error) {
-    console.error("Error sending thresmanual method time notification:", error);
+
+// eventEmitter.on(
+//   'sendMotorStartNotification',
+//   async (fcmTokens, motorId, waterLevel, blockName, tankName, motorOnType, stopCriteria, manual_threshold_time, typeOfWater) => {
+//     try {
+//       // Get the latest timestamp
+//       const currentDateTime = new Date();
+//       const startTime = currentDateTime.toLocaleString('en-IN', { timeZone: 'Asia/Kolkata' });
+//       const formattedDate = currentDateTime.toLocaleDateString('en-IN', { timeZone: 'Asia/Kolkata' });
+//       const formattedTime = currentDateTime.toLocaleTimeString('en-IN', { timeZone: 'Asia/Kolkata' });
+
+//       // Retrieve the user information
+//       const users = await User.find({ fcmIds: { $in: fcmTokens } });
+//       const userNames = users.map(user => user.username).join(', ');
+      
+//       // Determine the pump initiation method
+//       const startMethod = motorOnType === "Mobile APP" ? "Mobile APP" : "Manual";
+
+//       // Dynamically generate the motor name
+//       const motorName = `${tankName}-${blockName}-${typeOfWater}`;
+
+//       // Prepare the notification message
+//       const message =
+//         `🚰 Motor Name: '${motorName}'\n` +
+//         `🚰 Tank Name: '${tankName}'\n` +
+//         `🏢 Block Name: '${blockName}'\n` +
+//         `💧 Water Level: '${waterLevel}%'\n` +
+//         `👤 Initiated by: ${userNames}\n` +
+//         `📱 Pump started by: '${startMethod}'\n` +
+//         `🕒 Start Time: '${startTime}'\n` +
+//         `⏳ Will stop after: '${manual_threshold_time}' mins\n` +
+//         `📅 Date: '${formattedDate}'\n` +
+//         `⏰ Time: '${formattedTime}'`;
+
+//       // Send the notification
+//       await sendNotification(fcmTokens, 'Motor Started 🚀', message);
+//       console.log('Motor start notification sent successfully!');
+//     } catch (error) {
+//       console.error('Error in sendMotorStartNotification event:', error);
+//     }
+//   }
+// );
+
+
+// eventEmitter.on(
+//   'sendMotorStopNotification',
+//   async (fcmTokens, motorId, waterLevel, blockName, tankName, motorOnType) => {
+//     try {
+//       // Get the latest timestamp
+//       const stopTime = new Date().toLocaleString('en-IN', { timeZone: 'Asia/Kolkata' });
+
+//       // Retrieve the user information
+//       const users = await User.find({ fcmIds: { $in: fcmTokens } });
+//       const userNames = users.map(user => user.username).join(', ');
+//       const stopMethod = motorOnType.toUpperCase() === "Forced Manual";
+
+//       // Prepare the message
+//       const message =
+//         `🚰 Tank Name: '${tankName}'\n` +
+//         `🕒 Pump stopped at: '${stopTime}'\n` +
+//         `👤 Initiated by: ${userNames}\n` +
+//         `🔄 Pump stopped by: '${stopMethod}'\n`;
+
+//       // Send the notification
+//       await sendNotification(fcmTokens, 'Motor Stopped 🛑', message);
+//       console.log('Motor stop notification sent successfully!');
+//     } catch (error) {
+//       console.error('Error in sendMotorStopNotification event:', error);
+//     }
+//   }
+// );
+
+eventEmitter.on(
+  'sendMotorStopNotification',
+  async (
+    fcmTokens,
+    blockName,
+    tankName,
+    motorOnType,
+    typeOfWater
+  ) => {
+    try {
+      // Get the latest timestamp
+      const currentDateTime = new Date();
+      const stopTime = currentDateTime.toLocaleString('en-IN', { timeZone: 'Asia/Kolkata' });
+      const formattedDate = currentDateTime.toLocaleDateString('en-IN', { timeZone: 'Asia/Kolkata' });
+      const formattedTime = currentDateTime.toLocaleTimeString('en-IN', { timeZone: 'Asia/Kolkata' });
+
+      // Retrieve the user information
+      const users = await User.find({ fcmIds: { $in: fcmTokens } });
+      const userNames = users.map(user => user.username).join(', ');
+
+      // Determine the pump stop method
+      const stopMethod = motorOnType === "Forced Manual" ? "Physically" : "Manually";
+
+      // Dynamically generate the motor name
+      const motorName = `${tankName}-${blockName}-${typeOfWater}`;
+  // Determine the stop condition message
+        let stopConditionMessage = "";
+        if (stopCriteria === "manual") {
+          stopConditionMessage = `Stopped at Manually \n`;
+        } else if (stopCriteria === "highThreshold") {
+          stopConditionMessage = `🚨 Pump will stop when the water level reaches the high threshold of ${highThreshold}%.\n`;
+        }
+      // Prepare the notification message
+      const message =
+        `🚰 Motor Name: ${motorName}\n` +
+        `🛢️ Tank Name: '${tankName}'\n` +
+        `🏢 Block Name: '${blockName}'\n` +
+        `📱 Mode: '${stopMethod}'\n` +
+        `🕒 Pump stopped at: ${stopTime}\n` +
+        stopConditionMessage;
+
+      // Send the notification
+      await sendNotification(fcmTokens, 'Motor Stopped 🛑', message);
+      console.log('Motor stop notification sent successfully!');
+    } catch (error) {
+      console.error('Error in sendMotorStopNotification event:', error);
+    }
   }
+);
+
+eventEmitter.on('sendLowWaterNotification', (fcmTokens, message) => {
+  const notificationMessage = `Warning: Water level is low in the tank. 
+  Tank Name: ${tankName}, 
+  Location: ${receiverTank.location}, 
+  Type of Water: ${receiverTank.typeOfWater}, 
+  Current Water Level: ${currentWaterLevel} liters (${currentWaterPercentage.toFixed(2)}%), 
+  Date & Time: ${new Date().toLocaleString()}`;
+  
+  // Send notifications using the provided FCM tokens
+  sendNotification(fcmTokens, notificationMessage);
 });
 
+eventEmitter.on('sendCriticalLowWaterNotification', (fcmTokens, message) => {
+  const notificationMessage = `Critical Alert: Water level is critically low in the tank. 
+  Tank Name: ${tankName}, 
+  Location: ${receiverTank.location}, 
+  Type of Water: ${receiverTank.typeOfWater}, 
+  Current Water Level: ${currentWaterLevel} liters (${currentWaterPercentage.toFixed(2)}%), 
+  Date & Time: ${new Date().toLocaleString()}`;
+  
+  // Send notifications using the provided FCM tokens
+  sendNotification(fcmTokens, notificationMessage);
+});
+
+
+
+// eventEmitter.on('sendMotorStartNotification', async (fcmTokens, message) => {
+//   try {
+//     await  sendNotification(fcmTokens, "Motor Started", message);
+//     console.log("Manual method time notification sent successfully.");
+//   } catch (error) {
+//     console.error("Error sending thresmanual method time notification:", error);
+//   }
+// });
+
+// eventEmitter.on('sendMotorStopNotification', async (fcmTokens, message) => {
+//   try {
+//     await  sendNotification(fcmTokens, "Motor Stopped", message);
+//     console.log("Manual method time notification sent successfully.");
+//   } catch (error) {
+//     console.error("Error sending thresmanual method time notification:", error);
+//   }
+// });
+
 
 
 // Function to emit events with timestamps
@@ -1779,12 +2241,21 @@ const sendNotification = async (fcmIds, title, body) => {
           notification: { title, body },
           token,
           data: {
-            'target': '/route_navigation',  
+            'target': '/screen',  
           },
         });
         console.log(`Notification sent successfully to token: ${token}`, response);
       } catch (error) {
         console.error(`Failed to send notification to token: ${token}`, error);
+        // Check for specific error indicating an invalid token
+        if (error.code === 'messaging/registration-token-not-registered') {
+          // Remove the invalid token from the database
+          await User.updateOne(
+            { fcmIds: token }, // Ensure you're targeting the right user with the invalid token
+            { $pull: { fcmIds: token } } // Remove the invalid token
+          );
+          console.log(`Removed invalid token: ${token}`);
+        }
       }
     });
 
@@ -2136,71 +2607,90 @@ const notificationSentStatus = {
   criticallyHighWater: false,
 };
 
-const checkWaterLevelsAndNotify = async (customerId, tankName, tankLocation, fcmTokens) => {
-  try {
-    // Fetch the tank details from the database
-    const tank = await Tank.findOne({ customerId, tankName, tankLocation });
+let waterLevelCheckInterval; // To hold the interval ID
 
-    if (!tank) {
-      console.error(`Tank not found: ${tankName} at location ${tankLocation}`);
-      return;
-    }
+const checkWaterLevel = async (customerId, motorId, fcmToken, receiverTank) => {
+  const currentWaterLevel = parseInt(receiverTank.waterlevel, 10);
+  const tankCapacity = parseInt(receiverTank.capacity.replace(/,/g, ''), 10);
+  const currentWaterPercentage = (currentWaterLevel / tankCapacity) * 100;
 
-    // Extract the current water level and capacity
-    const currentWaterLevel = parseInt(tank.waterlevel, 10);
-    const capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);
-
-    // Calculate the water level percentage
-    const waterLevelPercentage = (currentWaterLevel / capacity) * 100;
-
-    // Thresholds for notifications
-    const thresholds = {
-      criticallyLow: 10,
-      veryLow: 20,
-      low: 30,
-      high: 70,
-      veryHigh: 80,
-      criticallyHigh: 85,
-    };
+  // Check for low water levels
+  if (currentWaterPercentage <= 20 && !notificationSentStatus.lowWater) {
+    eventEmitter.emit('sendLowWaterNotification', fcmToken, `Water level has dropped below 20%.`);
+    notificationSentStatus.lowWater = true; 
+  }
 
-    // Check water levels and send notifications
-    if (waterLevelPercentage <= thresholds.criticallyLow && !notificationSentStatus.criticallyLowWater) {
-      eventEmitter.emit('sendCriticalLowWaterNotification', fcmTokens, tank);
-      notificationSentStatus.criticallyLowWater = true;
-      await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentCritical: true } });
-    } else if (waterLevelPercentage <= thresholds.veryLow && !notificationSentStatus.veryLowWater) {
-      eventEmitter.emit('sendVeryLowWaterNotification', fcmTokens, tank);
-      notificationSentStatus.veryLowWater = true;
-      await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentVeryLow: true } });
-    } else if (waterLevelPercentage <= thresholds.low && !notificationSentStatus.lowWater) {
-      eventEmitter.emit('sendLowWaterNotification', fcmTokens, tank);
-      notificationSentStatus.lowWater = true;
-      await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentLow: true } });
-    }
-    // if (waterLevelPercentage <= thresholds.criticallyLow) {
-    //   eventEmitter.emit('sendCriticalLowWaterNotification', fcmTokens, tank);
-    //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentCritical: true } });
-    // } else if (waterLevelPercentage <= thresholds.veryLow) {
-    //   eventEmitter.emit('sendVeryLowWaterNotification', fcmTokens, tank);
-    //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentVeryLow: true } });
-    // } else if (waterLevelPercentage <= thresholds.low) {
-    //   eventEmitter.emit('sendLowWaterNotification', fcmTokens, tank);
-    //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentLow: true } });
-    // }
-    //  else if (waterLevelPercentage >= thresholds.criticallyHigh) {
-    //   eventEmitter.emit('sendCriticalHighWaterNotification', fcmTokens, tank);
-    //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentCriticalHigh: true } });
-    // } else if (waterLevelPercentage >= thresholds.veryHigh) {
-    //   eventEmitter.emit('sendVeryHighWaterNotification', fcmTokens, tank);
-    //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentVeryHigh: true } });
-    // } else if (waterLevelPercentage >= thresholds.high) {
-    //   eventEmitter.emit('sendHighWaterNotification', fcmTokens, tank);
-    //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentHigh: true } });
-    // }
-  } catch (error) {
-    console.error(`Error checking water levels for tank ${tankName}:`, error);
+  // Check for critically low water levels
+  if (currentWaterPercentage <= 10 && !notificationSentStatus.criticallyLowWater) {
+    eventEmitter.emit('sendCriticalLowWaterNotification', fcmToken, `Water level has dropped below 10%.`);
+    notificationSentStatus.criticallyLowWater = true; 
   }
 };
+// const checkWaterLevelsAndNotify = async (customerId, tankName, tankLocation, fcmTokens) => {
+//   try {
+//     // Fetch the tank details from the database
+//     const tank = await Tank.findOne({ customerId, tankName, tankLocation });
+
+//     if (!tank) {
+//       console.error(`Tank not found: ${tankName} at location ${tankLocation}`);
+//       return;
+//     }
+
+//     // Extract the current water level and capacity
+//     const currentWaterLevel = parseInt(tank.waterlevel, 10);
+//     const capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);
+
+//     // Calculate the water level percentage
+//     const waterLevelPercentage = (currentWaterLevel / capacity) * 100;
+
+//     // Thresholds for notifications
+//     const thresholds = {
+//       criticallyLow: 10,
+//       veryLow: 20,
+//       low: 30,
+//       high: 70,
+//       veryHigh: 80,
+//       criticallyHigh: 85,
+//     };
+
+//     // Check water levels and send notifications
+//     if (waterLevelPercentage <= thresholds.criticallyLow && !notificationSentStatus.criticallyLowWater) {
+//       eventEmitter.emit('sendCriticalLowWaterNotification', fcmTokens, tank);
+//       notificationSentStatus.criticallyLowWater = true;
+//       await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentCritical: true } });
+//     } else if (waterLevelPercentage <= thresholds.veryLow && !notificationSentStatus.veryLowWater) {
+//       eventEmitter.emit('sendVeryLowWaterNotification', fcmTokens, tank);
+//       notificationSentStatus.veryLowWater = true;
+//       await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentVeryLow: true } });
+//     } else if (waterLevelPercentage <= thresholds.low && !notificationSentStatus.lowWater) {
+//       eventEmitter.emit('sendLowWaterNotification', fcmTokens, tank);
+//       notificationSentStatus.lowWater = true;
+//       await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentLow: true } });
+//     }
+//     // if (waterLevelPercentage <= thresholds.criticallyLow) {
+//     //   eventEmitter.emit('sendCriticalLowWaterNotification', fcmTokens, tank);
+//     //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentCritical: true } });
+//     // } else if (waterLevelPercentage <= thresholds.veryLow) {
+//     //   eventEmitter.emit('sendVeryLowWaterNotification', fcmTokens, tank);
+//     //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentVeryLow: true } });
+//     // } else if (waterLevelPercentage <= thresholds.low) {
+//     //   eventEmitter.emit('sendLowWaterNotification', fcmTokens, tank);
+//     //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentLow: true } });
+//     // }
+//     //  else if (waterLevelPercentage >= thresholds.criticallyHigh) {
+//     //   eventEmitter.emit('sendCriticalHighWaterNotification', fcmTokens, tank);
+//     //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentCriticalHigh: true } });
+//     // } else if (waterLevelPercentage >= thresholds.veryHigh) {
+//     //   eventEmitter.emit('sendVeryHighWaterNotification', fcmTokens, tank);
+//     //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentVeryHigh: true } });
+//     // } else if (waterLevelPercentage >= thresholds.high) {
+//     //   eventEmitter.emit('sendHighWaterNotification', fcmTokens, tank);
+//     //   await Tank.updateOne({ customerId, tankName: tank.tankName }, { $set: { notificationSentHigh: true } });
+//     // }
+//   } catch (error) {
+//     console.error(`Error checking water levels for tank ${tankName}:`, error);
+//   }
+// };
 
 
 const monitorWaterLevels = async () => {
@@ -2223,7 +2713,7 @@ const monitorWaterLevels = async () => {
         const tankLocation = tank.tankLocation; // Assuming tank has a 'location' field
 
         // Call the function to check water levels and send notifications
-        await checkWaterLevelsAndNotify(customerId, tankName, tankLocation, fcmTokens);
+        //await checkWaterLevelsAndNotify(customerId, tankName, tankLocation, fcmTokens);
       } else {
         //console.log(`No FCM tokens found for customerId ${tank.customerId}`);
       }
@@ -2237,6 +2727,17 @@ const monitorWaterLevels = async () => {
 setInterval(monitorWaterLevels, 30 * 60 * 1000);
 
 const motorIntervals = {};
+async function calculateTotalPumpedWater(customerId, motorId, start_instance_id) {
+  const motorData = await MotorData.findOne({ customerId, motor_id: motorId, start_instance_id: start_instance_id });
+  if (motorData) {
+      const receiverTank = await Tank.findOne({ customerId, tankName: motorData.receiverTank, tankLocation: motorData.receiver_type.toLowerCase() });
+      const receiverFinalWaterLevel = parseInt(receiverTank.waterlevel, 10);
+      const quantityDelivered = receiverFinalWaterLevel - parseInt(motorData.receiverInitialwaterlevel, 10);
+      const waterPumpedTillNow = parseInt(receiverTank.total_water_added_from_midnight, 10);
+      return quantityDelivered + waterPumpedTillNow; // Total water pumped
+  }
+  return 0; // Return 0 if no data found
+}
 exports.motorAction = async (req, reply) => {
   try {
     const customerId = req.params.customerId;
@@ -2245,7 +2746,7 @@ exports.motorAction = async (req, reply) => {
     const start_instance_id = req.body.start_instance_id;
 
     // Define thresholds for water levels
-    const lowWaterThreshold = 20; // Low water level percentage threshold
+    const lowWaterThreshold = 5; // Low water level percentage threshold
     //const highWaterThreshold = 90; // High water level percentage threshold
     const highWaterThreshold = 70; // High water level percentage threshold
     const veryHighWaterThreshold = 80; // Very High water level percentage threshold
@@ -2263,14 +2764,15 @@ exports.motorAction = async (req, reply) => {
     console.log(receiverTank)
     const currentWaterLevel = parseInt(receiverTank.waterlevel, 10);
     const waterLevelThresholds = { low: 30, veryLow: 20, criticallyLow: 10 };
-
+    const typeOfWater = receiverTank.typeOfWater;
+    console.log(typeOfWater,"typeOfWater")
   
     // Determine the motor stop status based on the action
     let motorStopStatus;
     const blockName = req.body.from || "Unknown Block"; // Provide a fallback if `from` is missing
     const tankName = req.body.to || "Unknown Tank"; // Provide a fallback if `to` is missing
     const stopTime = req.body.stopTime 
-    const motorOnType = req.body.motor_on_type || "APP";
+    const motorOnType = "manual";
    const  manual_threshold_time = req.body.manual_threshold_time;
    let hasNotifiedStart = false;
     let hasNotifiedStop = false;
@@ -2285,85 +2787,59 @@ exports.motorAction = async (req, reply) => {
       );
 
       const thresholdTimeMs = req.body.manual_threshold_time * 60 * 1000; // Convert minutes to milliseconds
-    const stopCriteria =
+      const stopCriteria =
         motorOnType === "time"
           ? `${req.body.manual_threshold_time} minutes`
           : `${req.body.manual_threshold_litres} litres`;
 
-          await checkWaterLevelsAndNotify(customerId, tankName, receiverTank.tankLocation, fcmToken);
-
-      // eventEmitter.emit(
-      //   "motorStart",
-      //   fcmToken,
-      //   new Date().toISOString(),
-      //   motorId,
-      //   currentWaterLevel,
-      //   blockName, // Block Name
-      //   tankName, // Tank Name
-      //   startTime,
-      //   motorOnType,
-      //   stopCriteria,
-      //  manual_threshold_time
-      // );
+          // await checkWaterLevelsAndNotify(customerId, tankName, receiverTank.tankLocation, fcmToken);
+  
       if (!notificationSentStatus.motorStart) {
         eventEmitter.emit(
-          "motorStart",
-          fcmToken,
-          new Date().toISOString(),
-          motorId,
-          currentWaterLevel,
-          blockName,
-          tankName,
-          startTime,
-          motorOnType,
-          manual_threshold_time
+          'motorStart', 
+          fcmToken, 
+          tankName, 
+          blockName, 
+          startTime, 
+          "Mobile APP", 
+          manual_threshold_time,
+          typeOfWater
         );
+       
         notificationSentStatus.motorStart = true; // Set flag to true to prevent duplicate notifications
+      }
+       // Start checking water level every 30 minutes
+       if (!waterLevelCheckInterval) {
+        waterLevelCheckInterval = setInterval(async () => {
+          await checkWaterLevel(customerId, motorId, fcmToken, receiverTank);
+        }, 30 * 60 * 1000); // 30 minutes
       }
       await Tank.updateOne(
         { customerId, "connections.inputConnections.motor_id": motorId },
         { $set: { "connections.inputConnections.$.motor_stop_status": "2",
         "connections.inputConnections.$.manual_threshold_time": manual_threshold_time,
         "connections.inputConnections.$.threshold_type": "time",
-        "connections.inputConnections.$.motor_on_type": motorOnType } }
+        "connections.inputConnections.$.motor_on_type": "manual" } }
       );
      
-      // await Tank.updateOne(
-      //   { customerId, "connections.inputConnections.motor_id": motorId },
-      //   {
-      //     $set: {
-      //       "connections.inputConnections.$.motor_stop_status": "2",
-      //       "connections.inputConnections.$.motor_on_type": "manual",
-      //     }
-      //   }
-      // );
-
-      
       reply.code(200).send({ message: "Motor started successfully." });
 
     } else if (action === "stop") {
       motorStopStatus = "1"; // If action is stop, set stop status to "1"
-     
       
-      await checkWaterLevelsAndNotify(customerId, tankName, receiverTank.tankLocation, fcmToken);
-
-      // eventEmitter.emit(
-      //   "motorStop",
-      //   fcmToken,
-      //   // motorId,
-      //   // currentWaterLevel,
-      //   // blockName,
-      //   tankName,
-      //   stopTime,
-      //   motorOnType
-      // );
       if (!notificationSentStatus.motorStop) {
+
+        // Emit motorStop event
+        const totalWaterPumped = await calculateTotalPumpedWater(customerId, motorId, start_instance_id); // A function to calculate total water pumped
         eventEmitter.emit(
-          "motorStop",
-          fcmToken,
-          tankName,
-          stopTime,
-          motorOnType
+            'motorStop', 
+            fcmToken,             
+            tankName,            
+            blockName,            
+            stopTime,             
+            "Mobile APP",               
+            totalWaterPumped, // Include total water pumped
+            typeOfWater           
         );
         notificationSentStatus.motorStop = true; // Set flag to true to prevent duplicate notifications
       }
@@ -2375,7 +2851,11 @@ exports.motorAction = async (req, reply) => {
             "connections.inputConnections.$.motor_on_type": motorOnType          }
         }
       );
-     
+     // Clear the interval when the motor is stopped
+     if (waterLevelCheckInterval) {
+      clearInterval(waterLevelCheckInterval);
+      waterLevelCheckInterval = null; // Reset the interval ID
+    }
     } else {
       throw new Error("Invalid action provided.");
     }
@@ -2408,10 +2888,11 @@ exports.motorAction = async (req, reply) => {
 
       // Perform stop operations in the background
       (async () => {
-        await delay(300000);
-
+        
+        console.log(start_instance_id,"start_instance_id",customerId,"customerId",motorId,"motorId")
         const motorData = await MotorData.findOne({ customerId, motor_id: motorId, start_instance_id: start_instance_id });
         if (motorData) {
+          console.log("entered if in stop")
           const receiverTank = await Tank.findOne({ customerId, tankName: motorData.receiverTank, tankLocation: motorData.receiver_type.toLowerCase() });
           const receiverFinalWaterLevel = parseInt(receiverTank.waterlevel, 10);
           const quantityDelivered = receiverFinalWaterLevel - parseInt(motorData.receiverInitialwaterlevel, 10);
@@ -2467,6 +2948,7 @@ exports.motorAction = async (req, reply) => {
         this.publishMotorStopStatus(motorId, motorStopStatus);
         for await (const tank of Tank.find({  "connections.inputConnections.motor_id": motorId })) {
           const index = tank.connections.inputConnections.findIndex(connection => connection.motor_id === motorId);
+          
           if (index !== -1) {
             await Tank.updateOne(
               { customerId, "connections.inputConnections.motor_id": motorId },
@@ -2493,12 +2975,12 @@ exports.motorAction = async (req, reply) => {
             console.log(thresholdTime,"thresholdTime")
             console.log("motor stopping because it entered this condition")
             // Emit the threshold time notification
-    eventEmitter.emit(
-      "sendThresholdTimeNotification",
-      fcmToken,
-      `Motor has reached its time threshold of ${req.body.manual_threshold_time} minutes and will stop.`
-    );
-
+    // eventEmitter.emit(
+    //   "sendThresholdTimeNotification",
+    //   fcmToken,
+    //   `Motor has reached its time threshold of ${req.body.manual_threshold_time} minutes and will stop.`
+    // );
+    const currentTime = moment().tz('Asia/Kolkata').format('DD-MMM-YYYY - HH:mm');
             await Tank.updateOne(
               { customerId, "connections.inputConnections.motor_id": motorId },
               { 
@@ -2507,7 +2989,8 @@ exports.motorAction = async (req, reply) => {
                   
                   "connections.inputConnections.$.threshold_type": null,
                   "connections.inputConnections.$.manual_threshold_time": null,
-                  "connections.inputConnections.$.manual_threshold_percentage": null
+                  "connections.inputConnections.$.manual_threshold_percentage": null,
+                  "connections.inputConnections.$.stopTime": currentTime,
                 }
               }
             );
@@ -2516,7 +2999,7 @@ exports.motorAction = async (req, reply) => {
             // clearInterval(motorIntervals[motorId]); // Clear interval
             // delete motorIntervals[motorId]; 
 
-            await checkWaterLevelsAndNotify(customerId, tankName, supplierTank.tankLocation, fcmToken);
+           // await checkWaterLevelsAndNotify(customerId, tankName, supplierTank.tankLocation, fcmToken);
             // if (currentWaterPercentage >= highWaterThreshold && !notificationSentStatus.highWater) {
             //   eventEmitter.emit('sendHighWaterNotification', fcmToken, `Water level has reached high levels.`);
             //   notificationSentStatus.highWater = true; // Set flag to true to prevent duplicate notifications
@@ -2535,9 +3018,12 @@ exports.motorAction = async (req, reply) => {
             delete motorIntervals[motorId]; // Remove from interval object
            
             this.publishMotorStopStatus(motorId, "1");
-            await delay(300000);
+            console.log(start_instance_id,"start_instance_id",customerId,"customerId",motorId,"motorId")
+          
             const motorData = await MotorData.findOne({ customerId, motor_id: motorId, start_instance_id: start_instance_id });
+            console.log(motorData,"motorData")
             if (motorData) {
+              console.log("got into if")
               const receiverTank = await Tank.findOne({ customerId, tankName: motorData.receiverTank, tankLocation: motorData.receiver_type.toLowerCase() });
               const receiverFinalWaterLevel = parseInt(receiverTank.waterlevel, 10);
               const quantityDelivered = receiverFinalWaterLevel - parseInt(motorData.receiverInitialwaterlevel, 10);
@@ -2553,7 +3039,7 @@ exports.motorAction = async (req, reply) => {
                 { customerId, motor_id: motorId, start_instance_id: start_instance_id },
                 {
                   $set: {
-                    stopTime: req.body.stopTime,
+                    stopTime: currentTime,
                     receiverfinalwaterlevel: receiverFinalWaterLevel.toString(),
                     quantity_delivered: quantityDelivered.toString()
                   }
@@ -3287,12 +3773,23 @@ const motorActionAuto = async (req, reply) => {
     const action = req.body.action;
     const motorId = req.body.motor_id;
     const motor_on_type = req.body.motor_on_type
+    const startTime = req.body.startTime;
+    const stopTime = req.body.stopTime;
+    const threshold = req.body.threshold || "unknown";
 
     if (!motorId) {
       throw new Error("Motor ID is required.");
     }
 
     let motorStopStatus;
+    const tank = await Tank.findOne({ customerId, "connections.inputConnections.motor_id": motorId });
+
+    if (!tank) {
+      throw new Error("Tank not found for the provided motor ID.");
+    }
+
+    const { tankName, blockName, typeOfWater, fcmTokens } = tank; // Extracting necessary details
+
 
     if (action === "start") {
       await Tank.updateOne(
@@ -3307,7 +3804,17 @@ const motorActionAuto = async (req, reply) => {
         }
       );
 
-     ;
+      eventEmitter.emit(
+        "motorStartAutomatic",
+        fcmTokens,
+        tankName,
+        blockName,
+        startTime,
+        "Automatic",
+        typeOfWater,
+        threshold
+      );
+     
     } 
 
     if (action === "stop") {
@@ -3321,6 +3828,21 @@ const motorActionAuto = async (req, reply) => {
           }
         }
       );
+
+      const currentDateTime = new Date();
+      const formattedDate = currentDateTime.toLocaleDateString();
+      const formattedTime = currentDateTime.toLocaleTimeString();
+
+      const stopMessage = 
+        `🚰 Motor Name: ${tankName}-${blockName}-${typeOfWater}\n` +
+        `🛢️ Tank Name: '${tankName}'\n` +
+        `🏢 Block Name: '${blockName}'\n` +
+        `🕒 Pump stopped at: ${stopTime}\n` +
+        `⏳ Operation Duration: ${threshold} `;
+
+      // Send stop notification
+      await sendNotification(fcmTokens, "Arminta Water Management", stopMessage);
+
     } 
 
  
@@ -4806,18 +5328,25 @@ exports.update_auto_mode = async (req, reply) => {
 exports.update_auto_percentage = async (req, reply) => {
   try {
     const customerId = req.params.customerId;
-    const { tankName,tankLocation, auto_min_percentage, auto_max_percentage } = req.body;
+    const { tankName, tankLocation, auto_min_percentage, auto_max_percentage, auto_mode_type } = req.body;
 
-    // Update inputConnections' auto_mode
-   
+    // Build the query filter
+    const filter = { customerId: customerId };
+    if (tankName !== "all") {
+      filter.tankName = tankName;
+    }
+    if (tankLocation) {
+      filter.tankLocation = tankLocation;
+    }
 
-    // Update auto_min_percentage and auto_max_percentage
-    await Tank.updateOne(
-      { customerId: customerId,tankLocation, tankName},
+    // Update auto_min_percentage, auto_max_percentage, and auto_mode_type
+    await Tank.updateMany(
+      filter,
       {
         $set: {
           "auto_min_percentage": auto_min_percentage,
-          "auto_max_percentage": auto_max_percentage
+          "auto_max_percentage": auto_max_percentage,
+          "auto_mode_type": auto_mode_type
         }
       }
     );
@@ -4829,6 +5358,7 @@ exports.update_auto_percentage = async (req, reply) => {
 };
 
 
+
 //storing water level for every 15 minutes
 
 const getFormattedISTTime = () => {
@@ -5056,7 +5586,6 @@ exports.getBlockData = async (req, reply) => {
 //   }
 // });
 
-
 const mqtt = require('mqtt');
 const client = mqtt.connect('mqtt://35.207.198.4:1883'); // Connect to MQTT broker
 
@@ -5167,15 +5696,45 @@ client.on('message', async (topic, message) => {
       const inputConnection = motorTank.connections.inputConnections.find(conn => conn.motor_id === hw_Id); // Updated variable name
       if (inputConnection) {
         inputConnection.motor_status = status; // Update motor status
+        
+        const tankName = motorTank.tankName;
+        console.log(tankName,"tankName")
         if (inputConnection.motor_stop_status === "1" && status === 2 && inputConnection.motor_on_type !== "forced_manual") {
+          
           const currentTime = moment().tz('Asia/Kolkata').format('DD-MMM-YYYY - HH:mm'); 
           inputConnection.motor_stop_status = "2";
           inputConnection.motor_on_type = "forced_manual";
           inputConnection.startTime = currentTime;
+             // Emit motor start notification with tankName
+          // eventEmitter.emit(
+          //   "sendMotorStartNotification",
+          //   fcmToken,        // FCM tokens
+          //   hw_Id,           // Motor ID
+          //   inputConnection.water_level || 0, // Water level
+          //   motorTank.blockName || "N/A",     // Block name
+          //   tankName,        // Tank name
+          //   inputConnection.motor_on_type,   // Motor on type
+          //   "threshold",     // Stop criteria
+          //   manual_threshold_time // Threshold time in mins
+          // );
+         
         }
         
         if (inputConnection.motor_stop_status === "2" && status === 1) {
           inputConnection.motor_stop_status = "1";
+          const currentTime = moment().tz('Asia/Kolkata').format('DD-MMM-YYYY - HH:mm'); 
+          inputConnection.stoptTime = currentTime;
+
+          // Emit motor stop notification with tankName
+          // eventEmitter.emit(
+          //   "sendMotorStopNotification",
+          //   fcmToken,        // FCM tokens
+          //   hw_Id,           // Motor ID
+          //   inputConnection.water_level || 0, // Water level
+          //   motorTank.blockName || "N/A",     // Block name
+          //   tankName,        // Tank name
+          //   inputConnection.motor_on_type    // Motor on type
+          // );
         }
         
         await motorTank.save(); // Save the updated tank
@@ -5425,13 +5984,160 @@ console.log("this is for testing autopush,line located in tankscontroller")
 
 
 
+// const calculateDailyConsumptionAndNotify = async () => {
+//   try {
+//     const today = moment().startOf("day");
+//     const yesterday = moment(today).subtract(1, "days");
+
+//     // Fetch all active users
+//     const activeUsers = await User.find({  });
+
+//     for (const user of activeUsers) {
+//       const { customerId, fcmIds } = user;
+
+//       // Fetch daily consumption for the customer
+//       const consumptions = await TankConsumptionOriginalSchema.find({
+//         customerId,
+//         time: {
+//           $gte: yesterday.format("DD-MMM-YYYY - HH:mm"),
+//           $lt: today.format("DD-MMM-YYYY - HH:mm"),
+//         },
+//       });
+
+//       // Calculate total consumption
+//       const totalConsumption = consumptions.reduce((total, record) => {
+//         return total + parseInt(record.consumption, 10);
+//       }, 0);
+
+//       // Prepare tank-wise consumption details
+//       const tankDetails = consumptions.map((record) => ({
+//         tankName: record.tankName,
+//         consumption: record.consumption,
+//       }));
+
+//       // Send notification
+//       const notificationTitle = "Daily Water Consumption Report";
+//       const notificationBody = `
+//         Total Consumption: ${totalConsumption} liters
+//         Tank Details: ${tankDetails
+//           .map((tank) => `${tank.tankName}: ${tank.consumption} liters`)
+//           .join(", ")}
+//       `;
+
+//       if (fcmIds && fcmIds.length > 0) {
+//         await sendNotification(fcmIds, notificationTitle, notificationBody);
+//       }
+//     }
+
+//     console.log("Daily consumption notifications sent successfully.");
+//   } catch (err) {
+//     console.error("Error sending daily consumption notifications:", err);
+//   }
+// };
+
+
+// cron.schedule("0 11:57 * * *", async () => {
+//   console.log("Starting daily consumption notification task...");
+//   await calculateDailyConsumptionAndNotify();
+// });
+
+// cron.schedule(
+//   "0 9 * * *",
+//   async () => {
+//     console.log("Starting daily consumption notification task...");
+//     await calculateDailyConsumptionAndNotify();
+//   },
+//   {
+//     timezone: "Asia/Kolkata", // Specify the timezone
+//   }
+// );
+
+// const calculateDailyConsumptionAndNotify = async () => {
+//   try {
+//     const today = moment().startOf("day");
+//     const yesterday = moment(today).subtract(1, "days");
+
+//     // Fetch all active users
+//     const activeUsers = await User.find({});
+
+//     for (const user of activeUsers) {
+//       const { customerId, fcmIds } = user;
+
+//       // Fetch daily consumption for the customer
+//       const consumptions = await TankConsumptionOriginalSchema.find({
+//         customerId,
+//         time: {
+//           $gte: yesterday.format("DD-MMM-YYYY - HH:mm"),
+//           $lt: today.format("DD-MMM-YYYY - HH:mm"),
+//         },
+//       });
+
+//       // Calculate total consumption by type of water and the water level percentage
+//       const consumptionSummary = consumptions.reduce((acc, record) => {
+//         const typeOfWater = record.typeOfWater; // Assuming this field exists
+//         const consumption = parseInt(record.consumption, 10);
+//         const waterLevel = parseInt(record.waterLevel, 10); // Assuming waterLevel is in percentage
+
+//         if (!acc[typeOfWater]) {
+//           acc[typeOfWater] = {
+//             totalConsumption: 0,
+//             tankDetails: [],
+//             totalWaterLevel: 0,
+//             count: 0,
+//           };
+//         }
+
+//         acc[typeOfWater].totalConsumption += consumption;
+//         acc[typeOfWater].totalWaterLevel += waterLevel;
+//         acc[typeOfWater].count += 1;
+//         acc[typeOfWater].tankDetails.push({
+//           tankName: record.tankName,
+//           consumption,
+//           waterLevel,
+//         });
+
+//         return acc;
+//       }, {});
+
+//       // Prepare notification body
+//       let notificationBody = "Daily Water Consumption Report:\n";
+//       for (const type in consumptionSummary) {
+//         const { totalConsumption, tankDetails, totalWaterLevel, count } = consumptionSummary[type];
+//         const averageWaterLevel = (totalWaterLevel / count).toFixed(2); // Calculate average water level
+//         console.log("averageWaterLevel",averageWaterLevel)
+//         console.log("totalConsumption",totalConsumption)
+
+//         notificationBody += `
+//         Type of Water: ${type}
+//         Total Consumption: ${totalConsumption} liters
+//         Average Water Level: ${averageWaterLevel}%
+//         `;
+//         console.log("noti---" ,notificationBody += `
+//         Type of Water: ${type}
+//         Total Consumption: ${totalConsumption} liters
+//         Average Water Level: ${averageWaterLevel}%
+//         `)
+//       }
+
+//       if (fcmIds && fcmIds.length > 0) {
+//         await sendNotification(fcmIds, "Daily Water Consumption Report", notificationBody);
+//       }
+//     }
+
+//     console.log("Daily consumption notifications sent successfully.");
+//   } catch (err) {
+//     console.error("Error sending daily consumption notifications:", err);
+//   }
+// };
+
+
 const calculateDailyConsumptionAndNotify = async () => {
   try {
     const today = moment().startOf("day");
     const yesterday = moment(today).subtract(1, "days");
 
     // Fetch all active users
-    const activeUsers = await User.find({  });
+    const activeUsers = await User.find({});
 
     for (const user of activeUsers) {
       const { customerId, fcmIds } = user;
@@ -5445,28 +6151,46 @@ const calculateDailyConsumptionAndNotify = async () => {
         },
       });
 
-      // Calculate total consumption
-      const totalConsumption = consumptions.reduce((total, record) => {
-        return total + parseInt(record.consumption, 10);
-      }, 0);
+      // Calculate total consumption and capacities based on water type
+      let totalBoreConsumption = 0;
+      let totalDrinkingConsumption = 0;
+      let totalBoreCapacity = 0;
+      let totalDrinkingCapacity = 0;
+
+      for (const record of consumptions) {
+        const typeOfWater = record.typeOfWater; // Assuming this field exists
+        const consumption = parseInt(record.consumption, 10);
+        const capacity = parseInt(record.capacity, 10); // Assuming capacity field exists
+
+        if (typeOfWater === "bore" || typeOfWater === "Bore Water") {
+          totalBoreConsumption += consumption;
+          totalBoreCapacity += capacity;
+        } else if (typeOfWater === "drinking" || typeOfWater === "Drinking Water") {
+          totalDrinkingConsumption += consumption;
+          totalDrinkingCapacity += capacity;
+        }
+      }
 
-      // Prepare tank-wise consumption details
-      const tankDetails = consumptions.map((record) => ({
-        tankName: record.tankName,
-        consumption: record.consumption,
-      }));
+      // Calculate percentages
+      const boreConsumptionPercentage = totalBoreCapacity
+        ? ((totalBoreConsumption / totalBoreCapacity) * 100).toFixed(2)
+        : 0;
+
+      const drinkingConsumptionPercentage = totalDrinkingCapacity
+        ? ((totalDrinkingConsumption / totalDrinkingCapacity) * 100).toFixed(2)
+        : 0;
 
-      // Send notification
-      const notificationTitle = "Daily Water Consumption Report";
-      const notificationBody = `
-        Total Consumption: ${totalConsumption} liters
-        Tank Details: ${tankDetails
-          .map((tank) => `${tank.tankName}: ${tank.consumption} liters`)
-          .join(", ")}
-      `;
+      // Prepare notification body
+      const reportDate = yesterday.format("DD-MMM-YYYY");
+      let notificationBody = `Daily Water Consumption Report for ${reportDate}:\n`;
+      notificationBody += `Total Bore Consumption: ${totalBoreConsumption} liters\n`;
+      notificationBody += `Bore Water Consumption Percentage: ${boreConsumptionPercentage}%\n`;
+      notificationBody += `Total Drinking Consumption: ${totalDrinkingConsumption} liters\n`;
+      notificationBody += `Drinking Water Consumption Percentage: ${drinkingConsumptionPercentage}%\n`;
 
+      // Send notification if FCM IDs are present
       if (fcmIds && fcmIds.length > 0) {
-        await sendNotification(fcmIds, notificationTitle, notificationBody);
+        await sendNotification(fcmIds, "Daily Water Consumption Report", notificationBody);
       }
     }
 
@@ -5476,13 +6200,7 @@ const calculateDailyConsumptionAndNotify = async () => {
   }
 };
 
-
-// cron.schedule("0 11:57 * * *", async () => {
-//   console.log("Starting daily consumption notification task...");
-//   await calculateDailyConsumptionAndNotify();
-// });
-
-
+// Schedule the cron job to run daily at 9 AM
 cron.schedule(
   "0 9 * * *",
   async () => {
@@ -5492,4 +6210,274 @@ cron.schedule(
   {
     timezone: "Asia/Kolkata", // Specify the timezone
   }
-);
\ No newline at end of file
+);
+
+
+const calculateConsumptionAndNotify = async () => {
+  try {
+    const now = moment(); // Current time
+    const sixHoursAgo = moment(now).subtract(6, 'hours').startOf('hour'); // 6 hours ago
+
+    // Fetch all active users
+    const activeUsers = await User.find({});
+
+    for (const user of activeUsers) {
+      const { customerId, fcmIds } = user;
+
+      // Fetch consumption records for the last 6 hours
+      const consumptions = await TankConsumptionOriginalSchema.find({
+        customerId,
+        time: {
+          $gte: sixHoursAgo.format("DD-MMM-YYYY - HH:mm"),
+          $lt: now.format("DD-MMM-YYYY - HH:mm"),
+        },
+      });
+
+      // Prepare notification body
+      let notificationBody = `Water Consumption Report (From ${sixHoursAgo.format(
+        "hh:mm A"
+      )} to ${now.format("hh:mm A")}):\n`;
+      const tankDetails = {};
+
+      // Aggregate consumption data by tank
+      for (const record of consumptions) {
+        const tankName = record.tankName; // Assuming this field exists
+        const tankLocation = record.tankLocation; // Assuming this field exists
+        const consumption = parseInt(record.consumption, 10); // Liters consumed
+        const typeOfWater = record.typeOfWater; // Type of water (e.g., bore, drinking)
+        const tankCapacity = parseInt(record.capacity, 10); // Tank capacity in liters
+
+        if (!tankDetails[tankName]) {
+          tankDetails[tankName] = {
+            tankLocation,
+            totalConsumption: 0,
+            typeOfWater,
+            tankCapacity,
+          };
+        }
+        tankDetails[tankName].totalConsumption += consumption;
+      }
+
+      // Format tank details for the notification
+      for (const tankName in tankDetails) {
+        const {
+          tankLocation,
+          totalConsumption,
+          typeOfWater,
+          tankCapacity,
+        } = tankDetails[tankName];
+        const consumptionPercentage = tankCapacity
+          ? ((totalConsumption / tankCapacity) * 100).toFixed(2)
+          : 0;
+
+        notificationBody += 
+        `Tank Name: ${tankName} \n`+
+        `Location: ${tankLocation} \n`+
+        `Total Consumption: ${totalConsumption} liters  ${consumptionPercentage}% \n`+
+        `Type of Water: ${typeOfWater}`;
+      }
+
+      // Send notification if FCM IDs are present
+      if (fcmIds && fcmIds.length > 0) {
+        await sendNotification(fcmIds, "Water Consumption Report", notificationBody);
+      }
+    }
+
+    console.log("Consumption notifications sent successfully.");
+  } catch (err) {
+    console.error("Error sending consumption notifications:", err);
+  }
+};
+
+
+
+const calculateWaterLevelAndNotify = async () => {
+  try {
+    const now = moment();
+    const sixHoursAgo = moment().subtract(6, "hours");
+
+    console.log(`Calculating water level between ${sixHoursAgo.format("HH:mm A")} and ${now.format("HH:mm A")}`);
+
+    const tanks = await Tank.find({});
+
+    for (const tank of tanks) {
+      const {
+        customerId,
+        tankName,
+        tankLocation,
+        typeOfWater,
+        capacity,
+        waterlevel,
+        waterlevel_at_midnight,
+      } = tank;
+
+      // ✅ Fix: Remove commas before parsing numbers
+      const tankCapacity = parseFloat(capacity.replace(/,/g, '')) || 0;
+      const currentWaterLevel = parseFloat(waterlevel.replace(/,/g, '')) || 0;
+      const midnightWaterLevel = parseFloat(waterlevel_at_midnight.replace(/,/g, '')) || 0;
+
+      if (tankCapacity === 0) {
+        console.log(`Skipping tank ${tankName} due to zero capacity`);
+        continue;
+      }
+
+      const currentWaterLevelPercentage = ((currentWaterLevel / tankCapacity) * 100).toFixed(2);
+      const waterUsedSinceMidnight = midnightWaterLevel - currentWaterLevel;
+      const waterUsedPercentageSinceMidnight = ((waterUsedSinceMidnight / tankCapacity) * 100).toFixed(2);
+
+      const user = await User.findOne({ customerId });
+      if (!user || !user.fcmIds || user.fcmIds.length === 0) {
+        console.log(`No FCM tokens for customer: ${customerId}`);
+        continue;
+      }
+
+      let notificationBody = 
+        `🛢️ Tank Name: ${tankName}\n` +
+        `🏢 Location: ${tankLocation}\n` +
+        `💧 Type of Water: ${typeOfWater}\n` +
+        `Current Water Level: ${currentWaterLevel} liters (${currentWaterLevelPercentage}%)\n`;
+
+      await sendNotification(user.fcmIds, "Water Level Update", notificationBody);
+    }
+
+    console.log("Water level notifications sent successfully.");
+  } catch (err) {
+    console.error("Error in water level calculation:", err);
+  }
+};
+
+// Schedule notifications at 6 AM, 12 PM, 6 PM, and 12 AM
+cron.schedule(
+  "0 6,12,18,0 * * *", // Cron expression for the required times
+  async () => {
+    console.log("Starting scheduled consumption notification task...");
+    //await calculateConsumptionAndNotify();
+    await calculateWaterLevelAndNotify();
+  },
+  {
+    timezone: "Asia/Kolkata", // Specify the timezone
+  }
+);
+
+// const updateStopTimeFormat = async () => {
+//   try {
+//     // Find records where stopTime is null or not in the required format
+//     const motorDataDocs = await MotorData.find();
+
+//     for (const doc of motorDataDocs) {
+//       // Parse and validate startTime
+//       const startTime = moment(doc.startTime, "DD-MMM-YYYY - HH:mm", true);
+//       if (!startTime.isValid()) {
+//         console.log(`Invalid startTime for record ID: ${doc._id}`);
+//         continue;
+//       }
+
+//       // Format startTime if it's not already formatted
+//       const formattedStartTime = startTime.format("DD-MMM-YYYY - HH:mm");
+
+//       // Check if stopTime is valid or calculate it
+//       let formattedStopTime = null;
+//       const stopTime = moment(doc.stopTime, "DD-MMM-YYYY - HH:mm", true);
+
+//       if (!stopTime.isValid()) {
+//         // Calculate stopTime by adding 30 minutes to startTime
+//         formattedStopTime = startTime.clone().add(30, "minutes").format("DD-MMM-YYYY - HH:mm");
+//       } else {
+//         // Format the existing stopTime
+//         formattedStopTime = stopTime.format("DD-MMM-YYYY - HH:mm");
+//       }
+
+//       // Update the document if startTime or stopTime is not correctly formatted
+//       if (doc.startTime !== formattedStartTime || doc.stopTime !== formattedStopTime) {
+//         await MotorData.updateOne(
+//           { _id: doc._id },
+//           {
+//             $set: {
+//               startTime: formattedStartTime,
+//               stopTime: formattedStopTime,
+//             },
+//           }
+//         );
+//         console.log(`Updated record ID: ${doc._id}`);
+//       }
+//     }
+
+//     console.log("StopTime format update completed.");
+//   } catch (err) {
+//     console.error("Error updating stopTime format:", err);
+//   }
+// };
+
+// // Call the function to update stopTime
+// updateStopTimeFormat();
+
+
+
+exports.updatetankstatus = async (req, reply) => {
+  try {
+    const { customerId } = req.params;
+    const { tankName, tankLocation, status } = req.body;
+
+    if (!["active", "inactive"].includes(status)) {
+      return reply.code(400).send({ message: "Invalid status value" });
+    }
+
+    // Find the main tank
+    const mainTank = await Tank.findOneAndUpdate(
+      { customerId, tankName, tankLocation },
+      { $set: { status } },
+      { new: true }
+    );
+
+    if (!mainTank) {
+      return reply.code(404).send({ message: "Tank not found" });
+    }
+
+    // Update status in related outputConnections tanks
+    await Tank.updateMany(
+      {
+        customerId,
+        "connections.outputConnections.outputConnections": tankName,
+      },
+      { $set: { "connections.outputConnections.$.status": status } }
+    );
+
+    // Update status in related inputConnections tanks
+    await Tank.updateMany(
+      {
+        customerId,
+        "connections.inputConnections.inputConnections": tankName,
+      },
+      { $set: { "connections.inputConnections.$.status": status } }
+    );
+
+    return reply.send({ message: "Tank status updated successfully" });
+  } catch (error) {
+    console.error("Error updating tank status:", error);
+    return reply.code(500).send({ message: "Internal Server Error" });
+  }
+};
+
+
+
+
+
+
+exports.listofactiveandinactivetankstatus = async (req, reply) => {
+  try {
+    const { customerId } = req.params;
+    const  status  = req.query.status.toLowerCase();
+
+    if (!["active", "inactive"].includes(status)) {
+      return reply.code(400).send({ message: "Invalid status value" });
+    }
+
+    // Find tanks based on customerId and status
+    const tanks = await Tank.find({ customerId, status });
+
+    return reply.send({ tanks });
+  } catch (error) {
+    console.error("Error fetching tank list:", error);
+    return reply.code(500).send({ message: "Internal Server Error" });
+  }
+};
\ No newline at end of file
diff --git a/src/routes/tanksRoute.js b/src/routes/tanksRoute.js
index c3df81c2..65115aa5 100644
--- a/src/routes/tanksRoute.js
+++ b/src/routes/tanksRoute.js
@@ -821,13 +821,54 @@ module.exports = function (fastify, opts, next) {
         handler: tanksController.deletemotordatarecordsbefore7days,
       });
 
-      fastify.get("/api/getTankmotordata", {
+      // fastify.get("/api/getTankmotordata", {
+      //   schema: {
+      //     tags: ["Tank"],
+      //     description: "This is for Get Tank Motor Data",
+      //     summary: "This is for to Get Tank Motor Data",
+      //     querystring: {
+      //       customerId: {type: 'string'}
+      //     },
+      //     security: [
+      //       {
+      //         basicAuth: [],
+      //       },
+      //     ],
+      //   },
+      //   preHandler: fastify.auth([fastify.authenticate]),
+      //   handler: tanksController.getTankmotordata,
+      // });
+
+
+
+      fastify.route({
+        method: "PUT",
+        url: "/api/getTankmotordata/:customerId",
         schema: {
           tags: ["Tank"],
-          description: "This is for Get Tank Motor Data",
-          summary: "This is for to Get Tank Motor Data",
-          querystring: {
-            customerId: {type: 'string'}
+          summary: "This is for Get Tank Motor Data",
+          params: {
+            required: ["customerId"],
+            type: "object",
+            properties: {
+              customerId: {
+                type: "string",
+                description: "customerId",
+              },
+            },
+          },
+         
+          body: {
+            type: "object",
+            // required: ['phone'],
+            properties: {
+              startDate:{ type: "string" },
+              stopDate:{type:"string"},
+              block:{type:"string"},
+           
+               
+               
+            },
           },
           security: [
             {
@@ -835,7 +876,7 @@ module.exports = function (fastify, opts, next) {
             },
           ],
         },
-        preHandler: fastify.auth([fastify.authenticate]),
+        //preHandler: fastify.auth([fastify.authenticate]),
         handler: tanksController.getTankmotordata,
       });
 
@@ -843,6 +884,7 @@ module.exports = function (fastify, opts, next) {
 
 
 
+
       fastify.post('/api/motor/write', {
         schema: {
           tags: ["Tank"],
@@ -1070,6 +1112,7 @@ module.exports = function (fastify, opts, next) {
                   auto_min_percentage: { type: "string", default: null },
                   auto_max_percentage: { type: "string", default: null },
                   tankLocation: { type: "string", default: null },
+                  auto_mode_type: { type: "string", default: "default" },
                  
                 },
               },
@@ -1188,6 +1231,70 @@ module.exports = function (fastify, opts, next) {
           });
           
 
+          fastify.route({
+            method: "PUT",
+            url: "/api/updatetankstatus/:customerId",
+            schema: {
+              tags: ["Tank"],
+              summary: "This is for updating tank status to active or inactive",
+              params: {
+                required: ["customerId"],
+                type: "object",
+                properties: {
+                  customerId: {
+                    type: "string",
+                    description: "customerId",
+                  },
+                },
+              },
+             
+              body: {
+                type: "object",
+                // required: ['phone'],
+                properties: {
+                  tankName:{ type: "string" },
+                  tankLocation:{type:"string"},
+                  status:{type:"string"},
+                
+                   
+                },
+              },
+              security: [
+                {
+                  basicAuth: [],
+                },
+              ],
+            },
+            //preHandler: fastify.auth([fastify.authenticate]),
+            handler: tanksController.updatetankstatus,
+          });
+
+
+          fastify.route({
+            method: "GET",
+            url: "/api/listofactiveandinactivetankstatus/:customerId",
+            schema: {
+              tags: ["Tank"],
+              summary: "Get list of active or inactive tanks",
+              params: {
+                required: ["customerId"],
+                type: "object",
+                properties: {
+                  customerId: { type: "string", description: "Customer ID" },
+                },
+              },
+              querystring: {
+                type: "object",
+                properties: {
+                  status: { type: "string"},
+                },
+              },
+              security: [{ basicAuth: [] }],
+            },
+            handler: tanksController.listofactiveandinactivetankstatus,
+          });
+          
+
     next();
 }