import User from "../models/User.js";
import bcrypt from "bcrypt";
import jwt from "jsonwebtoken";
import cloudinary from "cloudinary";
import multer from "multer";
import streamifier from "streamifier";
import DatauriParser from "datauri/parser.js";
import path from "path";
import axios from "axios";
/* READ */

cloudinary.config({
  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
  api_key: process.env.CLOUDINARY_API_KEY,
  api_secret: process.env.CLOUDINARY_API_SECRET,
});

// Configure Multer middleware to handle file uploads
const upload = multer({
  storage: multer.memoryStorage(),
  limits: {
    fileSize: 10 * 1024 * 1024, // 10 MB
  },
});

export const getUsers = async (req, res, next) => {
  try {
    const users = await User.find();
    res.status(200).json(users);
  } catch (err) {
    res.status(404).json({ message: err.message });

    next(err);
  }
};
export const getUser = async (req, res) => {
  try {
    const { id } = req.params;
    const user = await User.findOne().or([
      { email: id },
      { phone: id },
      { username: id },
    ]);
    if (user) {
      res.status(200).json(user);
    } else {
      res.status(404).json({ message: "user not found" });
    }
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
};
export const getUserId = async (req, res) => {
  try {
    const { id } = req.params;
    const user = await User.findById(id);
    if (user) {
      res.status(200).json(user);
    } else {
      res.status(404).json({ message: "user not found" });
    }
  } catch (err) {
    res.status(404).json({ message: err.message });
  }
};
export const updateUser = async (req, res, next) => {
  try {
    const {
      fName,
      lName,
      email,
      phone,
      address1,
      address2,
      city,
      province,
      country,
      zip,
      type,
      status,
      transactions,
    } = req.body;

    const emailTaken = await User.findOne({ email: email });
    const phoneTaken = await User.findOne({ phone: phone });

    let taken = false;
    if (phoneTaken._id.toString().includes(req.params.id)) {
      taken = false;
    } else {
      taken = true;
    }

    console.log(taken);
    if (req.file) {
      const extName = path.extname(req.file.originalname).toString();
      const file64 = parser.format(extName, req.file.buffer);
      const result = await cloudinary.uploader.upload(file64.content, {
        folder: "obPayUserPhoto",
        transformation: [{ width: 500, height: 500, crop: "limit" }],
      });
      if (!emailTaken && !taken) {
        const newUser = {
          fName,
          lName,
          email,
          phone,
          address1,
          address2,
          city,
          province,
          country,
          zip,
          type,
          status,
          transactions,
          photo: result.secure_url,
        };
        const updatedUser = await User.findByIdAndUpdate(
          req.params.id,
          { $set: newUser },
          { new: true }
        );
        res.status(200).json(updatedUser);
      } else if (emailTaken) {
        res.status(500).json({ error: "email taken" });
      } else if (taken) {
        res.status(500).json({ error: "phone taken" });
      }
    } else if (!req.file) {
      if (!emailTaken && !taken) {
        const newUser = {
          fName,
          lName,
          email,
          phone,
          address1,
          address2,
          city,
          province,
          country,
          zip,
          transactions,
          status,
        };
        const updatedUser = await User.findByIdAndUpdate(
          req.params.id,
          { $set: newUser },
          { new: true }
        );
        res.status(200).json(updatedUser);
      } else if (emailTaken) {
        res.status(500).json({ error: "email taken" });
      } else if (taken) {
        const newUser = {
          fName,
          lName,
          email,
          phone,
          address1,
          address2,
          city,
          province,
          country,
          zip,
          transactions,
          status,
        };
        const updatedUser = await User.findByIdAndUpdate(
          req.params.id,
          { $set: newUser },
          { new: true }
        );
        res.status(500).json({ error: updatedUser });
      }
    }
  } catch (err) {
    res.status(404).json({ message: err.message });

    next(err);
  }
};
export const updateUserSub = async (req, res, next) => {
  try {
    console.log(req.params.id);

    const emailTaken = await User.findOne({ email: req.body.email });
    const usernameTaken = await User.findOne({ username: req.body.username });

    const updatedUser = await User.findByIdAndUpdate(
      req.params.id,
      { $set: req.body },
      { new: true }
    );
    if (updatedUser) {
      res.status(200).json(updatedUser);
    } else {
      res.status(400).json("User does not exist.");
    }
  } catch (err) {
    next(err);
    res.status(400).json(err);
    console.log(err);
  }
};
export const updateUserPass = async (req, res, next) => {
  try {
    console.log(req.params.id);
    if (req.body.password) {
      const salt = await bcrypt.genSalt();
      const passwordHash = await bcrypt.hash(req.body.password, salt);

      const updatedUser = await User.findByIdAndUpdate(
        req.params.id,
        { $set: { password: passwordHash } },
        { new: true }
      );

      if (updatedUser) {
        res.status(200).json(updatedUser);
      } else {
        res.status(200).json("User does not exist.");
      }
    }
  } catch (err) {
    next(err);
  }
};
export const updateUserPhoto = async (req, res, next) => {
  try {
    console.log(req.params.id);
    if (req.file) {
      const extName = path.extname(req.file.originalname).toString();
      const file64 = parser.format(extName, req.file.buffer);
      const result = await cloudinary.uploader.upload(file64.content, {
        folder: "obPayUserPhoto",
        transformation: [{ width: 500, height: 500, crop: "limit" }],
      });
      const updatedUser = await User.findByIdAndUpdate(
        req.params.id,
        { $set: { photo: result } },
        { new: true }
      );

      if (updatedUser) {
        res.status(200).json(updatedUser);
      } else {
        res.status(200).json("User does not exist.");
      }
    }
  } catch (err) {
    next(err);
    res.status(400).json(err);
  }
};
export const updateUserFriends = async (req, res, next) => {
  try {
    console.log(req.params.id);
    const user = await User.findById(req.params.id);
    if (!user) {
      return res.status(404).json("User does not exist.");
    }
    const { number, favorite, nickname } = req.body;
    const newFriend = { number, favorite, nickname };
    user.friends.push(newFriend);
    const updatedUser = await user.save();
    res.status(200).json(updatedUser);
  } catch (err) {
    next(err);
  }
};
export const updateUserFriendData = async (req, res, next) => {
  try {
    const userId = req.params.id;
    const friendId = req.params.friendId;
    const { number, favorite, nickname } = req.body;
    const updatedUser = await User.findOneAndUpdate(
      { _id: userId, "friends._id": friendId },
      {
        $set: {
          "friends.$.number": number,
          "friends.$.favorite": favorite,
          "friends.$.nickname": nickname,
        },
      },
      { new: true }
    );
    if (updatedUser) {
      res.status(200).json(updatedUser);
    } else {
      res.status(404).json("User or friend not found.");
      console.log("heyy" + friendId + " " + userId);
    }
  } catch (err) {
    next(err);
  }
};
export const deleteUserFriend = async (req, res, next) => {
  try {
    const userId = req.params.id;
    const friendId = req.params.friendId;
    const updatedUser = await User.findOneAndUpdate(
      { _id: userId },
      { $pull: { friends: { _id: friendId } } },
      { new: true }
    );
    if (updatedUser) {
      res.status(200).json(updatedUser);
    } else {
      res.status(404).json("User or friend not found.");
    }
  } catch (err) {
    next(err);
  }
};

export const deleteUser = async (req, res, next) => {
  try {
    await User.findByIdAndDelete(req.params.id);
    res.status(200).json("User has been deleted.");
  } catch (err) {
    res.status(404).json({ message: err.message });

    next(err);
  }
};
export const sendOtpEmail = async (req, res) => {
  const { username } = req.body;

  try {
    const user = await User.findOne({ email: username });

    if (!user) {
      return res.status(404).json({ message: "User not found" });
    }
    // Generate OTP (simplified for demonstration)
    const otp = Math.floor(100000 + Math.random() * 900000);
    const otpExpiration = new Date(Date.now() + 600000); // OTP expires in 10 minutes

    const updated = await User.findOneAndUpdate(
      { email: username },
      { otp, otpExpiration }
    );

    const requestData = {
      email: username,
      html: "<p>Your One-Time Pin (OTP) is: <strong>" + otp + "</strong></p>",
    };

    const responseFromExternalAPI = await axios.post(
      "http://192.168.50.15:4038/api/send-email",
      requestData
    );
    // console.log(responseFromExternalAPI);

    // Process the response from the external API
    const responseData = responseFromExternalAPI.data;

    return res.json({ message: responseData });
  } catch (error) {
    console.error(error);
    return res.status(500).json({ message: "Internal Server Error" });
  }
};
export const confirmOtp = async (req, res) => {
  const { username, otp } = req.body;

  // Verify OTP and its expiration time
  const user = await User.findOne({
    email: username,
    otp,
    otpExpiration: { $gt: Date.now() },
  });

  if (!user) {
    return res.status(400).send("Invalid OTP or expired");
  }

  user.otp = null;
  user.otpExpiration = null;

  await user.save();

  return res.status(200).json({ message: "OTP success" });
};