import { Request, Response } from "express";

import { JSONToken } from "../helpers/jwtHelper";

import { Encrypt } from "../helpers/cryptHelper";
import { StringUtil } from "../helpers/stringHelper";
import Employer, { IEmployer } from "../models/employer";
import moment from "moment";
import { authenticator } from 'otplib';
import { isEmail, isMobileNumber } from "../helpers/commonHelper";
import { EmailHelper } from "../helpers/emailHelper";
import { authenticatorHelper, twoFactorAuthVerifyHelper } from
"../helpers/twoFactoreAuthenticatorHelper";

export async function employerRegistration(req: Request, res: Response) {

let employerModel: IEmployer = req.body

let query = {}
employerModel.createdAt = moment().format();
employerModel.updatedAt = moment().format();
employerModel.password = await Encrypt.cryptPassword(employerModel.password);
const isEmailCheck = isEmail(employerModel.email);
const isMobileNumberCheck = isMobileNumber(employerModel.mobileNumber);
const employer = new Employer(employerModel);

if (isEmailCheck) {
query = {
$or: [
{ 'email': employer.email },
]
}
}

if (isMobileNumberCheck) {
query = {
$or: [
{ 'mobileNumber': employer.mobileNumber },
]
}
}

let isExist = await Employer.find(query);

const otp = StringUtil.genRandomNumber(6);
console.log("employerModel.email", employerModel.email)
employer.otp = otp
 if (isExist && isExist.length === 0) {
employer.save().then(async (x) => {
await EmailHelper.send([
{
"name": employerModel.name,
"address": employerModel.email
}],

"Confirm your email address on JObportal.",

'Thanks for signing up at HaqtoJobsportal! Please click on the
following button to verify your email address. <a href="walkupp.com">Verify
Email</a>');

const existEmployer: IEmployer[] = await Employer.find(query);

const token = JSONToken.createToken(existEmployer[0]);

res.status(200).send({ statusCode: 200, message: "User created

successfully", token });
}).catch((err) => {
res.status(500).send(err);
});
}
else {
res.status(200).send("user already exist");
}
}

export async function verifyOTP(req: Request, res: Response) {

const { email, otp, mobileNumber } = req.body;
if (!email && !mobileNumber) {
return res.status(400).send({ statusCode: 400, message: "email or
mobileNumber must" });
}
const query = email ? { email } : { mobileNumber };
try {
const employer = await Employer.findOne(query);

console.log('employer',)
if (employer) {
if (otp === employer.otp) {
await Employer.updateOne(query, { $set: { "isLoggedIn":
true } });
 const token = JSONToken.createToken(employer);
return res.status(200).send({ statusCode: 200, message:
"successfully verified otp",token });
} else {
return res.status(404).send({ statusCode: 404, message: "otp
incorrect or expired" });
}
} else {
return res.status(404).send({ statusCode: 404, message: "employer
doesn't exist" });
}
} catch (error) {
console.error(error);
return res.status(500).send({ statusCode: 500, message: "Internal server
error" });
}
}

export async function employerLogin(req: Request, res: Response) {

let employerModel: IEmployer = req.body

const isEmailCheck = isEmail(employerModel.email);
const isMobileNumberCheck = isMobileNumber(employerModel.mobileNumber);
let query = {}

if (isEmailCheck) {
query = {
$or: [
{ 'email': employerModel.email },
]
}
}

if (isMobileNumberCheck) {
query = {
$or: [
{ 'mobileNumber': employerModel.mobileNumber }
]
}
}

let isExist = await Employer.find(query);

console.log("isExist[0]", isExist[0])
 if (isExist && isExist.length > 0) {
const isValid = await Encrypt.comparePassword(employerModel.password,
isExist[0].password);
if (isValid) {
const token = JSONToken.createToken(isExist[0]);
res.status(200).send(token);
}
else {
res.status(400).send({
code: 10002,
message: "Invalid Email / Mobile Number / Username and password"
})
}
}
else {
res.status(400).send({
code: 10002,
message: "Invalid Email / Mobile Number / Username"
})
}
}

export async function updateEmployerProfile(req: Request, res: Response) {

try {
const _id = res.get("id")
// const employerId = req.params.id;
console.log("_id", _id);
const updatedFields: Partial<IEmployer> = req.body;
const existingEmployer = await Employer.findById(_id);
console.log("existingEmployer", existingEmployer);

if (!existingEmployer) {
return res.status(404).send("Employer not found");
}

if (updatedFields.name) {
existingEmployer.name = updatedFields.name;
}

if (updatedFields.employerCity) {
existingEmployer.employerCity = updatedFields.employerCity;
}

if (updatedFields.employerArea) {
 existingEmployer.employerArea = updatedFields.employerArea;
}

if (updatedFields.employerStreet) {
existingEmployer.employerStreet = updatedFields.employerStreet;
}

if (updatedFields.employerPincode) {
existingEmployer.employerPincode = updatedFields.employerPincode;
}

if (updatedFields.employerCountry) {
existingEmployer.employerCountry = updatedFields.employerCountry;
}

if (updatedFields.employerProfileImage) {
existingEmployer.employerProfileImage =
updatedFields.employerProfileImage;
}

if (updatedFields.mobileNumber) {
existingEmployer.mobileNumber = updatedFields.mobileNumber;
}

if (updatedFields.email) {
existingEmployer.email = updatedFields.email;
}

existingEmployer.updatedAt = moment().format();
const updatedEmployer = await existingEmployer.save();
res.status(200).json(updatedEmployer);
}

catch (error) {
console.error("Error updating employer profile:", error);
res.status(500).send("Internal Server Error");
}
}

export async function getAllEmployer(req: Request, res: Response) {

try {
const employer = await Employer.find();
res.status(200).json({
statusCode: 200,
employer: employer,
 });
} catch (error) {
console.error("Error fetching jobs:", error);
res.status(500).json({
statusCode: 500,
message: "Internal server error",
});
}
}

export async function getEmployerById(req: Request, res: Response) {

try {
const _id = res.get("id")
console.log("id", _id)
const employer = await Employer.findById({ _id: _id });

if (employer) {
res.status(200).json({
statusCode: 200,
message: "employer fetch successfully",
employer: employer,
});
} else {
res.status(404).json({
statusCode: 404,
message: "employer not found",
});
}
} catch (error) {
console.error("Error fetching employer:", error);
res.status(500).json({
statusCode: 500,
message: "Internal server error",
});
}
}

export async function employertwoFA(req: Request, res: Response) {

const email = res.get("email");
console.log('email', email)
let isExist = await Employer.find({
$or: [
{ 'email': email },
],
 });

if (isExist && isExist.length > 0) {

let secret = process.env.QRCODE_SECRET;
console.log(isExist);
if (isExist[0].secret) {
secret = isExist[0].secret;
}
else {
secret = authenticator.generateSecret();
await Employer.updateOne(
{ "email": email },
{ $set: { "secret": secret } }
);
}
let data = { email, secret };

try {
let url = await authenticatorHelper(data);
console.log('response', url)
res.status(200).send(url);
} catch (error) {
console.error('Error generating QR code:', error);
res.status(500).send(error);
}
}
else {
res.status(400).send({
code: "10002",
message: "Invalid Email / Mobile Number / Username"
})
}
}

export async function employertwoFAVerify(req: Request, res: Response) {

let code = req.body.code
console.log('code', code)
const email = res.get("email");
console.log('email', email)
let isExist = await Employer.find({
$or: [
{ 'email': email },
],
});
let data = {
 isExist,
code
}
const response = await twoFactorAuthVerifyHelper(data);
if (response) {
res.status(200).send({
code: "200",
message: "code verified"
})
} else {
res.status(400).send({
code: "10002",
message: "Invalid Code, Please try again"
})
}

export async function employerSendOtp(req: Request, res: Response) {

try {
const employerModel: IEmployer = req.body;
const isEmailCheck = isEmail(employerModel.email);
const isMobileNumberCheck = isMobileNumber(employerModel.mobileNumber);

const query = isEmailCheck

? { 'email': employerModel.email }
: isMobileNumberCheck
? { 'mobileNumber': employerModel.mobileNumber }
: {};

const isExist = await Employer.findOne(query);

if (isExist) {
const otp = StringUtil.genRandomNumber(6);
isExist.otp = otp;
await isExist.save();

if (isEmailCheck) {
const name = employerModel.email.split("@")[0];
const emailContent = `<p>Welcome to walkupp! Please use this pin
for ${otp} one-time password</p>`;
await EmailHelper.send([{ "name": name, "address":
employerModel.email }],
"Confirm your email address on Jobportal.",
emailContent);
 }

if(isMobileNumberCheck){

}
res.status(200).send({ statusCode: 200, message: "Otp sent
successfully" });
} else {
res.status(200).send({ statusCode: 200, message: "User doesn't
exist" });
}
} catch (error) {
console.error(error);
res.status(500).send({ statusCode: 500, message: "Internal Server Error"
});
}
}