// import hashPassword from '../utils/hashPassword';
import crypto from "crypto";
import mongoose from "mongoose";
import SalesCoOrdinator from "./SalesCoOrdinatorModel.js";
import sendEmail, { sendOtp } from "../../Utils/sendEmail.js";
import validator from "validator";
import password from "secure-random-password";
import catchAsyncErrors from "../../middlewares/catchAsyncErrors.js";
import { generatePassword } from "../../Utils/generatepassword.js";
import XLSX from "xlsx";
import fs from "fs";
import path from "path";
export const uploadSalesCoordinators = async (req, res) => {
  try {
    if (!mongoose.Types.ObjectId.isValid(req.user._id)) {
      return res.status(400).json({ message: "Please login again" });
    }
    if (!req.files || !req.files.file) {
      return res.status(400).json({ message: "No file uploaded" });
    }

    const file = req.files.file;
    const filePath = path.join("public", "uploads", file.name);

    // Ensure 'uploads' directory exists
    if (!fs.existsSync(path.dirname(filePath))) {
      fs.mkdirSync(path.dirname(filePath), { recursive: true });
    }

    // Move the file from temp to the uploads directory
    await file.mv(filePath);

    // Process the file
    const fileBuffer = fs.readFileSync(filePath);
    const workbook = XLSX.read(fileBuffer, { type: "buffer" });
    const sheetName = workbook.SheetNames[0];
    const worksheet = workbook.Sheets[sheetName];
    const data = XLSX.utils.sheet_to_json(worksheet, { header: 1 });

    if (data.length <= 1) {
      return res
        .status(400)
        .json({ message: "Empty spreadsheet or no data found" });
    }

    const headers = data[0];

    // Map headers from the Excel file to your schema
    const headerMapping = {
      "Employee Code": "uniqueId",
      "Sales Coordinator Name": "name",
      Email: "email",
      "Phone Number": "mobileNumber",
    };

    const requiredHeaders = Object.keys(headerMapping);

    if (!requiredHeaders.every((header) => headers.includes(header))) {
      return res
        .status(400)
        .json({ message: "Missing required columns in spreadsheet" });
    }

    const errors = [];
    const newlyCreated = [];
    const updatedsalesCoordinators = [];

    for (let i = 1; i < data.length; i++) {
      const row = data[i];
      // Skip the row if it's completely empty
      if (row.every((cell) => cell === undefined || cell === "")) {
        continue;
      }
      const item = {};

      headers.forEach((header, index) => {
        if (headerMapping[header]) {
          item[headerMapping[header]] =
            row[index] !== undefined ? row[index] : "";
        }
      });

      // Initialize error tracking for each item
      const missingFields = new Set();
      const validationErrors = new Set();

      // Validate required fields
      if (!item.uniqueId) missingFields.add("Employee Code");
      if (!item.name) missingFields.add("name");
      if (!item.email) missingFields.add("email");
      if (!item.mobileNumber) missingFields.add("mobileNumber");

      // Check email validity
      if (item.email && !validator.isEmail(item.email)) {
        validationErrors.add("incorrect mail");
      }

      // Normalize the mobileNumber
      if (item.mobileNumber) {
        item.mobileNumber = item.mobileNumber.toString().trim();

        // Check if it already has +91
        if (item.mobileNumber.startsWith("+91")) {
          // If it has +91, remove it for validation
          const strippedNumber = item.mobileNumber.substring(3);

          // Validate that the remaining number is 10 digits
          if (/^\d{10}$/.test(strippedNumber)) {
            // Keep the mobile number with +91 for storage
            item.mobileNumber = `+91${strippedNumber}`;
          } else {
            validationErrors.add(
              "Invalid Mobile Number (should be 10 digits after +91)"
            );
          }
        } else {
          // If not prefixed with +91, check if it is exactly 10 digits
          if (/^\d{10}$/.test(item.mobileNumber)) {
            // Add +91 for storage
            item.mobileNumber = `+91${item.mobileNumber}`;
          } else {
            validationErrors.add("Invalid Mobile Number (should be 10 digits)");
          }
        }
      }

      // Combine all errors into a single message
      let errorMessage = "";
      if (missingFields.size > 0) {
        errorMessage += `Missing fields: ${Array.from(missingFields).join(
          ", "
        )}. `;
      }
      if (validationErrors.size > 0) {
        errorMessage += `Validation errors: ${Array.from(validationErrors).join(
          ", "
        )}.`;
      }

      // If there are errors, push them to the errors array
      if (errorMessage.trim()) {
        errors.push({
          uniqueId: item.uniqueId || "N/A",
          name: item.name || "N/A",
          email: item.email || "N/A",
          phone: item.mobileNumber || "N/A",
          message: errorMessage.trim(),
        });
        continue;
      }

      // Generate a password
      const password = generatePassword(item.name, item.email);

      // Check for existing user by uniqueId
      let salesCoordinatorByUniqueId = await SalesCoOrdinator.findOne({
        uniqueId: item.uniqueId,
      });

      // Search for sales coordinator by mobile number
      let salesCoordinatorByMobileNumber = await SalesCoOrdinator.findOne({
        $or: [
          { mobileNumber: item.mobileNumber }, // Check stored mobile number with +91
          { mobileNumber: item.mobileNumber.substring(3) }, // Check 10-digit number (remove +91)
        ],
      });

      // Case 1: Both uniqueId and mobileNumber exist
      if (salesCoordinatorByUniqueId && salesCoordinatorByMobileNumber) {
        if (
          salesCoordinatorByUniqueId._id.equals(
            salesCoordinatorByMobileNumber._id
          )
        ) {
          // Both match and are the same person, proceed to update
          let salescoordinatorUpdated = false;

          for (let field in item) {
            const currentValue = salesCoordinatorByUniqueId[field]?.toString();
            const newValue = item[field]?.toString();

            if (currentValue !== newValue) {
              salesCoordinatorByUniqueId[field] = item[field];
              salescoordinatorUpdated = true;
            }
          }

          if (salescoordinatorUpdated) {
            await salesCoordinatorByUniqueId.save();
            updatedsalesCoordinators.push({
              ...salesCoordinatorByUniqueId._doc,
              updatedFields: updatedFields.join(", "),
            });
          }
        } else {
          // Both exist but refer to different users
          errors.push({
            uniqueId: item.uniqueId,
            name: item.name,
            email: item.email,
            phone: item.mobileNumber,
            message: ` Employee Code (${salesCoordinatorByUniqueId.uniqueId}) is refer to (${salesCoordinatorByUniqueId.name}) and Mobile Number (${salesCoordinatorByMobileNumber.mobileNumber}) refer to (${salesCoordinatorByMobileNumber.name}) Sales Coordinator. Please provide the correct employee code or mobile number.`,
          });
        }
      } else if (salesCoordinatorByUniqueId) {
        // Case 2: uniqueId exists, but mobileNumber is new
        salesCoordinatorByUniqueId.mobileNumber = item.mobileNumber; // Update mobile number
        await salesCoordinatorByUniqueId.save();
        updatedsalesCoordinators.push({
          ...salesCoordinatorByUniqueId._doc,
          updatedFields: "mobileNumber",
        });
      } else if (salesCoordinatorByMobileNumber) {
        // Case 3: mobileNumber exists but uniqueId is new
        errors.push({
          uniqueId: item.uniqueId,
          name: item.name,
          email: item.email,
          phone: item.mobileNumber,
          message: `Mobile number already exists for ${salesCoordinatorByMobileNumber.name} user.`,
        });
      } else {
        // Case 4: Both uniqueId and mobileNumber are new, create a new salesCoordinator
        const salesCoordinator = new SalesCoOrdinator({
          ...item,
          password,
          isVerified: true,
        });
        await salesCoordinator.save();
        // Send email with the new password
        await sendEmail({
          to: `${item?.email}`, // Change to your recipient
          from: `${process.env.SEND_EMAIL_FROM}`, // Change to your verified sender
          subject: `Welcome to Cheminova - Account Created Successfully`,
          html: `
            <p>Dear ${item?.name},</p>
            <p>We are pleased to inform you that your Sales Coordinator account has been successfully created. Please find your account details below:</p>
            <p><strong>Name:</strong> ${item?.name}</p>
            <p><strong>Mobile Number:</strong> ${item?.mobileNumber}</p>
            <p><strong>Email:</strong> ${item.email}</p>
            <p><strong>Password:</strong> ${password}</p>
            <br/>
            <p>You can log in to your account using the following link:</p>
           
            <br/>
            <p>For convenience, you can also download our mobile app from the following links:</p>
            <ul>
              <li><a href="https://drive.google.com/file/d/1S8oJRz90LImcFBgMrqWZkWXDR79aBoot/view?usp=sharing
        " target="_blank" style="color: #0066cc; text-decoration: none;">Download Mobile Application</a></li>
            </ul>
            <br/>
            <p>If you have not requested this email or have any concerns, please contact our support team immediately.</p>
            <br/>
            <p>Best regards,</p>
            <p><strong>Cheminova Support Team</strong></p>
          `,
        });
        newlyCreated.push({ salesCoordinator });
      }
    }
    // Clean up uploaded file if any error occurs
    if (fs.existsSync(filePath)) {
      fs.unlinkSync(filePath);
    }
    res.status(200).json({
      message: "File processed successfully",
      newlyCreated,
      updatedsalesCoordinators,
      errors,
    });
  } catch (error) {
    console.error(error);
    // Clean up uploaded file if any error occurs
    if (fs.existsSync(filePath)) {
      fs.unlinkSync(filePath);
    }
    res.status(500).json({ message: "Internal Server Error" });
  }
};
export const register = async (req, res) => {
  let { name, email, countryCode, mobileNumber, territoryManager, uniqueId } =
    req.body;
  // console.log(req.body);
  countryCode = countryCode?.trim();
  mobileNumber = mobileNumber?.trim();
  const fullMobileNumber = `${countryCode}${mobileNumber}`;

  try {
    let salesCoordinator = await SalesCoOrdinator.findOne({
      uniqueId,
      mobileNumber: fullMobileNumber,
    });

    if (salesCoordinator && salesCoordinator.isVerified) {
      return res.status(400).json({
        message:
          "SalesCoordinator already registered and verified for this mobile number.",
      });
    }
    // const otp = crypto.randomInt(100000, 1000000).toString();
    const otp = "123456";
    const otpExpires = Date.now() + 1 * 60 * 1000;

    if (salesCoordinator) {
      salesCoordinator.otp = otp;
      salesCoordinator.otpExpires = otpExpires;
      salesCoordinator.mappedby = territoryManager;
    } else {
      salesCoordinator = new SalesCoOrdinator({
        name,
        email,
        mobileNumber: fullMobileNumber,
        otp,
        otpExpires,
        mappedby: territoryManager,
        uniqueId,
      });
    }
    await salesCoordinator.save();
    // await sendOtp(
    //   fullMobileNumber,
    //   Your Cheminova verification OTP is: ${otp}
    // );
    return res.status(200).json({
      message: `OTP sent to your mobile number ${fullMobileNumber} successfully`,
    });
  } catch (error) {
    res.status(500).json({
      message: error.message ? error.message : "Server error!",
    });
  }
};

export const verifyOtp = async (req, res) => {
  const { fullMobileNumber, otp } = req.body;

  try {
    let mobileNmr = fullMobileNumber?.trim();
    const salesCoordinator = await SalesCoOrdinator.findOne({
      mobileNumber: mobileNmr,
    });

    if (!salesCoordinator) {
      return res.status(400).json({ message: "Invalid mobile number or OTP" });
    }

    if (
      salesCoordinator.otp !== otp ||
      salesCoordinator.otpExpires < Date.now()
    ) {
      return res.status(400).json({ message: "Invalid or expired OTP" });
    }
    const name = salesCoordinator.name;
    const mobile = salesCoordinator.mobileNumber;
    salesCoordinator.isVerified = true;
    salesCoordinator.otp = undefined;
    salesCoordinator.otpExpires = undefined;

    // Generate a random password
    const newPassword = password.randomPassword({
      length: 12,
      characters: [
        { characters: password.upper, exactly: 1 },
        { characters: password.symbols, exactly: 1 },
        password.lower,
        password.digits,
      ],
    });

    // Save the new password (hashed)
    salesCoordinator.password = newPassword;
    await salesCoordinator.save();

    // Send email with the new password
    await sendEmail({
      to: `${salesCoordinator?.email}`, // Change to your recipient
      from: `${process.env.SEND_EMAIL_FROM}`, // Change to your verified sender
      subject: `Welcome to Cheminova - Account Created Successfully`,
  html: `
    <p>Dear ${name},</p>
    <p>We are pleased to inform you that your Sales Coordinator account has been successfully created. Please find your account details below:</p>
    <p><strong>Name:</strong> ${name}</p>
    <p><strong>Mobile Number:</strong> ${mobile}</p>
    <p><strong>Email:</strong> ${salesCoordinator.email}</p>
    <p><strong>Password:</strong> ${newPassword}</p>
    <br/>
    <p>You can log in to your account using the following link:</p>
   
    <br/>
    <p>For convenience, you can also download our mobile app from the following links:</p>
    <ul>
      <li><a href="https://drive.google.com/file/d/1S8oJRz90LImcFBgMrqWZkWXDR79aBoot/view?usp=sharing
" target="_blank" style="color: #0066cc; text-decoration: none;">Download Mobile Application</a></li>
    </ul>
    <br/>
    <p>If you have not requested this email or have any concerns, please contact our support team immediately.</p>
    <br/>
    <p>Best regards,</p>
    <p><strong>Cheminova Support Team</strong></p>
  `,
    });

    const token = salesCoordinator.getJWTToken();
    res.status(200).json({
      success: true,
      token,
      message: "Mobile number verified and new password sent successfully",
    });
  } catch (error) {
    res.status(500).json({
      message: error.message ? error.message : "Server error!",
    });
  }
};
// Login SalesCoOrdinator
export const loginSalesCoOrdinator = async (req, res) => {
  const { email, password } = req.body;

  try {
    if (!email || !password) {
      return res.status(400).json({ message: "Please Enter Email & Password" });
    }

    const salesCoordinator = await SalesCoOrdinator.findOne({ email }).select(
      "+password"
    );

    if (!salesCoordinator) {
      return res.status(400).json({ message: "Invalid Email or Password" });
    }

    const isPasswordMatched = await salesCoordinator.comparePassword(password);

    if (!isPasswordMatched) {
      return res.status(400).json({ message: "Invalid Email or Password" });
    }
    const token = salesCoordinator.getJWTToken();

    return res.status(200).json({
      success: true,
      token,
      message: "Login Successfully",
    });
  } catch (error) {
    return res.status(500).json({
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};
// Logout User
export const logout = catchAsyncErrors(async (req, res, next) => {
  res.cookie("token", null, {
    expires: new Date(Date.now()),
    httpOnly: true,
  });

  res.status(200).json({
    success: true,
    message: "Logged Out",
  });
});
//get All salescoordinator
export const getAllSalesCoOrdinator = async (req, res) => {
  try {
    const PAGE_SIZE = parseInt(req.query?.show || "10");
    const page = parseInt(req.query?.page || "1") - 1;
    if (!req.user || !req.user._id) {
      return res.status(401).json({
        success: false,
        message: "Please login to a TM account",
      });
    }
    let filter = {};
    if (req.query?.name) {
      filter.name = {
        $regex: new RegExp(req.query.name, "i"),
      };
    }
    if (req.query?.mobileNumber) {
      filter.mobileNumber = {
        $regex: new RegExp(req.query.mobileNumber, "i"),
      };
    }
    if (req.query?.isVerified) {
      filter.isVerified = req.query.isVerified === "true";
    }
    const total = await SalesCoOrdinator.countDocuments(filter);
    const salesCoOrinators = await SalesCoOrdinator.find(filter)
      .populate("mappedby", "name")
      .limit(PAGE_SIZE)
      .skip(PAGE_SIZE * page)
      .sort({ createdAt: -1 });

    return res.status(200).json({
      success: true,
      total_data: total,
      total_pages: Math.ceil(total / PAGE_SIZE),
      salesCoOrinators,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};
export const getAllSalesCoOrdinatorforTM_App = async (req, res) => {
  try {
    const PAGE_SIZE = parseInt(req.query?.show || "10");
    const page = parseInt(req.query?.page || "1") - 1;
    if (!req.user || !req.user._id) {
      return res.status(401).json({
        success: false,
        message: "Please login to a TM account",
      });
    }
    let filter = {};
    if (req.query?.name) {
      filter.name = {
        $regex: new RegExp(req.query.name, "i"),
      };
    }
    if (req.query?.mobileNumber) {
      filter.mobileNumber = {
        $regex: new RegExp(req.query.mobileNumber, "i"),
      };
    }
    if (req.query?.isVerified) {
      filter.isVerified = req.query.isVerified === "true";
    }
    // Mandatory filter for mappedby
    filter.mappedby = req.user._id;
    const total = await SalesCoOrdinator.countDocuments(filter);
    const salesCoOrinators = await SalesCoOrdinator.find(filter)
      .limit(PAGE_SIZE)
      .skip(PAGE_SIZE * page)
      .sort({ createdAt: -1 });

    return res.status(200).json({
      success: true,
      total_data: total,
      total_pages: Math.ceil(total / PAGE_SIZE),
      salesCoOrinators,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};
export const getAllSalesCoOrdinatorbytmId = async (req, res) => {
  try {
    const PAGE_SIZE = parseInt(req.query?.show || "10");
    const page = parseInt(req.query?.page || "1") - 1;
    let filter = { mappedby: req.params.id }; // Include the mappedby field in the filter

    // Adding optional filters
    if (req.query?.name) {
      filter.name = {
        $regex: new RegExp(req.query.name, "i"),
      };
    }
    if (req.query?.mobileNumber) {
      filter.mobileNumber = {
        $regex: new RegExp(req.query.mobileNumber, "i"),
      };
    }
    if (req.query?.isVerified) {
      filter.isVerified = req.query.isVerified === "true";
    }

    const total = await SalesCoOrdinator.countDocuments(filter);
    const salesCoOrinators = await SalesCoOrdinator.find(filter)
      .populate("mappedby", "name")
      .limit(PAGE_SIZE)
      .skip(PAGE_SIZE * page)
      .sort({ createdAt: -1 });

    return res.status(200).json({
      success: true,
      total_data: total,
      total_pages: Math.ceil(total / PAGE_SIZE),
      salesCoOrinators,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};
export const mappedbyTM = async (req, res) => {
  try {
    const { id } = req.params; // SalesCoOrdinator ID from URL parameters
    const { mappedby } = req.body; // TerritoryManager ID from request body
    // console.log(id, mappedby);
    // Validate that the TerritoryManager ID is provided
    if (!mappedby) {
      return res.status(400).json({
        success: false,
        message: "Territory Manager ID (mappedby) is required.",
      });
    }

    // Find the SalesCoOrdinator by ID
    const salesCoordinator = await SalesCoOrdinator.findById(id);

    // If no SalesCoOrdinator is found
    if (!salesCoordinator) {
      return res.status(404).json({
        success: false,
        message: "Sales Coordinator not found.",
      });
    }

    // Update the mappedby field
    salesCoordinator.mappedby = mappedby;

    // Save the updated SalesCoOrdinator
    await salesCoordinator.save();

    return res.status(200).json({
      success: true,
      message: "Sales Coordinator successfully updated.",
      salesCoordinator,
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};
export const unmapSalesCoOrdinator = async (req, res) => {
  try {
    if (!req.params.id) {
      return res.status(400).json({
        success: false,
        message: "Please provide SalesCoOrdinator ID!",
      });
    }

    const getSalesCoOrdinator = await SalesCoOrdinator.findById(req.params.id);
    if (!getSalesCoOrdinator) {
      return res.status(404).json({
        success: false,
        message: "Sales Coordinator not found!",
      });
    }

    // Set mappedby field to null
    getSalesCoOrdinator.mappedby = null;

    // Save the updated sales coordinator
    await getSalesCoOrdinator.save();

    res.status(200).json({
      success: true,
      message: "Sales Coordinator unmapped successfully!",
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};
export const getOneSalesCoOrdinator = async (req, res) => {
  try {
    if (!req.params.id) {
      return res
        .status(400)
        .json({ message: "Please provide sales coordinator ID" });
    }
    const salesCoordinator = await SalesCoOrdinator.findById(req.params.id);
    if (salesCoordinator) {
      return res.status(200).json({
        success: true,
        message: "Fetched successfully",
        data: salesCoordinator,
      });
    } else {
      return res.status(404).json({
        success: false,
        message: "Sales coordinator not found",
      });
    }
  } catch (error) {
    return res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};

// 4.Forgot Password

export const forgotPassword = async (req, res) => {
  const salescoordinator = await SalesCoOrdinator.findOne({
    email: req.body.email,
  });
  if (!req.body.email) {
    return res.status(400).json({ message: "please Enter Email!" });
  }
  if (!salescoordinator) {
    return res.status(404).json({ message: "SalesCoOrdinator not found" });
  }
  // Get ResetPassword Token
  // const resetToken = salescoordinator.getResetPasswordToken(); //call function

  //save database reset token
  // await salescoordinator.save({ validateBeforeSave: false });

  const passwords = password.randomPassword({
    length: 12,
    characters: [
      { characters: password.upper, exactly: 1 },
      { characters: password.symbols, exactly: 1 },
      password.lower,
      password.digits,
    ],
  });
  // console.log(passwords);
  salescoordinator.password = passwords;
  await salescoordinator.save();
  // const message = `Your password reset token are :- \n\n ${resetPasswordUrl} \n\nyour new password is:${password}\n\nIf you have not requested this email then, please ignore it.`;
  try {
    await sendEmail({
      to: `${salescoordinator?.email}`, // Change to your recipient

      from: `${process.env.SEND_EMAIL_FROM}`, // Change to your verified sender

      subject: `Cheminova Password Recovery`,
      html: `your new password is: <br/> <strong> ${passwords}</strong><br/><br/>If you have not requested this email then, please ignore it.`,
    });

    res.status(200).json({
      success: true,
      message: `Email sent to ${salescoordinator?.email} successfully`,
    });
  } catch (error) {
    salescoordinator.resetPasswordToken = undefined;
    salescoordinator.resetPasswordExpire = undefined;

    await salescoordinator.save({ validateBeforeSave: false });

    return res.status(500).json({
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};
export const ResetPassword = async (req, res) => {
  const id = req.params.id;
  // console.log(id);
  if (!id) {
    return res
      .status(400)
      .json({ message: "Invalid request. ID is required." });
  }

  try {
    const salescoordinator = await SalesCoOrdinator.findById(id);

    if (!salescoordinator) {
      return res.status(404).json({ message: "Sales Coordinator not found" });
    }

    // Generate a new random password
    const newPassword = password.randomPassword({
      length: 12,
      characters: [
        { characters: password.upper, exactly: 1 },
        { characters: password.symbols, exactly: 1 },
        password.lower,
        password.digits,
      ],
    });
    // console.log(newPassword);
    // Update the Sales Coordinator's password
    salescoordinator.password = newPassword;
    await salescoordinator.save();

    // Send email with the new credentials
    await sendEmail({
      to: `${salescoordinator.email}`, // Recipient email
      from: `${process.env.SEND_EMAIL_FROM}`, // Sender email
      subject: "Cheminova Account Credentials",
      html: `
    <p>Dear ${salescoordinator.name},</p>
    <p>Your Sales Coordinator account credentials have been updated. Please find your new login details below:</p>
    <p><strong>Email:</strong> ${salescoordinator.email}</p>
    <p><strong>Password:</strong> ${newPassword}</p>
    <p>Please use these credentials to log in to your account. For security reasons, it's recommended to change your password after logging in.</p>
    <br/>
    <p>To download our mobile app, use the following links:</p>
    <ul>
      <li><a href="https://drive.google.com/file/d/1S8oJRz90LImcFBgMrqWZkWXDR79aBoot/view?usp=sharing
" target="_blank">Download Mobile Application</a></li>
    </ul>
    <br/>
    <p>If you did not request this change, please contact our support team immediately.</p>
    <br/>
    <p>Best regards,</p>
    <p>Cheminova Support Team</p>
  `,
    });
    // console.log(salescoordinator);
    res.status(200).json({
      success: true,
      message: `Account credentials sent to ${salescoordinator.email} successfully.`,
    });
  } catch (error) {
    console.error("Error resetting password:", error);

    res.status(500).json({
      success: false,
      message:
        error.message || "Something went wrong while resetting the password.",
    });
  }
};
//Update mobile Number
export const updateMobileNumber = async (req, res) => {
  const { id } = req.params;
  const userId = id || req.user._id;
  let { newCountryCode, newMobileNumber } = req.body;
  newCountryCode = newCountryCode?.trim();
  newMobileNumber = newMobileNumber?.trim();
  const newFullMobileNumber = `${newCountryCode}${newMobileNumber}`;

  try {
    const salescoordinator = await SalesCoOrdinator.findById(userId);
    if (!salescoordinator) {
      return res.status(400).json({ message: "SalesCoOrdinator not found" });
    }
    if (salescoordinator.mobileNumber === newFullMobileNumber) {
      return res.status(400).json({
        message:
          "New mobile number cannot be the same as the old mobile number",
      });
    }
    // Check if the new mobile number already exists in another document
    const existingSalesCoordinator = await SalesCoOrdinator.findOne({
      mobileNumber: newFullMobileNumber,
    });

    if (existingSalesCoordinator) {
      return res.status(400).json({
        message: "Mobile number already registered and verified by someone",
      });
    }
    // const otp = crypto.randomInt(100000, 1000000).toString();
    const otp = "123456";
    const otpExpires = Date.now() + 3 * 60 * 1000; // 3 minutes

    salescoordinator.newMobileNumber = newFullMobileNumber;
    salescoordinator.otp = otp;
    salescoordinator.otpExpires = otpExpires;

    await salescoordinator.save();
    await sendOtp(
      newFullMobileNumber,
      `Your Cheminova verification OTP is: ${otp}`
    );

    return res.status(200).json({
      message: `OTP sent to your new mobile number ${newFullMobileNumber} successfully`,
    });
  } catch (error) {
    console.error("Error updating mobile number:", error);
    return res.status(500).json({
      message: error.message ? error.message : "Server error!",
    });
  }
};

//verify Updated Number OTP
export const verifyUpdatedMobileOtp = async (req, res) => {
  const { newMobileNumber, otp } = req.body;

  try {
    let mobileNmr = newMobileNumber?.trim();
    const salesCoordinator = await SalesCoOrdinator.findOne({
      newMobileNumber: mobileNmr,
    });

    if (!salesCoordinator) {
      return res.status(400).json({ message: "Invalid mobile number or OTP" });
    }

    if (
      salesCoordinator.otp !== otp ||
      salesCoordinator.otpExpires < Date.now()
    ) {
      return res.status(400).json({ message: "Invalid or expired OTP" });
    }

    // Update sales coordinator's mobile number and verification status
    salesCoordinator.mobileNumber = salesCoordinator.newMobileNumber;
    salesCoordinator.newMobileNumber = undefined;
    salesCoordinator.isVerified = true;
    salesCoordinator.otp = undefined;
    salesCoordinator.otpExpires = undefined;

    // Save changes to the database
    await salesCoordinator.save();

    const token = salesCoordinator.getJWTToken();
    return res.status(200).json({
      success: true,
      token,
      message: "Mobile number updated and verified successfully",
    });
  } catch (error) {
    console.error("Error verifying mobile OTP:", error);
    return res.status(500).json({
      message: error.message ? error.message : "Server error!",
    });
  }
};

//getmyProfile
export const getmyProfile = async (req, res) => {
  try {
    const myData = await SalesCoOrdinator.findById(req.user?._id);
    if (myData) {
      return res.status(200).json({
        success: true,
        message: "feched!",
        myData,
      });
    }
  } catch (error) {
    return res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};

//
export const deleteSalesCoOrdinator = async (req, res) => {
  try {
    if (!req.params.id) {
      return res.status(400).json({
        success: false,
        message: "Please Provide SalesCoOrdinator ID!",
      });
    }
    const getSalesCoOrdinator = await SalesCoOrdinator.findById(req.params.id);
    if (!getSalesCoOrdinator) {
      return res.status(404).json({
        success: false,
        message: "salescoordinator not Found!",
      });
    }

    //-------------------------//
    const salescoordinator = await SalesCoOrdinator.findByIdAndDelete(
      req.params.id
    );
    if (!salescoordinator) {
      return res.status(404).json({ message: "salescoordinator Not Found" });
    }
    await salescoordinator.remove();
    res.status(200).json({
      success: true,
      message: "salescoordinator Deleted Successfully!!",
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message ? error.message : "Something went wrong!",
    });
  }
};

export const UpdateProfile = async (req, res) => {
  const { name, email } = req.body;
  const { id } = req.params;
  const userId = id || req.user._id;
  // Validate email
  if (!validator.isEmail(email)) {
    return res.status(400).json({ message: "Invalid email address" });
  }

  try {
    const salesCoordinator = await SalesCoOrdinator.findById(userId); // Use the ID from params

    if (!salesCoordinator) {
      return res.status(404).json({ message: "SalesCoOrdinator not found" });
    }

    if (!salesCoordinator.isVerified) {
      return res.status(400).json({ message: "SalesCoOrdinator not verified" });
    }

    // Check if email is being changed and already exists
    if (email && email !== salesCoordinator.email) {
      const emailExists = await SalesCoOrdinator.findOne({ email });
      if (emailExists && emailExists._id.toString() !== userId) {
        return res.status(400).json({
          message:
            "This Email ID is already in use by another SalesCoOrdinator",
        });
      }
      salesCoordinator.email = email;
    }

    // Update name if provided
    if (name) {
      salesCoordinator.name = name;
    }

    // Save the updated salesCoordinator
    await salesCoordinator.save();

    return res.status(200).json({
      salesCoordinator,
      message: "Profile updated successfully",
    });
  } catch (error) {
    res.status(500).json({
      message: error.message ? error.message : "Server error!",
    });
  }
};

//change SalesCoOrdinator password
export const ChangePassword = async (req, res) => {
  const { id } = req.params; // Retrieve id from req.params
  const { oldPassword, newPassword, confirmPassword } = req.body;
  const userId = id || req.user._id; // Use the ID from the URL or from the authenticated user
  // console.log(userId);
  if (!oldPassword) {
    return res.status(400).json({ message: "Please Enter Old password" });
  }
  if (!newPassword) {
    return res.status(400).json({ message: "Please Enter New Password " });
  }
  if (!confirmPassword) {
    return res.status(400).json({ message: "Please Enter Confirm Password" });
  }
  try {
    const Salescoordinator = await SalesCoOrdinator.findById(userId).select(
      "+password"
    );

    if (!Salescoordinator) {
      return res.status(404).json({ message: "SalesCoOrdinator not found" });
    }

    const isPasswordMatched = await Salescoordinator.comparePassword(
      oldPassword
    );

    if (!isPasswordMatched) {
      return res.status(400).json({ message: "Old password is incorrect" });
    }

    if (newPassword !== confirmPassword) {
      return res
        .status(400)
        .json({ message: "New password and confirm Password do not match" });
    }

    Salescoordinator.password = newPassword;
    await Salescoordinator.save();

    return res
      .status(200)
      .json({ success: true, message: "Password updated successfully" });
  } catch (error) {
    console.error("Error updating password:", error);
    return res.status(500).json({
      message: error.message ? error.message : "Server error!",
    });
  }
};

export const Otp = async (req, res) => {
  // const { name, mobileNumber } = req.body;
  try {
    // let salescoordinator = await SalesCoOrdinator.findOne({ mobileNumber });

    // if (salescoordinator && salescoordinator.isVerified) {
    //   return res.status(400).json({ message: 'SalesCoOrdinator already registered and verified for This Mobile No.' });
    // }

    //      const otp = crypto.randomInt(100000, 1000000).toString();

    //     // const otp ="123456";

    // const otpExpires = Date.now() + 10 * 60 * 1000; // 10 minutes

    // if (salescoordinator) {
    //   salescoordinator.otp = otp;
    //   salescoordinator.otpExpires = otpExpires;
    // } else {
    //   salescoordinator = new SalesCoOrdinator({ name, mobileNumber, otp, otpExpires });
    // }

    // await salescoordinator.save();
    await sendOtp();

    // res.status(200).json({salescoordinator, message: `OTP  ${otp} sent to your  mobile number successfully` });
  } catch (error) {
    res.status(500).json({
      message: error.message ? error.message : "Server error!",
    });
  }
};