const { genSaltSync, hashSync, compareSync } = require("bcrypt")
const { sign } = require("jsonwebtoken")
const otpGenerator = require("otp-generator")
const nodemailer = require("nodemailer")
const bcrypt = require("bcrypt")
const { pool, db } = require("../config/database")
const fs = require("fs")
const path = require("path")
const generateRandomHash = require("../Functions/generateRandomHash")
const { execArgv, env } = require("process")
const {
  buildExtensionByFormCode,
} = require("../Functions/buildExtensionByFormCode")
const { exec } = require("child_process")
const { v4: uuidv4 } = require("uuid")
const multer = require("multer")
const { promisify } = require("util")
const readFileAsync = promisify(require("fs").readFile)

const transporter = nodemailer.createTransport({
  service: "gmail", // e.g., 'Gmail'
  host: process.env.NODEMAILER_HOST,
  port: process.env.NODEMAILER_PORT,
  secure: false,
  auth: {
    user: process.env.NODEMAILER_USER,
    pass: process.env.NODEMAILER_PASSWORD,
  },
})

async function dateAndTime() {
  var today = new Date()
  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time
  return dateTime
}

async function executeQuery(sql, values) {
  const connection = await db.getConnection()
  // console.log("connection..",connection);
  try {
    const [rows] = await connection.execute(sql, values)
    return rows
  } finally {
    connection.release()
  }
}

const login = async (req, res) => {
  const body = req.body

  pool.query(
    "SELECT * FROM sec_users WHERE email = ?",
    [body.email],
    (err, results) => {
      if (err) {
        console.error(err)
        return res.json({
          success: 0,
          data: "Error during login",
        })
      }

      if (!results || results.length === 0) {
        return res.json({
          success: 0,
          data: "Invalid email or password",
        })
      }

      const isValidPassword = compareSync(body.password, results[0].user_passw)

      if (isValidPassword) {
        // console.log(results[0].usr_grp)

        const jsontoken = sign(results[0], "secret", {
          algorithm: "HS256", // Use a shorter signing algorithm
          expiresIn: "5h", // Set a shorter expiration time if appropriate
        })

        return res.json({
          operationStatus: "SUCCESS",
          operationMessage: "Login Success",
          item: {
            token: jsontoken,
            userId: results[0].user_id,
            fullname: results[0].full_name,
            username: results[0].user_name,
            email: results[0].email,
            firstName: results[0].full_name,
            roles: ["ProjectManager", "Developer", "ROLE ADMIN"],
          },
        })
      } else {
        res.json({
          success: 0,
          data: "Invalid email or password",
        })
      }
    }
  )
}

// logout

const logout = (req, res) => {
  res.json({
    success: 1,
    message: "Logout successful",
  })
}

// reset password

const sendEmailForResetPassword = async (req, res) => {
  const userEmail = req.body.email
  // console.log(userEmail)
  try {
    const [userRows] = await executeQuery(
      "SELECT * FROM sec_users WHERE email = ?",
      [userEmail]
    )
    // console.log(userRows.email)
    const user = userRows

    if (user) {
      const email = user.email
      const subject = "Password Reset"
      const hash = generateRandomHash()
      const link =
        "http://" +
        process.env.LOCAL_HOST +
        ":" +
        process.env.FRONTEND_PORT_9191 +
        "/#/forgotresetpassword/" +
        hash

      // Store the reset token in the database
      const resetTokenData = {
        expiry_date: calculateExpiryDate(), // You need to implement a function to calculate the expiry date
        token: hash,
        user_user_id: user.user_id,
      }

      // Assuming you have a database model for password_reset_token
      await createPasswordResetToken(resetTokenData)

      // req.user.resetHash = hash

      const mailOptions = {
        from: process.env.NODEMAILER_USER,
        to: userEmail,
        subject: subject,
        text: `${link}`,
      }

      transporter.sendMail(mailOptions, (error) => {
        if (error) {
          console.log(error)
          return res.status(500).json({ message: "Error sending email" })
        }

        return res.status(200).json({ message: "Email sent successfully" })
      })
    } else {
      return res.status(400).json({ message: "User not found" })
    }
  } catch (error) {
    console.error(error)
    return res
      .status(500)
      .json({ message: "Error sending email for password reset" })
  }
}

const createPasswordResetToken = async (resetTokenData) => {
  try {
    // Obtain the maximum ID from the password_reset_token table
    const sql = `SELECT MAX(id) AS maxId FROM password_reset_token`
    const [record] = await executeQuery(sql)
    // console.log(record)

    // Increment the maxId by 1 to get the new primary key value
    const newId = record.maxId + 1

    // Insert the record into the password_reset_token table with the new ID
    const insertSql = `
      INSERT INTO password_reset_token (id, expiry_date, token, user_user_id)
      VALUES (?, ?, ?, ?)
    `

    const results = await executeQuery(insertSql, [
      newId,
      resetTokenData.expiry_date,
      resetTokenData.token,
      resetTokenData.user_user_id,
    ])

    return results
  } catch (error) {
    console.error(error)
    throw error
  }
}

// Function to calculate expiry date (you may customize this as per your requirements)
const calculateExpiryDate = () => {
  const expiryDate = new Date()
  expiryDate.setDate(expiryDate.getDate() + 1) // Set expiry date to 1 day from now
  return expiryDate
}

const savePassword = async (req, res) => {
  const token = req.params.token
  // console.log(token)
  const { newPassword, confirmPassword } = req.body

  try {
    // Fetch user by token from the database
    const [rows] = await executeQuery(
      "SELECT * FROM password_reset_token WHERE token = ?",
      [token]
    )

    if (rows.length === 0) {
      return res.status(400).json({ message: "Token expired" })
    }

    // console.log(rows)
    const user_id = rows.user_user_id

    // Fetch user by email from the database
    const [userRows] = await executeQuery(
      "SELECT * FROM sec_users WHERE user_id = ?",
      [user_id]
    )

    // console.log(userRows)

    if (userRows.length === 0) {
      return res.status(400).json({ message: "User not found" })
    }

    const a = userRows

    if (newPassword === confirmPassword) {
      // Update user password
      const hashedPassword = await bcrypt.hash(newPassword, 10)

      a.user_passw = hashedPassword
      a.pwd_changed_cnt = a.pwd_changed_cnt ? a.pwd_changed_cnt + 1 : 1
      a.last_pwd_changed_date = new Date()
      a.change_passw = newPassword

      // Fetch the maximum id from password_reset_token
      // const sql = `SELECT MAX(id) AS maxId FROM password_reset_token`
      // const [record] = await executeQuery(sql)
      // // console.log(record)

      // // Increment the maxId by 1 to get the new primary key value
      // const newId = record.maxId + 1

      // Save the updated user details to the database with the new id
      await executeQuery(
        "UPDATE sec_users SET user_passw = ?, pwd_changed_cnt = ?, last_pwd_changed_date = ?,  change_passw = ? WHERE user_id = ?",
        [
          a.user_passw,
          a.pwd_changed_cnt,
          a.last_pwd_changed_date,
          a.change_passw,
          a.user_id,
        ]
      )

      // Delete the password reset token
      await executeQuery("DELETE FROM password_reset_token WHERE token = ?", [
        token,
      ])

      return res.status(200).json(a)
    }

    return res
      .status(400)
      .json({ message: "Password and confirm password do not match" })
  } catch (error) {
    console.error(error)
    return res.status(500).json({ message: "Internal Server Error" })
  }
}

const resetPassword = async (req, res) => {
  try {
    const { oldPassword, newPassword, confirmPassword } = req.body

    console.log(oldPassword, newPassword, confirmPassword)

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

    const user = req.user
    // console.log(user)
    if (!user) {
      return res.status(400).json({ message: "User not found" })
    }

    // Validate old password
    const isValidOldPassword = compareSync(oldPassword, user.user_passw)

    if (!isValidOldPassword) {
      return res.status(400).json({ message: "Invalid old password" })
    }

    // Update the password in the database
    await updatePasswordAndUserData(user.user_id, newPassword)

    // Optionally, remove the hash from your local storage or mark it as used
    // removeHashFromStorage(hash);

    return res.status(200).json({ message: "Password reset successful" })
  } catch (error) {
    console.error(error)
    return res.status(500).json({ message: "Error resetting password" })
  }
}

// Update Password Controller

const updatePasswordAndUserData = async (userId, newPassword) => {
  return new Promise(async (resolve, reject) => {
    try {
      // Retrieve user details
      const [userRows] = await executeQuery(
        "SELECT * FROM sec_users WHERE user_id = ?",
        [userId]
      )

      if (userRows.length === 0) {
        reject({ message: "User not found" })
        return
      }

      // Hash the new password
      const hashedPassword = await bcrypt.hash(newPassword, 10)

      // Update user details
      const updatedUser = {
        user_passw: hashedPassword,
        pwd_changed_cnt: userRows.pwd_changed_cnt
          ? userRows.pwd_changed_cnt + 1
          : 1,
        last_pwd_changed_date: new Date(),
        change_passw: newPassword,
        user_id: userId,
      }

      // Update password and user data in a single query
      await executeQuery(
        "UPDATE sec_users SET user_passw = ?, pwd_changed_cnt = ?, last_pwd_changed_date = ?, change_passw = ? WHERE user_id = ?",
        [
          updatedUser.user_passw,
          updatedUser.pwd_changed_cnt,
          updatedUser.last_pwd_changed_date,
          updatedUser.change_passw,
          updatedUser.user_id,
        ]
      )

      resolve({ message: "Password updated successfully" })
    } catch (error) {
      console.error(error)
      reject({ message: "Internal Server Error" })
    }
  })
}

// Controllers for User grp maintenance

const getUsersUserGrpMaintenance = (req, res) => {
  //   pool.query(`SELECT * FROM sec_user_group`, [], (error, results, fields) => {
  //     if (error) {
  //       console.log(error)
  //       return res.json({
  //         success: 0,
  //         message: "Table is empty",
  //       })
  //     }
  //     return res.status(200).json(results)
  //   })
  // }

  pool.query(
    `SELECT * FROM sec_user_group`,
    [],
    (error, results, fields) => {
      if (error) {
        console.log(error);
        return res.json({
          success: 0,
          message: "Table is empty",
        });
      }

      // Map the results to the desired format
      const formattedResults = results.map((item) => {
        // Convert updatedate to a timestamp in milliseconds and a human-readable format
        const updatedateTimestamp = item.updatedate ? new Date(item.updatedate).getTime() : null;
        const updateDateFormated = item.updatedate
          ? new Date(item.updatedate).toLocaleString("en-GB", {
            day: "2-digit",
            month: "short",
            year: "numeric",
            hour: "2-digit",
            minute: "2-digit",
            second: "2-digit",
          })
          : null;

        // Re-map the fields
        return {
          usrGrp: item.usr_grp,
          groupName: item.group_name,
          groupDesc: item.group_desc,
          createby: item.createby,
          createdate: item.createdate,
          updatedate: updatedateTimestamp, // Converted to timestamp in milliseconds
          updateby: item.updateby,
          status: item.status,
          groupLevel: item.group_level,
          createDateFormated: item.createdate, // Keeping it as null or format if needed
          updateDateFormated: updateDateFormated, // Human-readable date format
        };
      });

      // Return the newly formatted result
      return res.status(200).json(formattedResults);
    }
  );
};


const getUsersByUserIdUserGrpMaintenance = (req, res) => {
  const id = req.params.id
  pool.query(
    `SELECT * FROM sec_user_group WHERE usr_grp = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Record not found",
        })
      }
      return res.status(200).json(results)
    }
  )
}

const updateUsersUserGrpMaintenance = (req, res) => {
  const body = req.body
  const id = req.params
  pool.query(
    `UPDATE INTO sec_user_group SET createby = ?, createdate = ?, group_desc = ?, group_level = ?, group_name = ?, status = ?, updateby = ? WHERE usr_grp = ?`,
    [
      body.createby,
      body.createdate,
      body.group_desc,
      body.group_level,
      body.password,
      body.group_name,
      body.status,
      body.updateby,
      id,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Failed to update user",
        })
      }
      return res.json({
        success: 1,
        data: "updated succesfully",
      })
    }
  )
}

const createUsersUserGrpMaintenance = (req, res) => {
  const body = req.body
  pool.query(
    `INSERT sec_user_group SET createby = ?,createdate = ?,group_desc = ?,group_level = ?,group_name = ?, status = ?, updateby = ? usr_grp = ?`,
    [
      body.createby,
      body.createdate,
      body.groupDesc,
      body.group_level,
      body.password,
      body.groupName,
      body.status,
      body.updateby,
      body.usrGrp,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Failed to update user",
        })
      }
      return res.json({
        success: 1,
        data: "updated succesfully",
      })
    }
  )
}

const deleteUsersUserGrpMaintenance = (req, res) => {
  const id = req.params.id
  pool.query(
    `delete from registration where id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      return res.json({
        success: 1,
        data: "user deleted succesfully",
      })
    }
  )
}

// Controllers for Menu maintainence

const getUsersMenuMaintainence = (req, res) => {
  pool.query(`SELECT * FROM sec_menu_det`, [], (error, results, fields) => {
    if (error) {
      console.log(error)
      return res.json({
        success: 0,
        message: "Table is empty",
      })
    }
    return res.status(200).json(results)
  })
}
const getUsersByUserIdMenuMaintainence = (req, res) => {
  const id = req.params.id;

  pool.query(
    `SELECT * FROM sec_grp_menu_access WHERE usr_grp = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error);
        return res.json({
          success: 0,
          message: "Table is empty",
        });
      }
      if (!results || results.length === 0) {
        return res.json({
          success: 0,
          message: "Record not found",
        });
      }

      // Map the results to the desired format
      const formattedResults = results.map((item) => {
        // Convert created_at and updated_at to timestamps in milliseconds
        const createdAtTimestamp = item.created_at ? new Date(item.created_at).getTime() : null;
        const updatedAtTimestamp = item.updated_at ? new Date(item.updated_at).getTime() : null;

        return {
          usrGrp: item.usr_grp,             // Adding usrGrp
          menuItemId: item.menu_item_id,  
          mexport: item.mexport,
          menuId: item.menu_id,
          createby: item.createby,
          createdAt: createdAtTimestamp, // Convert to timestamp
          updateby: item.updateby,
          updatedAt: updatedAtTimestamp, // Convert to timestamp
          isdisable: item.isdisable,
          itemSeq: item.item_seq,
          menuItemDesc: item.menu_item_desc,
          status: item.status,
          moduleName: item.module_name,
          main_menu_action_name: item.main_menu_action_name,
          main_menu_icon_name: item.main_menu_icon_name,
          subMenus: [], // Empty array as requested
          grpid: null, // Placeholder for grpid, assuming no equivalent field in the database
          gmenuid: null, // Placeholder for gmenuid, assuming no equivalent field in the database
          mcreate: item.m_create,
          mdelete: item.m_delete,
          mquery: item.m_query,
          mvisible: item.m_visible,
          medit: item.m_edit,
        };
      });

      return res.status(200).json(formattedResults);
    }
  );
};


const updateUsersMenuMaintainence = (req, res) => {
  const body = req.body
  const { id } = req.params
  var today = new Date()
  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time
  pool.query(
    `UPDATE sec_menu_det SET item_seq = ?, main_menu_action_name = ?, main_menu_icon_name = ?, menu_id = ?, menu_item_desc = ?, module_name = ?, status = ?, updated_at = ? WHERE menu_item_id = ?`,
    [
      body.itemSeq,
      body.main_menu_action_name,
      body.main_menu_icon_name,
      body.menuId,
      body.menuItemDesc,
      body.moduleName,
      body.status,
      dateTime,
      id,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Failed to update user",
        })
      }
      return res.json({
        success: 1,
        data: "updated succesfully",
      })
    }
  )
}

const createUsersMenuMaintainence = (req, res) => {
  const body = req.body
  var today = new Date()
  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time
  pool.query(
    `INSERT sec_menu_det SET menu_item_id = ?, item_seq = ?, main_menu_action_name = ?, main_menu_icon_name = ?, menu_id = ?, menu_item_desc = ?, module_name = ?, status = ?, created_at = ?, updated_at = ?`,
    [
      body.menuItemId,
      body.itemSeq,
      body.main_menu_action_name,
      body.main_menu_icon_name,
      body.menuId,
      body.menuItemDesc,
      body.moduleName,
      body.status,
      body.createdAt,
      dateTime,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Failed to create user",
        })
      }
      return res.json({
        success: 1,
        data: "created succesfully",
      })
    }
  )
}

const deleteUsersMenuMaintainence = (req, res) => {
  const id = req.params.id
  pool.query(
    `DELETE FROM sec_menu_det WHERE menu_item_id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      return res.json({
        success: 1,
        data: "user deleted succesfully",
      })
    }
  )
}

// Controller for Sub Menu maintainence

const getUsersSubMenuMaintainence = (req, res) => { }

// by rajeev
// const getUsersByIdSubMenuMaintainence = (req, res) => {
//   const id = req.params.id
//   pool.query(
//     `SELECT * FROM sec_menu_det WHERE menu_id = ? ORDER BY item_seq ASC`,
//     [id],
//     (error, results, fields) => {
//       if (error) {
//         console.log(error)
//         return res.json({
//           success: 0,
//           message: "Table is empty",
//         })
//       }
//       if (!results) {
//         return res.json({
//           success: 0,
//           message: "Record not found",
//         })
//       }
//       // console.log(results)
//       return res.status(200).json(results)
//     }
//   )
// }

// by Gk
const getUsersByIdSubMenuMaintainence = (req, res) => {
  const id = req.params.id;
  pool.query(
    `SELECT * FROM sec_menu_det WHERE menu_id = ? ORDER BY item_seq ASC`,
    [id],
    (error, results) => {
      if (error) {
        console.log(error);
        return res.json({
          success: 0,
          message: "Table is empty",
        });
      }
      if (!results || results.length === 0) {
        return res.json({
          success: 0,
          message: "Record not found",
        });
      }

      // Map the results to the desired format
      const formattedResults = results.map((item) => {
        return {
          createdAt: new Date(item.created_at).getTime(),
          updatedAt: new Date(item.updated_at).getTime(),
          menuItemId: item.menu_item_id,
          itemSeq: item.item_seq,
          menuItemDesc: item.menu_item_desc,
          status: item.status,
          menuId: item.menu_id,
          moduleName: item.module_name,
          main_menu_action_name: item.main_menu_action_name,
          main_menu_icon_name: item.main_menu_icon_name,
          subMenus: [], // Empty array as required
        };
      });

      return res.status(200).json(formattedResults);
    }
  );
};


const updateUsersSubMenuMaintainence = (req, res) => { }

const createUsersSubMenuMaintainence = (req, res) => { }

const deleteUsersSubMenuMaintainence = (req, res) => { }

// Controller for MENU ACCESS CONTROL

const getUsersMenuAccessControl = (req, res) => {
  pool.query(
    `SELECT * FROM sec_grp_menu_access`,
    [],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json(results)
    }
  )
}


const getUsersByMenuAccessControl = (req, res) => { }

const createUsersMenuAccessControl = async (req, res) => {
  const { id } = req.params
  const sql = `SELECT * FROM sec_menu_det WHERE menu_item_id = ?`
  const values = [id]

  try {
    const [record] = await executeQuery(sql, values)
    if (!record) {
      return res.status(404).json({ message: "Record not found" })
    }
    var today = new Date()
    var date =
      today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
    var time =
      today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
    var dateTime = date + " " + time

    const sqlIn = `INSERT INTO sec_grp_menu_access SET menu_item_id = ?, usr_grp = 41, created_at = ?, main_menu_action_name = ?, main_menu_icon_name = ?, menu_id = ?, menu_item_desc = ?, module_name = ?, status = ?, item_seq = ?, updated_at = ?, isdisable = 'true', m_create = 'true', m_delete = 'true', m_edit = 'true' , m_query = 'true', m_visible = 'true'`
    const valuesIn = [
      record.menu_item_id,
      record.created_at,
      record.main_menu_action_name,
      record.main_menu_icon_name,
      record.menu_id,
      record.menu_item_desc,
      record.module_name,
      record.status,
      record.item_seq,
      dateTime,
    ]
    try {
      const [recordIn] = await executeQuery(sqlIn, valuesIn)
    } catch (errorIn) {
      console.error("inside", errorIn)
    }
  } catch (error) {
    console.error(error)
    res.status(500).json({ message: "error fetching record Outside" })
  }
  return res.json({
    success: 1,
    data: "created succesfully",
  })
}

// Controller for User maintenance

const getUserMaintainence = (req, res) => {
  pool.query(`SELECT * FROM sec_users`, [], (error, results, fields) => {
    if (error) {
      console.log(error)
      return res.json({
        success: 0,
        message: "Table is empty",
      })
    }
    return res.status(200).json(results)
  })
}

const getByIdUserMaintainence = (req, res) => {
  const { id } = req.params
  pool.query(
    `SELECT * FROM sec_users WHERE user_id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json(results)
    }
  )
}

const getLoggedInUser = async (req, res) => {
  const user = req.user
  res.json(user)
}

const updateUserMaintainence = async (req, res) => {
  try {
    const updatedFields = {
      full_name: req.body.fullName || null,
      pronounce: req.body.pronounce || null,
      // role: req.body.role || null,
      // department: req.body.department || null,
      about: req.body.about || null,
      email: req.body.email || null, // Add email field
      // Add other fields to update as needed
    }

    // console.log(updatedFields)

    const user = req.user // Assuming req.user contains the user details, adjust accordingly

    // Filter out fields with null values
    const filteredFields = Object.fromEntries(
      Object.entries(updatedFields).filter(([_, value]) => value !== null)
    )

    // If no fields are provided for update, return a response
    if (Object.keys(filteredFields).length === 0) {
      return res.json({ success: 1, message: "No fields to update" })
    }

    // Construct the SQL query dynamically based on the provided filteredFields
    const updateFieldsSql = Object.keys(filteredFields)
      .map((key) => `${key} = ?`)
      .join(", ")

    // Add the user_id to the filteredFields
    filteredFields.user_id = user.user_id

    // Construct the parameters array for the query
    const queryParams = Object.values(filteredFields)

    // Update the specified non-null fields, including the updateDate, in sec_users
    await executeQuery(
      `UPDATE sec_users SET ${updateFieldsSql} WHERE user_id = ?`,
      queryParams
    )

    res.json({ success: 1, message: "User profile updated successfully" })
  } catch (error) {
    console.error(error)
    res.status(500).json({ success: 0, message: "Internal Server Error" })
  }
}

const uploadPath = path.join(process.cwd(), "uploaded-picture")

// Create the 'uploaded-picture' directory if it doesn't exist
if (!fs.existsSync(uploadPath)) {
  fs.mkdirSync(uploadPath)
}

const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, uploadPath)
  },
  filename: (req, file, cb) => {
    const userId = req.user.user_id
    const ext = path.extname(file.originalname)
    const fileName = `profile-pic-${userId}-${uuidv4()}${ext}`
    cb(null, fileName)
  },
})

const upload = multer({ storage: storage })

const uploadProfilePhoto = (req, res) => {
  try {
    const userId = req.user.user_id
    const usernameFolder = req.user.user_name

    const userFolderPath = path.join(
      process.cwd(),
      "uploaded-picture",
      usernameFolder
    )

    if (!fs.existsSync(userFolderPath)) {
      fs.mkdirSync(userFolderPath)
    }

    const currentDate = new Date()
      .toISOString()
      .replace(/:/g, "-")
      .substring(0, 19)
    const fileNewName = `profile-pic-${userId}-${currentDate}.png`
    const destinationPath = path.join(
      userFolderPath,
      fileNewName.replace(/ /g, "_")
    )

    const updateQuery = "UPDATE sec_users SET photo_name = ? WHERE user_id = ?"

    pool.query(updateQuery, [fileNewName, userId], (error, results) => {
      if (error) {
        console.error(error)
        return res
          .status(500)
          .json({ success: false, message: "Internal Server Error" })
      }

      // Use req.file.path to get the temporary path of the uploaded file
      // console.log(req)
      // console.log("Request body:", req.body) // Log the entire request body
      // console.log("Request file:", req.file.path) // Log the uploaded file information
      // fs.renameSync(req.file.path, destinationPath)
      fs.writeFileSync(destinationPath, req.file.buffer)

      res.json({
        success: true,
        message: "Profile picture uploaded successfully",
      })
    })
  } catch (error) {
    console.error(error)
    res.status(500).json({ success: false, message: "Internal Server Error" })
  }
}

const retrieveProfilePhoto = async (req, res) => {
  try {
    const userId = req.user.user_id.toString()
    const usernameFolder = req.user.user_name

    // Retrieve the file name from the database
    const selectQuery = "SELECT photo_name FROM sec_users WHERE user_id = ?"

    const [results] = await executeQuery(selectQuery, [userId])

    // console.log(results)

    if (results.length === 0 || !results.photo_name) {
      return res.status(404).json({
        success: false,
        message: "Profile picture not found. First try uploading one...!!",
      })
    }

    const fileName = results.photo_name
    const filePath = path.join(
      process.cwd(),
      "uploaded-picture",
      usernameFolder,
      fileName
    )

    const imageBuffer = await readFileAsync(filePath)

    // Convert the image buffer to a base64-encoded string
    const encodeBase64 = imageBuffer.toString("base64")
    const ext = path.extname(filePath).substring(1)

    // Construct the data URL
    const dataURL = `data:image/${ext};base64,${encodeBase64}`

    // Send the data URL as a JSON response
    res.json({
      success: true,
      message: "Profile picture retrieved successfully",
      image: dataURL,
    })
  } catch (error) {
    console.error(error)
    res.status(500).json({ success: false, message: "Internal Server Error" })
  }
}

const createUserMaintainence = (req, res) => {
  const body = req.body
  var today = new Date()
  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time
  pool.query(
    `INSERT sec_users SET user_id = ?, change_passw = ?, email = ?, full_name = ?, is_blocked = ?, mob_no = ?, user_passw = ?, user_name = ?, usr_grp_id = ?, account_id = ?, usr_grp = ?, createdate = ?`,
    [
      body.user_id,
      body.is_complete,
      body.change_passw,
      body.email,
      body.full_name,
      body.is_blocked,
      body.mob_no,
      body.user_passw,
      body.user_name,
      body.usr_grp_id,
      body.account_id,
      body.usr_grp,
      dateTime,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Failed to create user",
        })
      }
      return res.json({
        success: 1,
        data: "created succesfully",
      })
    }
  )
}

const deleteUserMaintainence = (req, res) => {
  const id = req.params.id
  pool.query(
    `DELETE FROM sec_menu_det WHERE menu_item_id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      return res.json({
        success: 1,
        data: "user deleted succesfully",
      })
    }
  )
}


// By Rajeev
// const loadMenuByUser = async (req, res) => {
//   try {
//     // Simulate getting the logged-in user's group (usrGrp)
//     const usrgrp = req.user.usr_grp // Replace this with your actual logic to get the user's group

//     // Find root menu items where menu_id is 0
//     let sql = `SELECT * FROM sec_grp_menu_access WHERE menu_id = 0 AND status= 'Enable' AND usr_grp = ${usrgrp} ORDER BY item_seq`
//     const root = await executeQuery(sql)

//     const renameFields = (obj) => {
//       const newObj = {}
//       for (const key in obj) {
//         switch (key) {
//           case "usr_grp":
//             newObj["usrGrp"] = obj[key]
//             break
//           case "menu_item_id":
//             newObj["menuItemId"] = obj[key]
//             break
//           case "item_seq":
//             newObj["itemSec"] = obj[key]
//             break
//           case "menu_id":
//             newObj["menuId"] = obj[key]
//             break
//           case "menu_item_desc":
//             newObj["menuItemDesc"] = obj[key]
//             break
//           case "m_create":
//             newObj["mcreate"] = obj[key]
//             break
//           case "m_delete":
//             newObj["mdelete"] = obj[key]
//             break
//           case "m_edit":
//             newObj["medit"] = obj[key]
//             break
//           case "m_query":
//             newObj["mquery"] = obj[key]
//             break
//           case "m_visible":
//             newObj["mvisible"] = obj[key]
//             break
//           default:
//             newObj[key] = obj[key]
//         }
//       }
//       return newObj
//     }

//     const renameSubmenuFields = (submenu) => {
//       const newSubmenu = {}
//       for (const key in submenu) {
//         switch (key) {
//           case "usr_grp":
//             newSubmenu["usrGrp"] = submenu[key]
//             break
//           case "menu_item_id":
//             newSubmenu["menuItemId"] = submenu[key]
//             break
//           case "item_seq":
//             newSubmenu["itemSec"] = submenu[key]
//             break
//           case "menu_id":
//             newSubmenu["menuId"] = submenu[key]
//             break
//           case "menu_item_desc":
//             newSubmenu["menuItemDesc"] = submenu[key]
//             break
//           case "m_create":
//             newSubmenu["mcreate"] = submenu[key]
//             break
//           case "m_delete":
//             newSubmenu["mdelete"] = submenu[key]
//             break
//           case "m_edit":
//             newSubmenu["medit"] = submenu[key]
//             break
//           case "m_query":
//             newSubmenu["mquery"] = submenu[key]
//             break
//           case "m_visible":
//             newSubmenu["mvisible"] = submenu[key]
//             break
//           default:
//             newSubmenu[key] = submenu[key]
//         }
//       }
//       return newSubmenu
//     }

//     // for (let i = 0; i < root.length; i++) {
//     //   const rootMenuItem = root[i]

//     //   // Find menu items by menu_id (rootMenuItemId) and usrGrp
//     //   let sql1 = `SELECT * FROM sec_grp_menu_access a WHERE a.usr_grp =${usrgrp} and a.menu_item_id=${rootMenuItem.menu_item_id}`
//     //   const menu = await executeQuery(sql1)

//     for (const menuItem of root) {
//       // Find all submenu items with status
//       let sql2 = `SELECT * FROM sec_grp_menu_access a where a.status= 'Enable' and a.menu_id=${menuItem.menu_item_id} and a.usr_grp =${usrgrp} ORDER BY item_seq`
//       const allSubmenu = await executeQuery(sql2)

//       for (const subMenus of allSubmenu) {
//         let sqlNew = `SELECT * FROM sec_user_group where usr_grp=${usrgrp}`
//         const sqlNewResult = await executeQuery(sqlNew)

//         let sqlMenuItemId = `SELECT * FROM sec_menu_det where menu_item_id=${menuItem.menu_item_id}`
//         const sqlMenuItemIdResult = await executeQuery(sqlMenuItemId)

//         subMenus.usrGrp = sqlNewResult[0]
//         subMenus.menuItemId = sqlMenuItemIdResult[0]
//       }

//       let sqlNew = `SELECT * FROM sec_user_group where usr_grp=${usrgrp}`
//       const sqlNewResult = await executeQuery(sqlNew)

//       let sqlMenuItemId = `SELECT * FROM sec_menu_det where menu_item_id=${menuItem.menu_item_id}`
//       const sqlMenuItemIdResult = await executeQuery(sqlMenuItemId)

//       menuItem.subMenus = allSubmenu.map(renameSubmenuFields)
//       menuItem.usrGrp = sqlNewResult[0]
//       // updatedUsrGrp = menuItem.usrGrp
//       // menuItem.usrGrp = updatedUsrGrp.map(renameSubmenuFields)
//       menuItem.menuItemId = sqlMenuItemIdResult[0]
//     }

//     // rootMenuItem.subMenus = menu
//     // }
//     for (let i = 0; i < root.length; i++) {
//       const rootMenuItem = root[i]
//       root[i] = renameFields(rootMenuItem)
//     }

//     res.status(200).json(root)
//     console.log(root);
//   } catch (error) {
//     console.error(error)
//     res.status(500).json({ message: "Internal server error" })
//   }
// }

// By Gk
const loadMenuByUser = async (req, res) => {
  try {
    const usrgrp = req.user.usr_grp; // Get the logged-in user's group

    // Batch query to fetch root menu items along with the necessary details
    const rootQuery = `
      SELECT 
        a.*, 
        b.group_name, 
        c.menu_item_desc AS menu_item_desc_det,
        c.main_menu_icon_name,
        c.main_menu_action_name

      FROM 
        sec_grp_menu_access a
      LEFT JOIN 
        sec_user_group b ON a.usr_grp = b.usr_grp
      LEFT JOIN 
        sec_menu_det c ON a.menu_item_id = c.menu_item_id
      WHERE 
        a.menu_id = 0 AND a.status = 'Enable' AND a.usr_grp = ?
      ORDER BY 
        a.item_seq;
    `;

    const root = await executeQuery(rootQuery, [usrgrp]);

    // Prepare a map of root menu items to fetch submenus in a single query
    const menuItemIds = root.map(item => item.menu_item_id);

    if (menuItemIds.length > 0) {
      const submenuQuery = `
        SELECT 
          a.*, 
          b.group_name, 
          c.menu_item_desc AS menu_item_desc_det,
          c.main_menu_icon_name,
          c.main_menu_action_name
        FROM 
          sec_grp_menu_access a
        LEFT JOIN 
          sec_user_group b ON a.usr_grp = b.usr_grp
        LEFT JOIN 
          sec_menu_det c ON a.menu_item_id = c.menu_item_id
        WHERE 
          a.status = 'Enable' 
          AND a.menu_id IN (${menuItemIds.join(',')})
          AND a.usr_grp = ?
        ORDER BY 
          a.item_seq;
      `;

      const submenus = await executeQuery(submenuQuery, [usrgrp]);

      // Organize submenus under their respective root menu items
      const submenuMap = {};
      submenus.forEach(submenu => {
        if (!submenuMap[submenu.menu_id]) {
          submenuMap[submenu.menu_id] = [];
        }
        submenuMap[submenu.menu_id].push(renameSubmenuFields(submenu));
      });

      // Assign submenus to their corresponding root menu items
      root.forEach(item => {
        item.subMenus = submenuMap[item.menu_item_id] || [];
      });
    } else {
      // If no root items, set subMenus to empty arrays
      root.forEach(item => {
        item.subMenus = [];
      });
    }

    // Rename fields for root menu items
    const formattedRoot = root.map(renameFields);

    res.status(200).json(formattedRoot);
    console.log(formattedRoot);
  } catch (error) {
    console.error(error);
    res.status(500).json({ message: "Internal server error" });
  }
};

const renameFields = (obj) => {
  return {
    usrGrp: obj.usr_grp,
    menuItemId: obj.menu_item_id,
    itemSec: obj.item_seq,
    menuId: obj.menu_id,
    menuItemDesc: obj.menu_item_desc,
    mcreate: obj.m_create,
    mdelete: obj.m_delete,
    medit: obj.m_edit,
    mquery: obj.m_query,
    mvisible: obj.m_visible,
    main_menu_action_name: obj.main_menu_action_name,
    main_menu_icon_name: obj.main_menu_icon_name,  // Include the main_menu_icon_name
    subMenus: obj.subMenus || []
  };
};

const renameSubmenuFields = (submenu) => {
  return {
    usrGrp: submenu.usr_grp,
    menuItemId: submenu.menu_item_id,
    itemSec: submenu.item_seq,
    menuId: submenu.menu_id,
    menuItemDesc: submenu.menu_item_desc,
    mcreate: submenu.m_create,
    mdelete: submenu.m_delete,
    medit: submenu.m_edit,
    mquery: submenu.m_query,
    mvisible: submenu.m_visible,
    main_menu_action_name: submenu.main_menu_action_name,
    main_menu_icon_name: submenu.main_menu_icon_name  // Include the main_menu_icon_name
  };
};




// Report


const createReport = async (req, res) => {
  const body = req.body
  try {
    const params = [body.reportName,
    body.description,
    body.active,
    body.isSql
    ]

    // Replace undefined with null in parameters
    const sanitizedParams = params.map((param) =>
      param !== undefined ? param : null
    )

    await executeQuery(
      `
      INSERT INTO rpt_builder2_t (report_name, description, active,is_sql)
      VALUES (?, ?, ?,?);
      `,
      sanitizedParams
    );


    return res.json({
      success: 1,
      content: "Report created successfully",
    })
  } catch (error) {
    console.error(error)
    return res.status(500).json({
      success: 0,
      message: "Error creating report",
      error: error.message,
    })
  }
}

const getAllReportBuilder = async (req, res) => {
  pool.query(
    `SELECT 
      r.id as reportId,
      r.report_name as reportName,
      r.description,
      r.active,
      l.id as lineId,
      l.header_id,
      l.model
    FROM rpt_builder2_t r
    LEFT JOIN rpt_builder2_lines_t l ON r.id = l.rpt_builder2_t_id`,
    [],
    (error, results, fields) => {
      if (error) {
        console.error("Error executing SQL query:", error)
        return res.status(500).json({
          success: 0,
          message: "Internal Server Error",
        })
      }

      if (results.length === 0) {
        return res.json({
          success: 0,
          message: "No data found",
        })
      }

      // console.log("Data retrieved successfully:", results)

      // Group results by report ID
      const groupedResults = results.reduce((acc, result) => {
        const existingReport = acc.find((item) => item.id === result.reportId)
        if (existingReport) {
          existingReport.rpt_builder2_lines.push({
            id: result.lineId,
            header_id: result.header_id,
            model: result.model,
          })
        } else {
          acc.push({
            id: result.reportId,
            reportName: result.reportName,
            description: result.description,
            active: result.active,
            rpt_builder2_lines: [
              {
                id: result.lineId,
                header_id: result.header_id,
                model: result.model,
              },
            ],
          })
        }
        return acc
      }, [])

      return res.status(200).json(groupedResults)
    }
  )
}

const getAllReportBuilderById = async (req, res) => {
  const id = req.params.id

  pool.query(
    `SELECT 
      r.id as reportId,
      r.report_name as reportName,
      r.description,
      r.active,
      l.id as lineId,
      l.header_id,
      l.model
    FROM rpt_builder2_t r
    LEFT JOIN rpt_builder2_lines_t l ON r.id = l.rpt_builder2_t_id
    WHERE r.id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.error("Error executing SQL query:", error)
        return res.status(500).json({
          success: 0,
          message: "Internal Server Error",
        })
      }

      if (results.length === 0) {
        return res.status(404).json({
          success: 0,
          message: "No data found for the given ID",
        })
      }

      // Group results by report ID
      const groupedResults = results.reduce((acc, result) => {
        const existingReport = acc.find((item) => item.id === result.reportId)
        if (existingReport) {
          existingReport.rpt_builder2_lines.push({
            id: result.lineId,
            header_id: result.header_id,
            model: result.model,
          })
        } else {
          acc.push({
            id: result.reportId,
            reportName: result.reportName,
            description: result.description,
            active: result.active,
            rpt_builder2_lines: [
              {
                id: result.lineId,
                header_id: result.header_id,
                model: result.model,
              },
            ],
          })
        }
        return acc
      }, [])

      return res.status(200).json(groupedResults)
    }
  )
}

const getAllReportBuilderByQuery = async (req, res) => {
  const query = req.params.query
  // console.log(query);
  pool.query(query, (error, results, fields) => {
    if (error) {
      console.log(error)
      return res.status(500).json({
        success: 0,
        message: "Error fetching data from the database",
      })
    }
    if (results.length === 0) {
      return res.status(404).json({
        success: 0,
        message: "No data found",
      })
    }
    return res.status(200).json(results)
  })
}

const updateReportBuilder = async (req, res) => {
  const id = req.params.id
  const body = req.body

  pool.query(
    `UPDATE rpt_builder2_t SET
      report_name = ?, 
      description = ?, 
      active = ?, 
      is_sql = ? 
      WHERE id = ?`,
    [body.report_name, body.description, body.active, body.is_sql, id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.status(500).json({
          success: 0,
          message: "Error updating record in the database",
        })
      }
      if (results.affectedRows === 0) {
        return res.status(404).json({
          success: 0,
          message: "Record not found",
        })
      }
      return res.status(200).json({
        success: 1,
        message: "Record updated successfully",
      })
    }
  )
}

const deleteReportBuilder = async (req, res) => {
  const id = req.params.id
  pool.query(
    `DELETE FROM rpt_builder2_t WHERE id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.status(500).json({
          success: 0,
          message: "Error deleting record from the database",
        })
      }
      if (results.affectedRows === 0) {
        return res.status(404).json({
          success: 0,
          message: "Record not found",
        })
      }
      return res.status(200).json({
        success: 1,
        message: "Record deleted successfully",
      })
    }
  )
}

// Report Line

const getReportLine = async (req, res) => {
  pool.query(
    `SELECT * FROM rpt_builder2_lines_t `,
    [],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json(results)
    }
  )
}

const getReportLineById = async (req, res) => {
  const id = req.params.id
  pool.query(
    `SELECT * FROM rpt_builder2_lines_t WHERE rpt_builder2_t_id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json(results)
    }
  )
}

const updateReportLine = async (req, res) => {
  const id = req.params.id
  const body = req.body

  pool.query(
    `UPDATE rpt_builder2_lines_t SET header_id = ?, model = ? WHERE rpt_builder2_t_id = ?`,
    [body.header_id, body.model, id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
      }
      if (!results) {
        return res.status(400).json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json({
        success: 1,
        message: "Record updated succesfully",
      })
    }
  )
}

// Dashboard

const getAllDashboard = async (req, res) => {

  pool.query(
    `SELECT 
      h.id,
      h.account_id,
      h.created_at AS createdAt,
      h.created_by AS createdBy,
      h.updated_at AS updatedAt,
      h.updated_by AS updatedBy,
      CAST(h.is_build AS UNSIGNED) AS build,
      CAST(h.testing AS UNSIGNED) AS testing,
      h.dashboard_name,
      h.module_id,
      h.description,
      h.menu_name,
      h.object_type,
      h.secuirity_profile,
      h.sub_object_type,
      h.tech_stack,
      h.is_updated,
      l.id AS lineId,
      l.created_at AS lineCreatedAt,
      l.created_by AS lineCreatedBy,
      l.updated_at AS lineUpdatedAt,
      l.updated_by AS lineUpdatedBy,
      l.account_id AS lineAccountId,
      l.header_id,
      l.model
    FROM dashbord_header h
    LEFT JOIN dashbord1_line l ON h.id = l.dashbord_header_id
    `,

    async (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Error fetching data from the database",
        })
      }

      // If there are no results, return an empty array
      if (results.length === 0) {
        return res.status(200).json([])
      }

      // Organize the data into the desired structure
      const dashboards = results.map((dashboardHeader) => {
        return {
          createdAt: dashboardHeader.createdAt,
          createdBy: dashboardHeader.createdBy,
          updatedBy: dashboardHeader.updatedBy,
          updatedAt: dashboardHeader.updatedAt,
          accountId: dashboardHeader.account_id,
          id: dashboardHeader.id,
          menuName: dashboardHeader.menu_name,
          updated: dashboardHeader.is_updated === 1,
          techStack: dashboardHeader.tech_stack,
          object_type: dashboardHeader.object_type,
          sub_object_type: dashboardHeader.sub_object_type,
          build: !!dashboardHeader.build, // Convert to boolean
          testing: !!dashboardHeader.testing, // Convert to boolean
          dashboard_name: dashboardHeader.dashboard_name,
          module_id: dashboardHeader.module_id,
          description: dashboardHeader.description,
          secuirity_profile: dashboardHeader.secuirity_profile,
          dashbord1_Line: dashboardHeader.lineId
            ? [
              {
                createdAt: dashboardHeader.lineCreatedAt,
                createdBy: dashboardHeader.lineCreatedBy,
                updatedBy: dashboardHeader.lineUpdatedBy,
                updatedAt: dashboardHeader.lineUpdatedAt,
                accountId: dashboardHeader.lineAccountId,
                id: dashboardHeader.lineId,
                header_id: dashboardHeader.header_id,
                model: dashboardHeader.model, // Parse the JSON model
              },
            ]
            : [],
        }
      })

      return res.status(200).json(dashboards)
    }
  )
}


const getDashboardByModuleId = async (req, res) => {
  const module_id = req.query.module_id

  pool.query(
    `SELECT 
      h.id,
      h.account_id,
      h.created_at AS createdAt,
      h.created_by AS createdBy,
      h.updated_at AS updatedAt,
      h.updated_by AS updatedBy,
      CAST(h.is_build AS UNSIGNED) AS build,
      CAST(h.testing AS UNSIGNED) AS testing,
      h.dashboard_name,
      h.module_id,
      h.description,
      h.menu_name,
      h.object_type,
      h.secuirity_profile,
      h.sub_object_type,
      h.tech_stack,
      h.is_updated,
      l.id AS lineId,
      l.created_at AS lineCreatedAt,
      l.created_by AS lineCreatedBy,
      l.updated_at AS lineUpdatedAt,
      l.updated_by AS lineUpdatedBy,
      l.account_id AS lineAccountId,
      l.header_id,
      l.model
    FROM dashbord_header h
    LEFT JOIN dashbord1_line l ON h.id = l.dashbord_header_id
    WHERE h.module_id = ?`,
    [module_id],
    async (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Error fetching data from the database",
        })
      }

      // If there are no results, return an empty array
      if (results.length === 0) {
        return res.status(200).json([])
      }

      // Organize the data into the desired structure
      const dashboards = results.map((dashboardHeader) => {
        return {
          createdAt: dashboardHeader.createdAt,
          createdBy: dashboardHeader.createdBy,
          updatedBy: dashboardHeader.updatedBy,
          updatedAt: dashboardHeader.updatedAt,
          accountId: dashboardHeader.account_id,
          id: dashboardHeader.id,
          menuName: dashboardHeader.menu_name,
          updated: dashboardHeader.is_updated === 1,
          techStack: dashboardHeader.tech_stack,
          object_type: dashboardHeader.object_type,
          sub_object_type: dashboardHeader.sub_object_type,
          build: !!dashboardHeader.build, // Convert to boolean
          testing: !!dashboardHeader.testing, // Convert to boolean
          dashboard_name: dashboardHeader.dashboard_name,
          module_id: dashboardHeader.module_id,
          description: dashboardHeader.description,
          secuirity_profile: dashboardHeader.secuirity_profile,
          dashbord1_Line: dashboardHeader.lineId
            ? [
              {
                createdAt: dashboardHeader.lineCreatedAt,
                createdBy: dashboardHeader.lineCreatedBy,
                updatedBy: dashboardHeader.lineUpdatedBy,
                updatedAt: dashboardHeader.lineUpdatedAt,
                accountId: dashboardHeader.lineAccountId,
                id: dashboardHeader.lineId,
                header_id: dashboardHeader.header_id,
                model: dashboardHeader.model, // Parse the JSON model
              },
            ]
            : [],
        }
      })

      return res.status(200).json(dashboards)
    }
  )
}

const getAllDashboardHeaderById = async (req, res) => {
  const dashboardId = req.params.id
  const moduleId = req.query.module_id

  pool.query(
    `SELECT 
      h.id,
      h.account_id,
      h.created_at AS createdAt,
      h.created_by AS createdBy,
      h.updated_at AS updatedAt,
      h.updated_by AS updatedBy,
      CAST(h.is_build AS UNSIGNED) AS build,
      CAST(h.testing AS UNSIGNED) AS testing,
      h.dashboard_name,
      h.module_id,
      h.description,
      h.menu_name,
      h.object_type,
      h.secuirity_profile,
      h.sub_object_type,
      h.tech_stack,
      h.is_updated,
      l.id AS lineId,
      l.created_at AS lineCreatedAt,
      l.created_by AS lineCreatedBy,
      l.updated_at AS lineUpdatedAt,
      l.updated_by AS lineUpdatedBy,
      l.account_id AS lineAccountId,
      l.header_id,
      l.model
    FROM dashbord_header h
    LEFT JOIN dashbord1_line l ON h.id = l.dashbord_header_id
    WHERE h.id = ?`,
    [dashboardId],
    async (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Error fetching data from the database",
        })
      }

      // If there are no results, return a 404 response
      if (results.length === 0) {
        return res.status(404).json({
          success: 0,
          message: "No data found for the given ID and module ID",
        })
      }

      // Organize the data into the desired structure
      const dashboardHeader = results[0] // Assuming there's only one record

      const dashboard = {
        createdAt: dashboardHeader.createdAt,
        createdBy: dashboardHeader.createdBy,
        updatedBy: dashboardHeader.updatedBy,
        updatedAt: dashboardHeader.updatedAt,
        accountId: dashboardHeader.account_id,
        id: dashboardHeader.id,
        menuName: dashboardHeader.menu_name,
        updated: dashboardHeader.is_updated === 1,
        techStack: dashboardHeader.tech_stack,
        object_type: dashboardHeader.object_type,
        sub_object_type: dashboardHeader.sub_object_type,
        build: !!dashboardHeader.build, // Convert to boolean
        testing: !!dashboardHeader.testing, // Convert to boolean
        dashboard_name: dashboardHeader.dashboard_name,
        module_id: dashboardHeader.module_id,
        description: dashboardHeader.description,
        secuirity_profile: dashboardHeader.secuirity_profile,
        dashbord1_Line: dashboardHeader.lineId
          ? [
            {
              createdAt: dashboardHeader.lineCreatedAt,
              createdBy: dashboardHeader.lineCreatedBy,
              updatedBy: dashboardHeader.lineUpdatedBy,
              updatedAt: dashboardHeader.lineUpdatedAt,
              accountId: dashboardHeader.lineAccountId,
              id: dashboardHeader.lineId,
              header_id: dashboardHeader.header_id,
              model: dashboardHeader.model, // Parse the JSON model
            },
          ]
          : [],
      }

      return res.status(200).json(dashboard)
    }
  )
}

const createDashboard = (req, res) => {
  const body = req.body

  var today = new Date()

  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time

  // Insert into dashbord_header
  pool.query(
    `INSERT dashbord_header SET 
      created_at = ?,
      updated_at = ?,
      is_build = ?,
      dashboard_name = ?,
      description = ?,
      menu_name = ?,
      module_id = ?,
      secuirity_profile = ?,
      tech_stack = ?,
      is_updated = ?,
      object_type = ?,
      sub_object_type = ?,
      testing = ?`,
    [
      dateTime,
      dateTime,
      body.is_build || null,
      body.dashboard_name || null,
      body.description || null,
      body.menu_name || null,
      body.module_id || 0, // Provide a default value for module_id
      body.secuirity_profile || null,
      body.tech_stack || null,
      body.is_updated || null,
      body.object_type || null,
      body.sub_object_type || null,
      body.testing || false,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Failed to create dashboard",
        })
      }
      if (!results.insertId) {
        return res.json({
          success: 0,
          message: "Failed to create dashboard",
        })
      }

      const dashboardId = results.insertId

      // Insert into dashbord1_line
      pool.query(
        `INSERT dashbord1_line SET 
          created_at = ?,
          updated_at = ?,
          model = ?,
          header_id = ?,
          dashbord_header_id = ?`,
        [
          dateTime,
          dateTime,
          body.model || null, // Assuming you have 'model' in your request body
          body.header_id || null, // Assuming you have 'header_id' in your request body
          dashboardId,
        ],
        (lineError, lineResults, lineFields) => {
          if (lineError) {
            console.log(lineError)
            // Handle error, you might want to rollback the dashboard_header insertion
            return res.json({
              success: 0,
              message: "Failed to create dashboard and line",
            })
          }

          return res.json({
            success: 1,
            data: "created successfully",
          })
        }
      )
    }
  )
}

const updateDashboard = (req, res) => {
  const { id } = req.params
  const body = req.body

  var today = new Date()
  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time

  pool.query(
    `UPDATE dashbord_header SET 
      updated_at = ?,
      is_build = ?,
      dashboard_name = ?,
      description = ?,
      menu_name = ?,
      module_id = ?,
      secuirity_profile = ?,
      tech_stack = ?,
      is_updated = ?,
      object_type = ?,
      sub_object_type = ?,
      testing = ?
    WHERE id = ?`,
    [
      dateTime,
      body.is_build || null,
      body.dashboard_name || null,
      body.description || null,
      body.menu_name || null,
      body.module_id || null,
      body.secuirity_profile || null,
      body.tech_stack || null,
      body.is_updated || null,
      body.object_type || null,
      body.sub_object_type || null,
      body.testing || null,
      id,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Failed to update dashboard",
        })
      }
      if (results.affectedRows === 0) {
        return res.json({
          success: 0,
          message: "No records found for the given ID",
        })
      }
      return res.json({
        success: 1,
        data: "updated successfully",
      })
    }
  )
}

const deleteDashboard = async (req, res) => {
  const id = req.params.id
  pool.query(
    `DELETE FROM dashbord_header WHERE id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      return res.json({
        success: 1,
        data: "Deleted succesfully",
      })
    }
  )
}

//// Dashboard Line

const getDashboardLine = async (req, res) => {
  const id = req.params.id
  pool.query(`SELECT * FROM dashbord1_line`, [id], (error, results, fields) => {
    if (error) {
      console.log(error)
      return res.json({
        success: 0,
        message: "Table is empty",
      })
    }
    return res.status(200).json(results)
  })
}

const getDashboardLineById = async (req, res) => {
  const id = req.params.id
  pool.query(
    `SELECT * FROM dashbord1_line WHERE id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json(results)
    }
  )
}

const updateDashboardLineById = async (req, res) => {
  const id = req.params.id
  const body = req.body

  var today = new Date()

  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time

  pool.query(
    `UPDATE dashbord1_line SET updated_at = ?, created_by = ?, updated_by = ?, model = ?  WHERE id = ${id}`,
    [dateTime, body.created_by, body.updated_by, body.model, id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Failed to update dashboard",
        })
      }
      return res.json({
        success: 1,
        data: "Updated succesfully",
      })
    }
  )
}

//// System Parameter

const getSystemParameter = async (req, res) => {
  pool.query(`SELECT * FROM system_paramaters`, (error, results, fields) => {
    if (error) {
      console.log(error)
      return res.json({
        success: 0,
        message: "Table is empty",
      })
    }
    return res.status(200).json(results)
  })
}

const getSystemParameterById = async (req, res) => {
  var id = req.params.id
  if (id == null) {
    id = 1
  }
  pool.query(
    `SELECT * FROM system_paramaters WHERE id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json(results)
    }
  )
}

const createSystemParameter = async (req, res) => {
  const body = req.body
  pool.query(
    `INSERT system_paramaters SET edi_mae_scheduler_onoff = ?, edi_scheduler_onoff = ?, base_price_list = ?, billing_department_code = ?, cn_billing_frequency = ?, default_department = ?, default_position = ?, first_dayof_the_week = ?, hour_per_shift = ?, lease_tax_code = ?, link_to_display = ?, lov_link_to_display = ?, lov_row_to_display = ?, noncontainer_serviceorder_auto_appdepcode = ?, oid_admin_user = ?, oid_base = ?, oid_server_port = ?, oid_server_name = ?, row_to_add = ?, row_to_display = ?, scheduler_time = ?, single_charge = ?, user_default_group = ?, vessel_conf_processlimit = ?, company_display_name = ?, upload_logo = ?, upload_logo_name = ?, upload_logo_path = ?`,
    [
      body.edi_mae_scheduler_onoff,
      body.edi_scheduler_onoff,
      body.base_price_list,
      body.billing_department_code,
      body.cn_billing_frequency,
      body.default_department,
      body.default_position,
      body.first_dayof_the_week,
      body.hour_per_shift,
      body.lease_tax_code,
      body.link_to_display,
      body.lov_link_to_display,
      body.lov_row_to_display,
      body.noncontainer_serviceorder_auto_appdepcode,
      body.oid_admin_user,
      body.oid_base,
      body.oid_server_port,
      body.oid_server_name,
      body.row_to_add,
      body.row_to_display,
      body.scheduler_time,
      body.single_charge,
      body.user_default_group,
      body.vessel_conf_processlimit,
      body.company_display_name,
      body.upload_logo,
      body.upload_logo_name,
      body.upload_logo_path,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Failed to create dashboard",
        })
      }
      return res.json({
        success: 1,
        data: "created succesfully",
      })
    }
  )
}

const updateSystemParameter = async (req, res) => {
  const id = req.params.id
  const body = req.body

  pool.query(
    `UPDATE system_paramaters SET edi_mae_scheduler_onoff = ?, edi_scheduler_onoff = ?, base_price_list = ?, billing_department_code = ?, cn_billing_frequency = ?, default_department = ?, default_position = ?, first_dayof_the_week = ?, hour_per_shift = ?, lease_tax_code = ?, link_to_display = ?, lov_link_to_display = ?, lov_row_to_display = ?, noncontainer_serviceorder_auto_appdepcode = ?, oid_admin_user = ?, oid_base = ?, oid_server_port = ?, oid_server_name = ?, row_to_add = ?, row_to_display = ?, scheduler_time = ?, single_charge = ?, user_default_group = ?, vessel_conf_processlimit = ?, company_display_name = ?, upload_logo = ?, upload_logo_name = ?, upload_logo_path = ? where id = ${id}`,
    [
      body.edi_mae_scheduler_onoff,
      body.edi_scheduler_onoff,
      body.base_price_list,
      body.billing_department_code,
      body.cn_billing_frequency,
      body.default_department,
      body.default_position,
      body.first_dayof_the_week,
      body.hour_per_shift,
      body.lease_tax_code,
      body.link_to_display,
      body.lov_link_to_display,
      body.lov_row_to_display,
      body.noncontainer_serviceorder_auto_appdepcode,
      body.oid_admin_user,
      body.oid_base,
      body.oid_server_port,
      body.oid_server_name,
      body.row_to_add,
      body.row_to_display,
      body.scheduler_time,
      body.single_charge,
      body.user_default_group,
      body.vessel_conf_processlimit,
      body.company_display_name,
      body.upload_logo,
      body.upload_logo_name,
      body.upload_logo_path,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      if (!results) {
        return res.json({
          success: 0,
          message: "Failed to update Parameter",
        })
      }
      return res.json({
        success: 1,
        data: "Updated succesfully",
      })
    }
  )
}

const deleteSystemParameter = async (req, res) => {
  const id = req.params.id
  pool.query(
    `DELETE FROM system_paramaters WHERE id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      return res.json({
        success: 1,
        data: "Deleted succesfully",
      })
    }
  )
}

// const test = async (req, res) => {
//   try {
//     // Simulate getting the logged-in user's group (usrGrp)
//     const usrgrp = 1 // Replace this with your actual logic to get the user's group

//     // Find root menu items where menu_id is 0
//     let sql = `SELECT * FROM sec_grp_menu_access WHERE menu_id = 0 AND status= 'Enable' AND usr_grp = ${usrgrp} ORDER BY item_seq`
//     const root = await executeQuery(sql)

//     for (let i = 0; i < root.length; i++) {
//       const rootMenuItemId = root[i]

//       // Find menu items by menu_id (rootMenuItemId) and usrGrp
//       let sql1 = `SELECT * FROM sec_grp_menu_access a WHERE a.usr_grp = ${usrgrp} and a.menu_item_id= ${rootMenuItemId.menu_item_id}`
//       const menu = await executeQuery(sql1)

//       for (const menuItem of menu) {
//         // Find all submenu items with status
//         let sql2 = `SELECT * FROM sec_grp_menu_access a where a.status= 'Enable' and a.menu_id=${menuItem.menu_item_id} and a.usr_grp =${usrgrp} ORDER BY item_seq`
//         const allSubmenu = await executeQuery(sql2)

//         menuItem.subMenus = allSubmenu
//       }
//     }

//     res.status(200).json(root)
//   } catch (error) {
//     console.error(error)
//     res.status(500).json({ message: "Internal server error" })
//   }
// }

const getLogs = (req, res) => {
  const { userName } = req.params // Adjust this to your specific user identification method

  // Define the directory where the user's logs are stored
  const logDir = path.join(__dirname, "../logs", userName)

  try {
    // Read log files in the user's directory
    const logFiles = fs.readdirSync(logDir)

    // Read the content of each log file
    const logs = logFiles.map((file) => {
      const logFilePath = path.join(logDir, file)
      const logData = fs.readFileSync(logFilePath, "utf-8")
      return { date: file, data: logData }
    })

    res.status(200).json({ logs })
  } catch (err) {
    console.error(`Error while reading logs: ${err}`)
    res.status(500).json({ error: "Internal Server Error" })
  }
}

const addColumns = (req, res) => {
  const { columnName, dataType } = req.body

  if (!Array.isArray(columnName) || !Array.isArray(dataType)) {
    return res.send("Please provide multiple column names and data types.")
  }

  if (columnName.length !== dataType.length) {
    return res.send(
      "Number of column names must match the number of data types."
    )
  }

  const columnsToAdd = []
  for (let i = 0; i < columnName.length; i++) {
    columnsToAdd.push(`${columnName[i]} ${dataType[i]}`)
  }

  // Construct the SQL query
  const sql = `ALTER TABLE your_table_name ADD COLUMN ${columnsToAdd.join(
    ", "
  )}`

  connection.query(sql, (err) => {
    if (err) {
      res.send(`Error: ${err.message}`)
    } else {
      res.send("Columns added successfully.")
    }
  })
}

//// Form Extension controller

const getAllFormExtension = (req, res) => {
  pool.query(`SELECT * FROM rn_ext_field_t`, (error, results, fields) => {
    if (error) {
      console.log(error)
      return res.json({
        success: 0,
        message: "Table is empty",
      })
    }
    return res.status(200).json(results)
  })
}

const getByIdFormExtension = (req, res) => {
  const id = req.params.id
  pool.query(
    `SELECT * FROM rn_ext_field_t WHERE id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json(results)
    }
  )
}

const createFormExtension = async (req, res) => {
  const body = req.body
  // const currentDate = new Date().toISOString().slice(0, 10) // Get YYYY-MM-DD format
  var today = new Date()
  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time
  const user = req.user
  console.log(req.user.user_name)
  const email = req.user.email

  const sql = `SELECT account_id FROM sec_users WHERE email = ?`
  const account_id = await executeQuery(sql, [email])
  // console.log(account_id[0].account_id)

  pool.query(
    `INSERT INTO rn_ext_field_t SET created_at = ?, created_by = ?, account_id = ?, data_type = ?, field_name = ?, form_code = ?, is_active = ?, mapping = ?, type = ?`,
    [
      dateTime,
      req.user.user_name,
      account_id[0].account_id,
      body.data_type,
      body.field_name,
      body.form_code,
      body.is_active,
      body.mapping,
      body.type,
    ],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Some error occured",
        })
      }
      return res.json({
        success: 1,
        data: "created succesfully",
      })
    }
  )

  // console.log(account_id)
}

const updateFormExtension = async (req, res) => {
  const id = req.params.id
  const body = req.body
  // const currentDate = new Date().toISOString().slice(0, 10) // Get YYYY-MM-DD format
  var today = new Date()
  var date =
    today.getFullYear() + "-" + (today.getMonth() + 1) + "-" + today.getDate()
  var time =
    today.getHours() + ":" + today.getMinutes() + ":" + today.getSeconds()
  var dateTime = date + " " + time
  const email = req.user.email
  const sql = `SELECT account_id FROM sec_users WHERE email = ?`
  const account_id = await executeQuery(sql, [email])
  pool.query(
    `UPDATE rn_ext_field_t SET updated_at = ?, updated_at = ?, account_id = ?, data_type = '${body.data_type}', field_name = '${body.field_name}', form_code = '${body.form_code}', is_active = '${body.is_active}', mapping = '${body.mapping}', type = '${body.type}' WHERE id = '${id}'`,
    [dateTime, req.user.user_name, account_id[0].account_id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Some error occured",
        })
      }
      return res.json({
        success: 1,
        data: "created succesfully",
      })
    }
  )
}

const deleteFormExtension = async (req, res) => {
  const id = req.params.id
  const body = req.body
  pool.query(
    `DELETE FROM rn_ext_field_t WHERE id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return
      }
      return res.json({
        success: 1,
        data: "Deleted succesfully",
      })
    }
  )
}

const buildExtension = async (req, res) => {
  const email = req.user.email
  const sql = `SELECT account_id FROM sec_users WHERE email = ?`
  const result = await executeQuery(sql, [email])
  const account_id = result[0].account_id
  const formId = req.params.formId

  const sql2 = `SELECT field_name FROM rn_ext_field_t WHERE id = ?`
  const field_name = await executeQuery(sql, [formId])
  console.log(field_name)
  const formCode = await buildExtensionByFormCode(account_id, formId)
  if (!formCode) {
    res.status(500).json({ success: 0, message: "Some error occured!" })
  }

  const mailOptions = {
    from: "example.com",
    to: email,
    subject: "Email for informing about form Extension",
    text: `Your form with form id ${formId} is extended with FieldName ${field_name}`,
  }

  transporter.sendMail(mailOptions, (error) => {
    if (error) {
      console.log(error)
      console.log({ message: "Error sending Email" })
    }
    console.log({ message: "Email sent successfully" })
  })

  console.log(formCode)
  res.status(200).json(formCode[0])
}

const userMenu = (req, res) => {
  pool.query(`SELECT * FROM accesstype`, (error, results, fields) => {
    if (error) {
      console.log(error)
      return res.json({
        success: 0,
        message: "Table is empty",
      })
    }
    return res.status(200).json(results)
  })
}

const test = (req, res) => {
  const id = req.params.id
  pool.query(
    `SELECT field_name FROM rn_ext_field_t WHERE id = ?`,
    [id],
    (error, results, fields) => {
      if (error) {
        console.log(error)
        return res.json({
          success: 0,
          message: "Table is empty",
        })
      }
      return res.status(200).json(results)
    }
  )
}

module.exports = {
  getUsersUserGrpMaintenance,
  getUsersByUserIdUserGrpMaintenance,
  updateUsersUserGrpMaintenance,
  createUsersUserGrpMaintenance,
  deleteUsersUserGrpMaintenance,
  getUsersMenuMaintainence,
  getUsersByUserIdMenuMaintainence,
  createUsersMenuMaintainence,
  updateUsersMenuMaintainence,
  deleteUsersMenuMaintainence,
  getUsersByIdSubMenuMaintainence,
  createUsersMenuAccessControl,
  getUsersMenuAccessControl,
  getUserMaintainence,
  getByIdUserMaintainence,
  createUserMaintainence,
  updateUserMaintainence,
  loadMenuByUser,
  userMenu,
  createReport,
  getAllReportBuilder,
  getAllReportBuilderById,
  getAllReportBuilderByQuery,
  updateReportBuilder,
  deleteReportBuilder,
  getReportLine,
  getReportLineById,
  updateReportLine,

  getAllDashboard,
  getDashboardByModuleId,
  getAllDashboardHeaderById,
  createDashboard,
  updateDashboard,
  deleteDashboard,
  getDashboardLine,
  getDashboardLineById,
  updateDashboardLineById,
  getSystemParameter,
  getSystemParameterById,
  createSystemParameter,
  updateSystemParameter,
  deleteSystemParameter,
  getLogs,
  getAllFormExtension,
  getByIdFormExtension,
  createFormExtension,
  updateFormExtension,
  deleteFormExtension,
  buildExtension,
  login,
  logout,
  sendEmailForResetPassword,
  resetPassword,
  savePassword,
  getLoggedInUser,
  uploadProfilePhoto,
  retrieveProfilePhoto,
  test,
}