//const Tank = require("../models/tanks");
const { Tank, MotorData } = require('../models/tanks')

const User = require("../models/User");
const boom = require("boom");
const fastify = require("fastify")({
  logger: true,
});
const tanksController = require("./tanksController")






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

    var customerId = req.params.customerId
    //const username = req.params.username;

console.log(req.params);
    //const  {username}  = loginObject.user.username;
    //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);
    tankData = {
      customerId: customerId,
      tankName: req.body.tankName,
      blockName: req.body.blockName,
      capacity: req.body.capacity,
      typeOfWater: req.body.typeOfWater,
   
      tankLocation:(req.body.tankLocation).toLowerCase(),
    };
    
    var tank_name = req.body.tankName
    var tankLocation = req.body.tankLocation
    var i_tank = await Tank.findOne({ tankName: tank_name,customerId:customerId,tankLocation:tankLocation})
    if(i_tank){
    throw new Error('tankname already exists');
            }
  else {

    var tank = new Tank(tankData);

    checkFormEncoding = isUserFormUrlEncoded(req);
    if (checkFormEncoding.isUserFormUrlEncoded) {
      usertobeInserted = checkFormEncoding.tank;
      console.log("thsi true url string");
      tank.customerId = usertobeInserted.customerId
      tank.tankName = usertobeInserted.tankName;
      tank.blockName = usertobeInserted.blockName;
      tank.capacity = usertobeInserted.capacity;
      tank.typeOfWater = usertobeInserted.typeOfWater;
    
      tank.tankLocation = (usertobeInserted.tankLocation).toLowerCase();
    }
  }
    const insertedTank = await tank.save();

    return insertedTank;
  

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


//update selected tank
exports.updateTanksInfo = async (req, reply) => {

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

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



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

//delete selected tank
exports.deleteTanksInfo = async (req, reply) => {
  try {
    var customerId = req.params.customerId;
    var tankName = req.query.tankName;
    const tank = await Tank.findOneAndDelete({ tankName: tankName,customerId:customerId });

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

//get tanks data by passing username
exports.getTank = async (req, reply) => {
  try {
    await Tank.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.getTanklevels = async (req, reply) => {
//  try {
 // const customerId = req.params.customerId;
//  const tankName = req.query.tankName;

//  setInterval(async function () {
 //   const randomNumber = Math.floor(Math.random() * (5500 - 1000) + 1000);
//    console.log(randomNumber)
//   console.log( await Tank.findOneAndUpdate({ customerId: customerId, tankName: tankName }, { $set: { waterlevel: randomNumber } }));
//  }, 2000);

//  return { message: 'Water level will be updated every 2 seconds' };
//}

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

exports.updateTanklevels = async (req, reply) => {
  try {
    const customerId = req.params.customerId;
    const tanks = await Tank.find({ customerId });

    const intervals = {};

    for (const tank of tanks) {
      const tankId = tank._id;
      let capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);
      let waterLevel = capacity - 100; // initial water level

      const intervalId = setInterval(async function () {
        const newWaterLevel = Math.floor(waterLevel - 200);
        
        if (newWaterLevel <= 0) {
          clearInterval(intervals[tankId]);
          console.log(`Stopped updating tank with ID ${tankId}`);
          return;
        }
        else{
        const result = await Tank.findOneAndUpdate(
          { _id: tankId },
          { $set: { waterlevel: newWaterLevel } }
        );
      }

       // console.log(result);

        

        waterLevel = newWaterLevel;
      }, 2000);

      intervals[tankId] = intervalId;
    }

    return { message: 'Water level updates started' };
  } catch (err) {
    throw boom.boomify(err);
  }
};



exports.updateTanklevels1 = async (req, reply) => {
    try {
      const customerId = req.params.customerId;
      const tanks = await Tank.find({ customerId });
  
      const intervals = {};
  
      for (const tank of tanks) {
        const tankName = tank.tankName;
        const tank_type = tank.tankLocation
        let capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);

        let waterLevel = capacity - 100; // initial water level
        const intervalId = setInterval(async function () {
          const newWaterLevel = Math.floor(waterLevel - 200);
            console.log(tank.tankName,newWaterLevel)
          const result = await Tank.findOneAndUpdate(
            { customerId, tankName, },
            { $set: { waterlevel: newWaterLevel } }
          );
  
         // console.log(result);
  
          if (newWaterLevel === 0) {
            clearInterval(intervals[tankName]);
            console.log(`Stopped updating ${tankName}`);
            return;
          }
  
          waterLevel = newWaterLevel;
        }, 2000);
  
        intervals[tankName] = intervalId;
      }
  
      return { message: 'Water level updates started' };
    } catch (err) {
      throw boom.boomify(err);
    }
  };
  

exports.getTanklevels = async (req, reply) => {
  try {
    const customerId = req.params.customerId;

   
    const updated_data = await Tank.find({ customerId: customerId });
  
    reply.send({ status_code: 200, data: updated_data});


  return { message: 'success' };
}

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





exports.motorAction = async (req, reply) => {
  try {
    //let start_time,stop_time
    const customerId = req.params.customerId;
    const action = req.body.action
    const receiver_tank = req.body.to
    const receiver_tank_info = await Tank.findOne({ customerId ,tankName:receiver_tank});
    const receiver_capacity = receiver_tank_info.capacity 
    const desired_water_percentage =  parseInt((req.body.percentage).replace(/,/g, ''), 10)
    
      
    if(action === "start"){
     // start_time = new Date().toLocaleString('en-US', {timeZone: 'Asia/Kolkata'})
      
      supplier_tank = req.body.from
      supplier_tank_type = req.body.from_type
      receiver_type = req.body.to_type
      console.log(supplier_tank)
      await Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { motor_status: 1 } });
      
    //  if(supplier_tank_type==="sump" && receiver_type === "overhead"){
    //    const supplier_tank_info1 = await Tank.findOne({ customerId ,tankName:supplier_tank});
    //    console.log(supplier_tank_info1)
    //     initial_update = parseInt(supplier_tank_info1.capacity.replace(/,/g, ''), 10)-200;
    //     await Tank.findOneAndUpdate({customerId, tankName: supplier_tank}, { $set: { waterlevel: initial_update } });
    //     const supplier_tank_info = await Tank.findOne({ customerId ,tankName:supplier_tank});

    //    // await changingfrom_tankwaterlevel(customerId,initial_update,supplier_tank_info);
    //     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 () {
    //       // Calculate new water levels
    //       const newWaterLevel = receiver_waterlevel  + 200//Math.floor(supplier_waterlevel  * 0.1);
    //       const newSupplierWaterLevel = supplier_waterlevel - 200//Math.floor(supplier_waterlevel  * 0.1);
    //       const supplier_capacity = parseInt(supplier_tank_info.capacity.replace(/,/g, ''), 10)
        
    //       // Check if updating should stop
    //       if ((newSupplierWaterLevel/supplier_capacity)*100 <= 5 || (newWaterLevel/receiver_capacity)*100 >= 95  || (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage) {
    //         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==="sump" && receiver_type === "overhead"){
        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 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)

          // Check if updating should stop
          if ( (newWaterLevel/receiver_capacity)*100 >= 95   ||  (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage ) {
            clearInterval(intervalId)
            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 = receiver_tank_info.capacity
          await Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { motor_status: 1 } });

         let receiver_waterlevel = parseInt(receiver_tank_info.waterlevel.replace(/,/g, ''), 10)
         intervalId = setInterval(async function () {
          // Calculate new water levels
          const newWaterLevel = receiver_waterlevel+200;
          // Check if updating should stop
          if ((newWaterLevel/receiver_capacity)*100 >= 97 || (newWaterLevel/receiver_capacity)*100 >= desired_water_percentage    ) {
            clearInterval(intervalId)
            await Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $set: { motor_status: 0 } });

            console.log("end");
          } else {
            // Update water levels in database
            
            receiver_waterlevel = newWaterLevel;
            
            console.log((newWaterLevel/receiver_capacity)*100)
            await Promise.all([
              Tank.findOneAndUpdate({customerId, tankName: receiver_tank}, { $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 });
    return motor_data



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

    }
    
    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}, { $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}`);

  };
};


 
exports.consumption = async (req, reply) => {
  try {
    const customerId = req.params.customerId;
    const tanks = await Tank.find({ customerId });
    const tankData = []; 
    for (const tank of tanks) {
      const tankId = tank._id;
      let capacity = parseInt(tank.capacity.replace(/,/g, ''), 10);
      let waterLevel = capacity*2+1700; // initial water level
      const tankname = tank.tankName

     
        const newWaterLevel = Math.floor(waterLevel);
        tankData.push({ tankname, waterLevel: newWaterLevel }); 

        
       // console.log(newWaterLevel);

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

    return { message: 'Water level updates started' };
  } catch (err) {
    throw boom.boomify(err);
  }
};