/* eslint-disable camelcase */
const { default: mongoose } = require("mongoose");
const LikeModel = require("../../../models/LikeModel");
const UserModel = require("../../../models/UserModel");
const jwt = require("jsonwebtoken");
const moment = require("moment-jalaali");
const NotificationModel = require("../../../models/NotificationModel");
const CommentModel = require("../../../models/CommentModel");
const { ProvinceModel, CityModel } = require("../../../models/StateCity");
const OfferModel = require("../../../models/OfferModel");
const PostModel = require("../../../models/PostModel");
const ProjectModel = require("../../../models/ProjectModel");
const LicenseModel = require("../../../models/license")


const getAllLicenses = async (req, res, next) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");

    jwt.verify(token, process.env.APP_SECRET);

    const { page = 1, limit = 10 } = req.query;

    const options = {
      page: parseInt(page),
      limit: parseInt(limit),
      sort: { createdAt: -1 },
      populate: {
        path: "userId",
        model: UserModel,
        select: "user_name first_name last_name is_verified profile_image",
      },
    };

    const licenses = await LicenseModel.paginate({}, options);

    const formattedLicenses = licenses.docs.map((license) => ({
      _id: license._id,
      userId: license.userId,
      Confirmation: license.Confirmation,
      licenseImg: license.licenseImg, // چون خودش Base64 هست
      createdAt: moment(license.createdAt).format("jYYYY-jMM-jDD HH:mm"),
      updatedAt: moment(license.updatedAt).format("jYYYY-jMM-jDD HH:mm"),
      user: license.userId,
    }));

    res.status(200).json({
      licenses: formattedLicenses,
      totalPages: licenses.totalPages,
      totalItems: licenses.totalDocs,
      currentPage: licenses.page,
    });
  } catch (error) {
    console.error("Error fetching licenses:", error);
    next(error);
  }
};


// GET: دریافت License بر اساس userId
const getLicenseByUserId = async (req, res, next) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");
    jwt.verify(token, process.env.APP_SECRET);

    const { userId } = req.params;

    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.status(400).json({ message: "شناسه کاربر معتبر نیست" });
    }

    const license = await LicenseModel.findOne({ userId }).populate({
      path: "userId",
      model: UserModel,
      select: "user_name first_name last_name is_verified profile_image",
    });

    if (!license) {
      return res.status(404).json({ message: "License یافت نشد" });
    }

    res.status(200).json(license); // licenseImg همان Base64 است
  } catch (error) {
    console.error("Error fetching license:", error);
    next(error);
  }
};



// POST: ذخیره License به صورت Base64
const createLicense = async (req, res, next) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");

    jwt.verify(token, process.env.APP_SECRET);

    const { userId, image } = req.body;

    if (!userId || !image) {
      return res.status(400).json({ message: "userId و تصویر الزامی هستند" });
    }

    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.status(400).json({ message: "شناسه کاربر معتبر نیست" });
    }

    if (!image.startsWith("data:image/")) {
      return res.status(400).json({ message: "فقط فایل‌های تصویری مجاز هستند" });
    }

    const existingLicense = await LicenseModel.findOne({ userId });
    if (existingLicense) {
      existingLicense.licenseImg = image;
      existingLicense.Confirmation = false; // نیاز به تأیید دوباره
      await existingLicense.save();

      return res.status(200).json({
        message: "تصویر مجوز با موفقیت به‌روزرسانی شد",
        license: existingLicense,
      });
    }

    const license = new LicenseModel({
      userId,
      Confirmation: false,
      licenseImg: image,
    });
    await license.save();

    res.status(201).json({ message: "License با موفقیت ذخیره شد", license });
  } catch (error) {
    console.error("Error saving license:", error);
    next(error);
  }
};


// PUT: به‌روزرسانی Confirmation و is_verified
const updateLicenseConfirmation = async (req, res, next) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");
    jwt.verify(token, process.env.APP_SECRET);

    const { userId } = req.params;
    const { Confirmation } = req.body;

    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.status(400).json({ message: "شناسه کاربر معتبر نیست" });
    }

    if (typeof Confirmation !== "boolean") {
      return res.status(400).json({ message: "Confirmation باید بولین باشد" });
    }

    const license = await LicenseModel.findOneAndUpdate(
      { userId },
      { Confirmation },
      { new: true }
    );

    if (!license) {
      return res.status(404).json({ message: "License یافت نشد" });
    }

    // اگر Confirmation به true تغییر کند، is_verified را به "true" به‌روزرسانی کن
    if (Confirmation) {
      await UserModel.findByIdAndUpdate(userId, { is_verified: "true" });
    }

    res.status(200).json({ message: "Confirmation به‌روزرسانی شد", license });
  } catch (error) {
    console.error("Error updating license:", error);
    next(error);
  }
};


// const getUsers = async (req, res, next) => {
//   try {
//     const token = req.header('Authorization').split(' ')[1]
//     if (!token) return res.status(401).send('Access Denied')

//     const decodedToken = jwt.verify(token, process.env.APP_SECRET)
//     const { expertise, page = 1, limit = 10 } = req.query
//     const filter = {}
//     if (expertise) {
//       filter.expertise = expertise
//     }

//     let users = await UserModel.aggregate([
//       { $match: filter },
//       { $match: { last_post: { $ne: null } } },
//       {
//         $addFields: {
//           'last_post.likesCount': { $size: { $ifNull: ['$last_post.likes', []] } }
//         }
//       },
//       {
//         $lookup: {
//           from: 'comments',
//           let: { userId: '$_id' },
//           pipeline: [
//             { $match: { $expr: { $and: [{ $eq: ['$user', '$$userId'] }, { $eq: ['$status', 'accepted'] }] } } },
//             { $count: 'commentsCount' }
//           ],
//           as: 'comments'
//         }
//       },
//       {
//         $addFields: {
//           commentsCount: { $arrayElemAt: ['$comments.commentsCount', 0] }
//         }
//       },
//       {
//         $project: {
//           user_level: 1,
//           first_name: 1,
//           last_name: 1,
//           user_name: 1,
//           is_verified: 1,
//           user_score: 1,
//           rate: 1,
//           profile_image: 1,
//           last_post: {
//             _id: 1,
//             post_image: 1,
//             caption: 1,
//             status: 1,
//             user_id: 1,
//             updatedAt: 1,
//             createdAt: 1,
//             __v: 1,
//             likesCount: 1,
//             is_liked: 1
//           },
//           commentsCount: 1
//         }
//       },
//       { $sort: { 'last_post.createdAt': -1 } }
//     ])

//     users = users.filter(user => user.last_post !== null)

//     if (!users || users.length === 0) {
//       return res.status(404).json({ message: 'هیچ کاربری با این مشخصات یافت نشد' })
//     }
//     users = await Promise.all(users.map(async (user) => {
//       const isLikedDocument = await LikeModel.findOne({ postId: user.last_post._id, userId: decodedToken.id })
//       user.last_post.is_liked = !!isLikedDocument
//       return user
//     }))

//     const startIndex = (page - 1) * limit
//     const endIndex = page * limit
//     const totalItems = users.length

//     const paginatedUsers = users.slice(startIndex, endIndex)
//     if (!users || users.length === 0) {
//       return res.status(404).json({ message: 'هیچ کاربری با این مشخصات یافت نشد' })
//     }

//     return res.status(200).json({
//       users: paginatedUsers,
//       totalPages: Math.ceil(totalItems / limit),
//       totalItems
//     })
//   } catch (error) {
//     next(error)
//   }
// }
const getUsers = async (req, res, next) => {
  try {
    const token = req.header("Authorization").split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");

    const decodedToken = jwt.verify(token, process.env.APP_SECRET);
    const {
      expertise,
      page = 1,
      limit = 10,
      province,
      city,
      userLevel,
      rateFilter,
    } = req.query;
    const filter = {};
    if (expertise) {
      filter.expertise = expertise;
    }
    if (province) {
      const provinceFind = await ProvinceModel.findOne(
        { id: province },
        { _id: 0 }
      );
      console.log("provinceFind:", provinceFind);
      if (provinceFind) {
        filter["province.id"] = provinceFind.id;
      }
    }
    if (city) {
      const cityFind = await CityModel.findOne({ id: city });
      console.log("cityFind:", cityFind);
      if (cityFind) {
        filter["city.id"] = cityFind.id;
      }
    }
    if (userLevel) {
      filter.user_level = userLevel;
    }

    let users = await UserModel.aggregate([
      { $match: filter },
      { $match: { last_post: { $ne: null } } },
      {
        $addFields: {
          "last_post.likesCount": {
            $size: { $ifNull: ["$last_post.likes", []] },
          },
        },
      },
      {
        $lookup: {
          from: "comments",
          let: { userId: "$_id" },
          pipeline: [
            {
              $match: {
                $expr: {
                  $and: [
                    { $eq: ["$user", "$$userId"] },
                    { $eq: ["$status", "accepted"] },
                  ],
                },
              },
            },
            { $count: "commentsCount" },
          ],
          as: "comments",
        },
      },
      {
        $addFields: {
          commentsCount: { $arrayElemAt: ["$comments.commentsCount", 0] },
        },
      },
      {
        $project: {
          user_level: 1,
          first_name: 1,
          last_name: 1,
          user_name: 1,
          is_verified: 1,
          user_score: 1,
          rate: 1,
          profile_image: 1,
          expertise: 1,
          hair_color: 1,
          eye_color: 1,
          height: 1,
          weight: 1,
          size: 1,
          services: 1,
          last_post: {
            _id: 1,
            post_image: 1,
            caption: 1,
            status: 1,
            user_id: 1,
            updatedAt: 1,
            createdAt: 1,
            __v: 1,
            likesCount: 1,
            is_liked: 1,
          },
          commentsCount: 1,
        },
      },
      { $sort: { "last_post.createdAt": -1 } },
    ]);

    users = users.filter((user) => user.last_post !== null);

    if (!users || users.length === 0) {
      return res
        .status(404)
        .json({ message: "هیچ کاربری با این مشخصات یافت نشد" });
    }

    users = await Promise.all(
      users.map(async (user) => {
        const isLikedDocument = await LikeModel.findOne({
          postId: user.last_post._id,
          userId: decodedToken.id,
        });
        user.last_post.is_liked = !!isLikedDocument;
        return user;
      })
    );

    if (rateFilter) {
      users.sort((a, b) => {
        if (rateFilter === "کمترین") {
          return a.rate - b.rate;
        } else if (rateFilter === "بیشترین") {
          return b.rate - a.rate;
        }
        return 0;
      });
    }

    const startIndex = (page - 1) * limit;
    const endIndex = page * limit;
    const totalItems = users.length;

    const paginatedUsers = users.slice(startIndex, endIndex);

    return res.status(200).json({
      users: paginatedUsers,
      totalPages: Math.ceil(totalItems / limit),
      totalItems,
    });
  } catch (error) {
    next(error);
  }
};
// const getUsersWeb = async (req, res, next) => {
//   try {
//     const token = req.header('Authorization')?.split(' ')[1]
//     const decodedToken = token && jwt.verify(token, process.env.APP_SECRET)

//     const { expertise, page = 1, limit = 10, province, city, userLevel, rateFilter } = req.query
//     const filter = {}
//     if (expertise) {
//       filter.expertise = expertise
//     }
//     if (province) {
//       const provinceFind = await ProvinceModel.findOne({ id: province }, { _id: 0 })
//       if (provinceFind) {
//         filter['province.id'] = provinceFind.id
//       }
//     }
//     if (city) {
//       const cityFind = await CityModel.findOne({ id: city })
//       if (cityFind) {
//         filter['city.id'] = cityFind.id
//       }
//     }
//     if (userLevel) {
//       filter.user_level = userLevel
//     }

//     let users = await UserModel.aggregate([
//       { $match: filter },
//       { $match: { last_post: { $ne: null } } },
//       {
//         $addFields: {
//           'last_post.likesCount': { $size: { $ifNull: ['$last_post.likes', []] } }
//         }
//       },
//       {
//         $lookup: {
//           from: 'comments',
//           let: { userId: '$_id' },
//           pipeline: [
//             { $match: { $expr: { $and: [{ $eq: ['$user', '$$userId'] }, { $eq: ['$status', 'accepted'] }] } } },
//             { $count: 'commentsCount' }
//           ],
//           as: 'comments'
//         }
//       },
//       {
//         $addFields: {
//           commentsCount: { $arrayElemAt: ['$comments.commentsCount', 0] }
//         }
//       },
//       {
//         $project: {
//           user_level: 1,
//           first_name: 1,
//           last_name: 1,
//           user_name: 1,
//           is_verified: 1,
//           user_score: 1,
//           rate: 1,
//           profile_image: 1,
//           expertise: 1,
//           hair_color: 1,
//           eye_color: 1,
//           height: 1,
//           weight: 1,
//           size: 1,
//           services: 1,
//           last_post: {
//             _id: 1,
//             post_image: 1,
//             caption: 1,
//             status: 1,
//             user_id: 1,
//             updatedAt: 1,
//             createdAt: 1,
//             __v: 1,
//             likesCount: 1,
//             is_liked: 1
//           },
//           commentsCount: 1
//         }
//       },
//       { $sort: { 'last_post.createdAt': -1 } }
//     ])
// const getUsersWeb = async (req, res, next) => {
//   try {
//     const token = req.header('Authorization')?.split(' ')[1]
//     const decodedToken = token && jwt.verify(token, process.env.APP_SECRET)

//     const { expertise, page = 1, limit = 10, province, city, userLevel, rateFilter, userId } = req.query
//     const filter = {}

//     if (expertise) filter.expertise = expertise
//     if (province) {
//       const provinceFind = await ProvinceModel.findOne({ id: province }, { _id: 0 })
//       if (provinceFind) filter['province.id'] = provinceFind.id
//     }
//     if (city) {
//       const cityFind = await CityModel.findOne({ id: city })
//       if (cityFind) filter['city.id'] = cityFind.id
//     }
//     if (userLevel) filter.user_level = userLevel

//     // ← اضافه کردن userId به فیلتر
//     if (userId) {
//       if (!mongoose.Types.ObjectId.isValid(userId)) {
//         return res.status(400).json({ message: 'شناسه کاربر معتبر نیست' })
//       }
//       filter._id = mongoose.Types.ObjectId(userId)
//     }

//     let users = await UserModel.aggregate([
//       { $match: filter },
//       { $match: { last_post: { $ne: null } } },
//       {
//         $addFields: {
//           'last_post.likesCount': { $size: { $ifNull: ['$last_post.likes', []] } }
//         }
//       },
//       {
//         $lookup: {
//           from: 'comments',
//           let: { userId: '$_id' },
//           pipeline: [
//             { $match: { $expr: { $and: [{ $eq: ['$user', '$$userId'] }, { $eq: ['$status', 'accepted'] }] } } },
//             { $count: 'commentsCount' }
//           ],
//           as: 'comments'
//         }
//       },
//       {
//         $addFields: {
//           commentsCount: { $arrayElemAt: ['$comments.commentsCount', 0] }
//         }
//       },
//       {
//         $project: {
//           user_level: 1,
//           first_name: 1,
//           last_name: 1,
//           user_name: 1,
//           is_verified: 1,
//           user_score: 1,
//           rate: 1,
//           profile_image: 1,
//           expertise: 1,
//           hair_color: 1,
//           eye_color: 1,
//           height: 1,
//           weight: 1,
//           size: 1,
//           services: 1,
//           last_post: 1,
//           commentsCount: 1
//         }
//       },
//       { $sort: { 'last_post.createdAt': -1 } }
//     ])

//     users = users.filter(user => user.last_post !== null)

//     if (!users || users.length === 0) {
//       return res.status(404).json({ message: 'هیچ کاربری با این مشخصات یافت نشد' })
//     }
//     // بررسی لایک‌ها فقط در صورت وجود توکن
//     if (token) {
//       users = await Promise.all(users.map(async (user) => {
//         const isLikedDocument = await LikeModel.findOne({ postId: user.last_post._id, userId: decodedToken.id })
//         user.last_post.is_liked = !!isLikedDocument
//         return user
//       }))
//     } else {
//       // اگر توکن وجود ندارد، مقدار پیش‌فرض را تنظیم کنید
//       users = users.map(user => {
//         user.last_post.is_liked = false
//         return user
//       })
//     }

//     if (rateFilter) {
//       users.sort((a, b) => {
//         if (rateFilter === 'کمترین') {
//           return a.rate - b.rate
//         } else if (rateFilter === 'بیشترین') {
//           return b.rate - a.rate
//         }
//         return 0
//       })
//     }

//     const startIndex = (page - 1) * limit
//     const endIndex = page * limit
//     const totalItems = users.length

//     const paginatedUsers = users.slice(startIndex, endIndex)

//     return res.status(200).json({
//       users: paginatedUsers,
//       totalPages: Math.ceil(totalItems / limit),
//       totalItems
//     })
//   } catch (error) {
//     next(error)
//   }
// }

// const getUsersWeb = async (req, res, next) => {
//   try {
//     const token = req.header("Authorization")?.split(" ")[1];
//     const decodedToken = token && jwt.verify(token, process.env.APP_SECRET);

//     const {
//       expertise,
//       page = 1,
//       limit = 10,
//       province,
//       city,
//       userLevel,
//       rateFilter,
//       _id,
//     } = req.query;

//     const filter = {};
//     if (expertise) filter.expertise = expertise;

//     if (province) {
//       const provinceFind = await ProvinceModel.findOne({ id: province }, { _id: 0 });
//       if (provinceFind) filter["province.id"] = provinceFind.id;
//     }

//     if (city) {
//       const cityFind = await CityModel.findOne({ id: city });
//       if (cityFind) filter["city.id"] = cityFind.id;
//     }

//     if (userLevel) filter.user_level = userLevel;
//     if (_id) filter._id = _id;

//     // پیدا کردن کاربران
//     let users = await UserModel.find(filter)
//       .select("-password -blocked_users -blocked_by")
//       .lean();

//     if (!users || users.length === 0) {
//       return res.status(404).json({ message: "هیچ کاربری با این مشخصات یافت نشد" });
//     }

//     // آماده‌سازی لیست userIds برای گرفتن همه پست‌ها یکجا
//     const userIds = users.map(u => u._id);

//     // گرفتن همه پست‌ها یکجا (به جای N+1 query)
//     let posts = await PostModel.find({ user_id: { $in: userIds }, status: { $ne: null } })
//       .sort({ createdAt: -1 })
//       .lean();

//     // گرفتن همه لایک‌های کاربران یکجا (برای بهبود کارایی)
//     let likeFilter = {};
//     if (decodedToken) likeFilter.userId = decodedToken.id;
//     const likes = decodedToken
//       ? await LikeModel.find({ userId: decodedToken.id, postId: { $in: posts.map(p => p._id) } }).lean()
//       : [];

//     const likesMap = {};
//     likes.forEach(l => { likesMap[l.postId.toString()] = true; });

//     // گرفتن تعداد کامنت‌ها یکجا برای همه کاربران
//     const comments = await CommentModel.aggregate([
//       { $match: { user: { $in: userIds }, status: "accepted" } },
//       { $group: { _id: "$user", count: { $sum: 1 } } }
//     ]);
//     const commentsMap = {};
//     comments.forEach(c => { commentsMap[c._id.toString()] = c.count; });

//     // اتصال پست‌ها و کامنت‌ها به کاربران
//     users = users.map(user => {
//       const userPosts = posts.filter(p => p.user_id.toString() === user._id.toString());
//       user.posts = userPosts.map(p => ({
//         ...p,
//         likesCount: p.likes ? p.likes.length : 0,
//         is_liked: !!likesMap[p._id.toString()]
//       }));
//       user.commentsCount = commentsMap[user._id.toString()] || 0;
//       return user;
//     });

//     // حذف کاربران بدون پست
//     users = users.filter(u => u.posts.length > 0);

//     // مرتب‌سازی
//     if (rateFilter) {
//       users.sort((a, b) => {
//         if (rateFilter === 'کمترین') return a.rate - b.rate;
//         if (rateFilter === 'بیشترین') return b.rate - a.rate;
//         return 0;
//       });
//     } else {
//       // مرتب‌سازی بر اساس جدیدترین پست آخر
//       users.sort((a, b) => new Date(b.posts[0].createdAt) - new Date(a.posts[0].createdAt));
//     }

//     // صفحه‌بندی
//     const startIndex = (page - 1) * limit;
//     const endIndex = page * limit;
//     const totalItems = users.length;
//     const paginatedUsers = users.slice(startIndex, endIndex);

//     return res.status(200).json({
//       users: paginatedUsers,
//       totalPages: Math.ceil(totalItems / limit),
//       totalItems,
//     });

//   } catch (error) {
//     console.error(error);
//     next(error);
//   }
// };

const getPostsWeb = async (req, res, next) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    const decodedToken = token ? jwt.verify(token, process.env.APP_SECRET) : null;

    const {
      expertise,
      page = 1,
      limit = 10,
      province,
      city,
      userLevel,
      rateFilter,
      _id,
      type,
    } = req.query;

    const postFilter = { status: { $ne: null } };
    if (type === 'video' || type === 'image') {
      postFilter.type = type;
    }

    // اکسپلور: ویدئوهای همه کاربران بدون فیلتر تخصص
    if (type === 'video' && !expertise && !_id && !province && !city) {
      let explorePosts = await PostModel.find(postFilter)
        .sort({ createdAt: -1 })
        .lean();
      const userIds = [...new Set(explorePosts.map((p) => String(p.user_id)))];
      const usersMap = await UserModel.find({ _id: { $in: userIds } })
        .select('_id user_name first_name last_name expertise province city user_level')
        .lean();
      const usersById = Object.fromEntries(usersMap.map((u) => [String(u._id), u]));
      explorePosts = explorePosts.map((post) => {
        const user = usersById[String(post.user_id)] || {};
        return {
          ...post,
          user_name: user.user_name || '',
          first_name: user.first_name || '',
          last_name: user.last_name || '',
          expertise: user.expertise || '',
          province: user.province || {},
          city: user.city || {},
          user_level: user.user_level || '',
          likesCount: post.likes ? post.likes.length : 0,
          is_liked: false,
          commentsCount: 0
        };
      });
      const startIndex = (page - 1) * limit;
      const paginatedPosts = explorePosts.slice(startIndex, startIndex + parseInt(limit));
      return res.status(200).json({
        posts: paginatedPosts,
        totalPages: Math.ceil(explorePosts.length / limit) || 1,
        totalItems: explorePosts.length
      });
    }

    const userFilter = {};

    if (expertise) userFilter.expertise = expertise;
    if (province) {
      const provinceFind = await ProvinceModel.findOne({ id: province }, { _id: 0 });
      if (provinceFind) userFilter["province.id"] = provinceFind.id;
    }
    if (city) {
      const cityFind = await CityModel.findOne({ id: city });
      if (cityFind) userFilter["city.id"] = cityFind.id;
    }
    if (userLevel) userFilter.user_level = userLevel;
    if (_id) userFilter._id = _id;

    const users = await UserModel.find(userFilter)
      .select("_id user_name first_name last_name expertise province city user_level")
      .lean();

    if (!users || users.length === 0) {
      return res.status(200).json({ posts: [], totalPages: 0, totalItems: 0 });
    }

    const userIds = users.map(u => u._id);
    postFilter.user_id = { $in: userIds };

    let posts = await PostModel.find(postFilter)
      .sort({ createdAt: -1 })
      .lean();

    if (!posts || posts.length === 0) {
      return res.status(200).json({ posts: [], totalPages: 0, totalItems: 0 });
    }

    let likeFilter = {};
    if (decodedToken) likeFilter.userId = decodedToken.id;
    const likes = decodedToken
      ? await LikeModel.find({ userId: decodedToken.id, postId: { $in: posts.map(p => p._id) } }).lean()
      : [];

    const likesMap = {};
    likes.forEach(l => { likesMap[l.postId.toString()] = true; });

    const comments = await CommentModel.aggregate([
      { $match: { post: { $in: posts.map(p => p._id) }, status: "accepted" } },
      { $group: { _id: "$post", count: { $sum: 1 } } }
    ]);
    const commentsMap = {};
    comments.forEach(c => { commentsMap[c._id.toString()] = c.count; });

    posts = posts.map(post => {
      const user = users.find(u => u._id.toString() === post.user_id.toString());
      return {
        ...post,
        user_name: user?.user_name || "",
        first_name: user?.first_name || "",
        last_name: user?.last_name || "",
        expertise: user?.expertise || "",
        province: user?.province || {},
        city: user?.city || {},
        user_level: user?.user_level || "",
        likesCount: post.likes ? post.likes.length : 0,
        is_liked: !!likesMap[post._id.toString()],
        commentsCount: commentsMap[post._id.toString()] || 0,
      };
    });

    if (rateFilter) {
      posts.sort((a, b) => {
        if (rateFilter === 'کمترین') return (a.rate || 0) - (b.rate || 0);
        if (rateFilter === 'بیشترین') return (b.rate || 0) - (a.rate || 0);
        return 0;
      });
    }

    const startIndex = (page - 1) * limit;
    const endIndex = page * limit;
    const totalItems = posts.length;
    const paginatedPosts = posts.slice(startIndex, endIndex);

    return res.status(200).json({
      posts: paginatedPosts,
      totalPages: Math.ceil(totalItems / limit),
      totalItems,
    });

  } catch (error) {
    console.error("Error in getPostsWeb:", error.message, error.stack);
    return res.status(500).json({ message: "خطای سرور: " + error.message });
  }
};

const getSingleUser = async (req, res, next) => {
  try {
    const token = req.header("Authorization").split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");
    const user_id = req.query.user_id;
    // eslint-disable-next-line no-unused-vars
    const decodedToken = jwt.verify(token, process.env.APP_SECRET);
    const userReqId = decodedToken.id;

    if (!mongoose.Types.ObjectId.isValid(user_id)) {
      return res.status(400).json({ message: "شناسه کاربر معتبر نیست" });
    }
    const user = await UserModel.findById(user_id);

    if (!user) {
      return res.status(404).json({ message: "کاربر مورد نظر یافت نشد" });
    }
    const shamsiDate = moment(user.created_at).format("jYYYY-jMM-jDD");
    const lastOnline = moment(user.last_online).format("jYYYY-jMM-jDD");

    // بررسی بلاک شدن
    const blockedByCurrentUser = user.blocked_by.includes(userReqId);
    const blockedYou = user.blocked_users.includes(userReqId);

    // Allow chat
    const offerExists = await OfferModel.exists({
      $or: [
        { sender: userReqId, receiver: user_id },
        { sender: user_id, receiver: userReqId },
      ],
    });
    const response = {
      is_self: user_id.toString() === userReqId.toString() ? "true" : "false",
      _id: user._id,
      last_online: lastOnline,
      created_at: shamsiDate,
      user_type: user.user_type,
      user_level: user.user_level,
      first_name: user.first_name,
      last_name: user.last_name,
      user_name: user.user_name,
      show_location: user.show_location,
      is_verified: user.is_verified,
      user_score: user.user_score,
      rate: user.rate,
      bio: user.bio,
      height: user.height,
      weight: user.weight,
      size: user.size,
      eye_color: user.eye_color,
      hair_color: user.hair_color,
      profile_image: user.profile_image,
      lat: user.show_location ? user.lat : null,
      lng: user.show_location ? user.lng : null,
      province: user.province,
      city: user.city,
      address: user.show_location ? user.address : null,
      is_blocked: blockedByCurrentUser,
      blocked_you: blockedYou,
      offer_status: !!offerExists,
 monthly_free_offer: user.monthly_free_offer,
      services: user.services,
      expertise: user.expertise,
      sub_expertise: user.sub_expertise,
    };
    return res.status(200).json({ user: response });
  } catch (error) {
    next(error);
  }
};
const getSingleUserWeb = async (req, res, next) => {
  try {
    let userReqId = null;

    // دریافت توکن و بررسی معتبر بودنش (اگر وجود داشت)
    const authHeader = req.header("Authorization");
    if (authHeader) {
      const token = authHeader.split(" ")[1];
      try {
        const decodedToken = jwt.verify(token, process.env.APP_SECRET);
        userReqId = decodedToken.id;
      } catch (err) {
        console.warn("توکن نامعتبر است، ادامه بدون احراز هویت"); // فقط هشدار، نه ارور
      }
    }

    let user;
    const { user_id, user_name } = req.query;

    if (user_id) {
      if (!mongoose.Types.ObjectId.isValid(user_id)) {
        return res.status(400).json({ message: "شناسه کاربر معتبر نیست" });
      }
      user = await UserModel.findById(user_id);
    } else if (user_name) {
      user = await UserModel.findOne({ user_name });
    } else {
      return res
        .status(400)
        .json({ message: "لطفاً user_id یا user_name ارسال کنید" });
    }

    if (!user) {
      return res.status(404).json({ message: "کاربر مورد نظر یافت نشد" });
    }

    const shamsiDate = moment(user.created_at).format("jYYYY-jMM-jDD");
    const lastOnline = moment(user.last_online).format("jYYYY-jMM-jDD");

    // بررسی بلاک شدن (فقط اگر توکن معتبر داشتیم)
    let blockedByCurrentUser = false;
    let blockedYou = false;
    let offerExists = false;

    if (userReqId) {
      blockedByCurrentUser = user.blocked_by.includes(userReqId);
      blockedYou = user.blocked_users.includes(userReqId);
      offerExists = await OfferModel.exists({
        sender: userReqId,
        receiver: user._id,
      });
    }
    // دریافت تعداد پست‌ها و پروژه‌ها
    const postsCount = await PostModel.countDocuments({
      user_id: user._id,
      status: { $in: ["accept"] },
    });
    const allProjectsCount = await ProjectModel.countDocuments({
      selected_user: user._id,
    });
    const successfulProjectsCount = await ProjectModel.countDocuments({
      selected_user: user._id,
      status: "done",
    });

    const response = {
      is_self: userReqId
        ? user._id.toString() === userReqId.toString()
        : "false",
      _id: user._id,
      last_online: lastOnline,
      created_at: shamsiDate,
      user_type: user.user_type,
      user_level: user.user_level,
      first_name: user.first_name,
      last_name: user.last_name,
      user_name: user.user_name,
      show_location: user.show_location,
      is_verified: user.is_verified,
      user_score: user.user_score,
      rate: user.rate,
      bio: user.bio,
      height: user.height,
      weight: user.weight,
      size: user.size,
      eye_color: user.eye_color,
      hair_color: user.hair_color,
      profile_image: user.profile_image,
      lat: user.show_location ? user.lat : null,
      lng: user.show_location ? user.lng : null,
      province: user.province,
      city: user.city,
      address: user.show_location ? user.address : null,
      is_blocked: blockedByCurrentUser,
      blocked_you: blockedYou,
      offer_status: !!offerExists,
      services: user.services,
      expertise: user.expertise,
      sub_expertise: user.sub_expertise,
      postsCount,
      allProjectsCount,
      successfulProjectsCount,
    };

    return res.status(200).json({ user: response });
  } catch (error) {
    next(error);
  }
};
const getUserContactInfo = async (req, res, next) => {
  try {
    const token = req.header("Authorization").split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");
    // eslint-disable-next-line no-unused-vars
    const decodedToken = jwt.verify(token, process.env.APP_SECRET);
    const user_id = decodedToken.id;

    if (!mongoose.Types.ObjectId.isValid(user_id)) {
      return res.status(400).json({ message: "شناسه کاربر معتبر نیست" });
    }
    const user = await UserModel.findById(user_id);

    if (!user) {
      return res.status(404).json({ message: "کاربر مورد نظر یافت نشد" });
    }

    const response = {
      contactInfo: user?.contactInfo,
      _id: user._id,
    };
    return res.status(200).json({ data: response });
  } catch (error) {
    next(error);
  }
};
const blockUser = async (req, res) => {
  try {
    const { user_to_block } = req.body;
    const token = req.header("Authorization").split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");
    const decodedToken = jwt.verify(token, process.env.APP_SECRET);
    const userReqId = decodedToken.id;

    const currentUser = await UserModel.findById(userReqId); // Req
    const userToBlock = await UserModel.findById(user_to_block); // To Block

    userToBlock.blocked_by.push(currentUser);
    currentUser.blocked_users.push(userToBlock);

    // بررسی تعداد بلاک ها و تنظیم block_status
    if (userToBlock.blocked_by.length >= 3) {
      userToBlock.block_status = true;
    }

    await currentUser.save();
    await userToBlock.save();

    res.status(200).json({ message: "کاربر با موفقیت بلاک شد" });
  } catch (error) {
    console.error("Error blocking user:", error);
    res.status(500).json({ error: "Server error" });
  }
};

const unblockUser = async (req, res) => {
  try {
    const { user_to_unblock } = req.body;
    const token = req.header("Authorization").split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");
    const decodedToken = jwt.verify(token, process.env.APP_SECRET);
    const userReqId = decodedToken.id;

    const currentUser = await UserModel.findById(userReqId); // Req
    const userToUnblock = await UserModel.findById(user_to_unblock); // To Unblock

    // حذف کاربر از لیست blocked_by کاربر فعلی
    currentUser.blocked_users.pull(userToUnblock._id);
    // حذف کاربر از لیست blocked_users کاربر مورد نظر
    userToUnblock.blocked_by.pull(currentUser._id);

    // بررسی تعداد بلاک ها و تنظیم block_status
    if (userToUnblock.blocked_by.length < 3) {
      userToUnblock.block_status = null;
    }

    await currentUser.save();
    await userToUnblock.save();

    res.status(200).json({ message: "کاربر با موفقیت آنبلاک شد" });
  } catch (error) {
    console.error("Error unblocking user:", error);
    res.status(500).json({ error: "Server error" });
  }
};

const getComments = async (req, res, next) => {
  try {
    const token = req.header("Authorization").split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");
    const user_id = req.query.user_id;
    const post_id = req.query.post_id;

    if (!mongoose.Types.ObjectId.isValid(user_id)) {
      return res.status(400).json({ message: "شناسه کاربر معتبر نیست" });
    }
    const user = await UserModel.findById(user_id);
    const { page = 1, limit = 10 } = req.query;
    if (!user) {
      return res.status(404).json({ message: "کاربر مورد نظر یافت نشد" });
    }

    const filter = { user: user_id, status: "accepted" };
    if (post_id && mongoose.Types.ObjectId.isValid(post_id)) {
      filter.post = post_id;
    }

    const options = {
      page: parseInt(page),
      limit: parseInt(limit),
      sort: { createdAt: -1 },
      populate: [
        { path: "creator", select: "user_name profile_image is_verified" },
        { path: "project", select: "project_name" },
      ],
    };

    const comments = await CommentModel.paginate(filter, options);

    const formattedComments = comments.docs.map((comment) => ({
      _id: comment._id,
      comment: comment.comment,
      rating: comment.rating,
      createdAt: moment(comment.createdAt).format("jYYYY-jMM-jDD HH:mm"),
      status: comment.status,
      user: {
        profile_image: comment.creator.profile_image,
        user_name: comment.creator.user_name,
        is_verified: comment.creator.is_verified,
        _id: comment.creator._id,
      },
      project: comment.project ? comment.project.project_name : null,
      post_id: comment.post ? comment.post.toString() : null,
    }));

    res.status(200).json({
      comments: formattedComments,
      totalPages: comments.totalPages,
      totalItems: comments.totalDocs,
      currentPage: comments.page,
    });
  } catch (error) {
    next(error);
  }
};
const createUserComment = async (req, res, next) => {
  try {
    const token = req.header("Authorization").split(" ")[1];
    if (!token) return res.status(401).send("Access Denied");

    const decodedToken = jwt.verify(token, process.env.APP_SECRET);
    const creatorId = decodedToken.id;

    const { user_id, comment, rate, post_id } = req.body;
    if (!user_id || !comment) {
      return res.status(400).send({ message: "All fields are required" });
    }

    const existingRating = await CommentModel.findOne({
      user: user_id,
      creator: creatorId,
      comment_for: post_id ? "post" : "user",
      rating: { $exists: true, $ne: null }
    });

    let ratingValue = rate;
    if (existingRating) {
      ratingValue = existingRating.rating;
    } else {
      if (!rate || rate < 1 || rate > 5) {
        return res.status(400).send({ message: "Rating must be between 1 and 5" });
      }
    }

    const newComment = new CommentModel({
      user: user_id,
      creator: creatorId,
      rating: ratingValue,
      comment,
      comment_for: post_id ? "post" : "user",
      post: post_id || undefined,
      status: "pending",
    });
    await newComment.save();

    const user = await UserModel.findById(user_id);

    // محاسبه امتیاز جدید کاربر
    const comments = await CommentModel.find({
      user: user_id,
      comment_for: "user",
    });
    const totalRating = comments.reduce(
      (acc, comment) => acc + comment.rating,
      0
    );
    const totalComments = comments.length;
    const averageRating = totalRating / totalComments;

    // تعیین سطح کاربر
    let userLevel;
    if (user.expertise === "مدل") {
      if (totalRating <= 50) userLevel = "تازه وارد";
      else if (totalRating <= 100) userLevel = "استاندارد";
      else if (totalRating <= 300) userLevel = "حرفه‌ای";
      else userLevel = "استاد";
    } else if (["زیبایی", "عکاس"].includes(user.expertise)) {
      if (totalRating <= 50) userLevel = "تازه وارد";
      else if (totalRating <= 100) userLevel = "استاندارد";
      else if (totalRating <= 300) userLevel = "حرفه‌ای";
      else userLevel = "استاد";
    }

    // به‌روزرسانی اطلاعات کاربر
    user.user_score = totalRating;
    user.user_level = userLevel;
    user.rate = averageRating.toFixed(1);
    await user.save();

    // ارسال نوتیفیکیشن
    const notification = new NotificationModel({
      user_id: user._id,
      type: "user_comment",
      title: "نظر جدید",
      description: `یک کاربر جدید برای شما نظر ثبت کرد:
      ${comment}
      امتیاز: ${rate} از 5`,
    });
    await notification.save();

    res.status(201).json({
      message: "نظر با موفقیت ثبت شد و بعد از تایید، منتشر میشود.",
      comment: newComment,
    });
  } catch (error) {
    next(error);
  }
};

const inviteEmployer = async (req, res, next) => {
  const token = req.header("Authorization").split(" ")[1];
  if (!token) return res.status(401).send("Access Denied");
  const user_id = req.query.user_id;
  // eslint-disable-next-line no-unused-vars
  const decodedToken = jwt.verify(token, process.env.APP_SECRET);
  const userReqId = decodedToken.id;

  if (!mongoose.Types.ObjectId.isValid(user_id)) {
    return res.status(400).json({ message: "شناسه کاربر معتبر نیست" });
  }
  const user = await UserModel.findById(user_id);
  const creatorUser = await UserModel.findById(userReqId);

  if (!user) {
    return res.status(404).json({ message: "کاربر مورد نظر یافت نشد" });
  }

  const today = new Date();
  today.setHours(0, 0, 0, 0);

  const existingNotification = await NotificationModel.findOne({
    user_id: user._id,
    project_post_id: userReqId,
    type: "invite",
    createdAt: { $gte: today },
  });

  if (existingNotification) {
    return res
      .status(400)
      .json({
        message: "شما امروز برای این کارفرما درخواست همکاری ارسال کرده اید.",
        type: "today",
      });
  }
  const notification = new NotificationModel({
    user_id: user._id,
    project_post_id: userReqId,
    type: "invite",
    title: "دعوت به همکاری",
    description: `کاربر ${creatorUser.user_name} شما را برای همکاری دعوت کرده است.`,
  });
  await notification.save();

  res.status(201).json({ message: "درخواست همکاری با موفقیت ثبت شد" });
};

module.exports = {
  getUsers,
  getSingleUser,
  blockUser,
  unblockUser,
  getComments,
  inviteEmployer,
  getUserContactInfo,
  getPostsWeb,
  getSingleUserWeb,
  createUserComment,
  getAllLicenses,
  getLicenseByUserId,
  createLicense,
  updateLicenseConfirmation,
};
