import * as authService from "../../services/auth/auth.services.js";
import bcrypt from "bcrypt";
import crypto from "crypto";
import moment from "moment";
import jwt from "jsonwebtoken";
import { config } from "../../config/config.js";
import { messages } from "../../config/response.messages.js";
import * as Email from "../../helper/email.js";
import * as Helper from "../../helper/index.js";

export async function login(req, res) {
  try {
    let userDetails = await authService.findByEmail(req.body);
    if (userDetails != null) {
      //Password verification
      if (!(await bcrypt.compare(req.body.password, userDetails.password))) {
        return res.status(401).send({
          status: 401,
          message: messages.login_password_incorrect,
        });
      } else if (userDetails.is_verified != 1) {
        let sendMail = await Email.sendVerifyOTPMail(req.body.email);
        if (sendMail != false) {
          let updateUser = {
            otp: sendMail,
          };
          await authService.updateUserByEmail(updateUser, req.body.email);
          return res.status(203).send({
            status: 203,
            message: messages.email_address_not_verified,
          });
        } else {
          return res.status(422).send({
            status: 422,
            message: messages.invalid_email,
          });
        }
      } else if (userDetails.is_active == 0 || userDetails.is_deleted == 1) {
        return res.status(401).send({
          status: 401,
          message: messages.account_inactive,
        });
      } else {
        //Token generation
        let updateUser = {
          device_id: req.body.device_id,
          device_type: req.body.device_type,
          fcm_token: req.body.fcm_token,
        };
        await authService.updateUserByEmail(updateUser, req.body.email);
        let tokenObject = {
          user_id: userDetails.id,
          email: req.body.email,
        };
        userDetails.dataValues.token = jwt.sign(
          tokenObject,
          config.jwt_encryption
        );
        return res.status(200).send({
          status: 200,
          message: messages.login_success,
          data: userDetails,
        });
      }
    } else {
      return res.status(400).send({
        status: 400,
        message: messages.email_not_found,
      });
    }
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function verifyOtp(req, res) {
  try {
    let userDetails = await authService.findByEmail(req.body);
    if (userDetails != null) {
      if (req.body.otp == userDetails.dataValues.otp) {
        let updateUser = {
          is_verified: 1,
          otp: 0,
        };
        await authService.updateUserByEmail(updateUser, req.body.email);
        return res.status(200).send({
          status: 200,
          message: messages.otp_verified,
        });
      } else {
        return res.status(400).send({
          status: 400,
          message: messages.otp_not_verified,
        });
      }
    } else {
      return res.status(400).send({
        status: 400,
        message: messages.email_not_found,
      });
    }
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function sendOtp(req, res) {
  try {
    let userDetails = await authService.findByEmail(req.body);
    if (userDetails != null) {
      let sendMail = await Email.sendVerifyOTPMail(req.body.email);
      if (sendMail != false) {
        let updateUser = {
          otp: sendMail,
        };
        await authService.updateUserByEmail(updateUser, req.body.email);
        return res.status(200).send({
          status: 200,
          message: messages.otp_send,
        });
      } else {
        return res.status(422).send({
          status: 422,
          message: messages.invalid_email,
        });
      }
    } else {
      return res.status(400).send({
        status: 400,
        message: messages.email_not_found,
      });
    }
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function userList(req, res) {
  try {
    let userDetails = await authService.userList();
    return res.status(200).send({
      status: 200,
      message: messages.user_found,
      data: userDetails,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export const createUser = async (req, res) => {
  try {
    const salt = await bcrypt.genSalt(10);
    req.body.password = await bcrypt.hash(req.body.password, salt);
    let isCreate = await authService.createUser(req.body);
    if (isCreate != false) {
      let sendMail = await Email.sendVerifyOTPMail(req.body.email);
      let updateUser = {
        is_active: 1,
        otp: sendMail,
      };
      await authService.updateUserByEmail(updateUser, req.body.email);
      if (sendMail != false) {
        return res.status(201).send({
          status: 201,
          message: messages.user_created,
        });
      } else {
        return res.status(422).send({
          status: 422,
          message: messages.invalid_email,
        });
      }
    } else {
      return res.status(500).send({
        status: 500,
        message: messages.something_went_wrong,
      });
    }
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
};

export async function isEmailExist(req, res, next) {
  try {
    let userData = await authService.findByEmail({ email: req.body.email });
    if (userData != null) {
      if (userData.is_verified != 1) {
        let sendMail = await Email.sendVerifyOTPMail(req.body.email);
        if (sendMail != false) {
          let updateUser = {
            otp: sendMail,
          };
          await authService.updateUserByEmail(updateUser, req.body.email);
          //redirect to the verify OTP
          return res.status(203).send({
            status: 203,
            message: messages.email_address_not_verified,
          });
        } else {
          return res.status(422).send({
            status: 422,
            message: messages.invalid_email,
          });
        }
      } else if (userData.is_deleted != 0 || userData.is_active != 0) {
        return res.status(401).send({
          status: 401,
          message: messages.account_inactive,
        });
      } else {
        //need to manage multi device
        return res.status(403).send({
          status: 403,
          message: messages.email_already_exist,
        });
      }
    } else {
      next();
    }
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function updateUser(req, res) {
  try {
    let userDetails = {
      name: req.body.name,
      profile_picture: req.body.profile_picture,
    };
    await authService.updateUser(userDetails, req.user_id);
    return res.status(202).send({
      status: 202,
      message: messages.user_updated,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function updateUserFcm(req, res) {
  try {
    let userDetails = {
      fcm_token: req.body.fcm_token,
    };
    await authService.updateUser(userDetails, req.user_id);
    return res.status(202).send({
      status: 202,
      message: messages.fcm_updated,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function deleteUser(req, res) {
  try {
    req.body.is_deleted = 1;
    await authService.updateUser(req.body, req.user_id);
    return res.status(202).send({
      status: 202,
      message: messages.user_deleted,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function userProfile(req, res) {
  try {
    let userDetails = await authService.findById({ user_id: req.user_id });
    return res.status(202).send({
      status: 202,
      message: messages.user_found,
      data: userDetails,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function logout(req, res) {
  try {
    await authService.updateUser({ fcm_token: "" }, req.user_id);
    return res.status(202).send({
      status: 202,
      message: messages.logout_success,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function ChangePassword(req, res) {
  try {
    let result = await authService.findById({ user_id: req.user_id });
    let comparePassword = await bcrypt.compare(
      req.body.old_password,
      result.password
    );
    if (!comparePassword) {
      return res.status(401).send({
        status: 401,
        message: messages.login_password_incorrect,
      });
    } else {
      if (req.body.new_password == req.body.old_password) {
        return res.status(400).send({
          status: 400,
          message: messages.old_new_same,
        });
      } else {
        const salt = await bcrypt.genSalt(10);
        req.body.password = await bcrypt.hash(req.body.new_password, 10);
        await authService.updateUser(
          { password: req.body.password },
          req.user_id
        );
        return res.status(202).send({
          status: 202,
          message: messages.password_change,
        });
      }
    }
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function ForgotPassword(req, res) {
  try {
    let createobject = {
      token: crypto.randomBytes(48).toString("base64url"),
      email: req.body.email,
      expired_at: moment().add(5, "minutes").unix(),
      created_at: moment().unix(),
      user_type: "user",
    };
    var isEmail = await authService.getUserEmail(req.body, createobject);
    if (isEmail) {
      var isData = await authService.ForgotPasswordByEmail(req.body.email);
      if (isData) {
        await authService.updateForgotPasswordByEmail(
          createobject,
          req.body.email
        );
      } else {
        await authService.createForgotPassword(createobject);
      }
      await Email.sendResetPasswordMail(
        req.body.email,
        createobject.token,
        createobject.user_type
      );
      return res.status(202).send({
        status: 202,
        message: messages.Forgot_password,
      });
    } else {
      return res.status(201).send({
        status: 201,
        message: messages.email_not_found,
      });
    }
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(501).send({
      status: 501,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function manageNotificationStatus(req, res) {
  try {
    await authService.updateUser(
      { notification_status: req.body.notification_status },
      req.user_id
    );
    return res.status(202).send({
      status: 202,
      message: messages.status_change,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
    });
  }
}

export async function notificationList(req, res) {
  try {
    let data = await authService.getNotificationList(
      { user_id: req.user_id },
      req.query
    );
    for (let i = 0; i < data.docs.length; i++) {
      if (data.docs[i].dataValues.notification_type == 2) {
        (data.docs[i].dataValues.title = messages.coffe_run),
          (data.docs[i].dataValues.description =
            " " +
            data.docs[i].dataValues.user.name +
            messages.initiate_java_go);
      } else {
        (data.docs[i].dataValues.title = ""),
          (data.docs[i].dataValues.description = "");
      }
    }
    return res.status(200).send({
      status: 200,
      message: messages.notification_list,
      data: data,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
    });
  }
}

export async function removeNotification(req, res) {
  try {
    if(req.params.id == 0){
      await authService.removeAllNotification(req.user_id)
    } else {
      await authService.removeNotification({ user_id: req.user_id }, req.params);
    }
    return res.status(202).send({
      status: 202,
      messages: messages.notification_removed,
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}

export async function s3BucketDetails(req, res) {
  try {
    let s3Details = await authService.s3BucketDetails(req.query.file_type);
    return res.status(200).send({
      status: 200,
      messages: messages.notification_removed,
      data: s3Details
    });
  } catch (error) {
    Helper.writeErrorLog(req, error);
    return res.status(500).send({
      status: 500,
      message: messages.something_went_wrong,
      error: error,
    });
  }
}