const jwt = require("jsonwebtoken");
const fs = require("fs-extra");
const path = require("path");
const jMoment = require("moment-jalaali");
const AcademyContentModel = require("../../../models/AcademyContentModel");
const AcademyModel = require("../../../models/AcademyModel");
const AcademyPaymentModel = require("../../../models/AcademyPaymentModel");
const CourseModel = require("../../../models/CourseModel");
const CoursePaymentModel = require("../../../models/CoursePaymentModel");
const UserModel = require("../../../models/UserModel");
const PaymentModel = require("../../../models/PaymentModel");
const { default: axios } = require("axios");
const AcademyLikeModel = require("../../../models/AcademyLikeModel");
const CourseComment = require("../../../models/CourseComentModel");
const IsPaymentCourse = require("../../../models/IsPaymentCourseModel");
const Tax = require("../../../models/TaxModel");
const AcademyCategoryModel = require('../../../models/AcademyCategoryModel');

const onServerRestart = async () => {
  const CoursePayment = await CoursePaymentModel.findOne({
    cuorse_type: "pro",
  });
  if (!CoursePayment) {
    const newCoursePayment = new CoursePaymentModel({
      price: "60000",
      cuorse_type: "pro",
    });
    await newCoursePayment.save();

    return console.log("اشتراک پرو ساخته شد");
  }

  console.log("اشتراک پرو موجود هست");
  const tax = await Tax.findOne({
    type: "course",
  });
  if (!tax) {
    const newTax = new Tax({
      tax: 8,
      type: "course",
    });
    await newTax.save();

    return console.log("تکس ساخته شد");
  }

  console.log(" تکس موجود هست");
};
onServerRestart();

const findAcademy = 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 userId = decodedToken.id;

    const user = await UserModel.findById(userId);
    if (!user) {
      return res.status(422).json({
        error: true,
        message: "کاربر یافت نشد",
      });
    }
    const academy = await AcademyModel.findOne({ userId: userId });
    if (!academy) {
      const newAcademy = new AcademyModel({
        userId: userId,
      });
      await newAcademy.save();

      return res.status(200).json({
        academy: newAcademy,
      });
    }

    res.status(200).json({
      academy: academy,
    });
  } catch (error) {
    // در صورت بروز خطا، ارسال پیام خطا به کاربر
    console.error("Error:", error);
    res.status(500).json({ message: "err in creat" });
  }
};
const findAcademyById = async (req, res, next) => {
  try {
    const { _id } = req.body;

    const academy = await AcademyModel.findById(_id);
    if (!academy) {
      res.status(500).json({
        academy: "اکادمی موحود نیست",
      });
    }

    res.status(200).json({
      academy: academy,
    });
  } catch (error) {
    // در صورت بروز خطا، ارسال پیام خطا به کاربر
    console.error("Error:", error);
    res.status(500).json({ message: "err in creat" });
  }
};
const academyProfile = 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 userId = decodedToken.id;

    const user = await UserModel.findById(userId);
    if (!user) {
      return res.status(422).json({
        error: true,
        message: "کاربر یافت نشد",
      });
    }
    const academy = await AcademyModel.findOne({ userId: userId });
    if (!academy) {
      return res.status(200).json({
        message: "اکادمی پیدا نشد",
      });
    }

    const { profile_image } = req.files;
    const { name, sheba, bio, tag } = req.body;

    if (!profile_image) {
      return res.status(422).json({
        error: true,
        message: "اطلاعات ارسالی اشتباه است",
      });
    }

    const uploadDir = path.join(__dirname, "../../../../storage/profiles");
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true });
    }

    const uniqueFileName = `${name}-${Date.now()}${path.extname(
      profile_image.name
    )}`;
    const filePath = path.join(uploadDir, uniqueFileName);

    await fs.move(profile_image.path, filePath);

    academy.academy_image = `/profiles/${uniqueFileName}`;
    academy.academy_name = name;
    academy.sheba = sheba;
    academy.bio = bio;
    academy.tag = tag;
    await academy.save();

    res.status(200).json({
      message: "ثبت شد",
    });
  } catch (error) {
    // در صورت بروز خطا، ارسال پیام خطا به کاربر
    console.error("Error:", error);
    res.status(500).json({ message: "err in update" });
  }
};

const creatCourse = 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 userId = decodedToken.id;

    const user = await UserModel.findById(userId);
    if (!user) {
      return res.status(422).json({
        error: true,
        message: "کاربر یافت نشد",
      });
    }

    const academy = await AcademyModel.findOne({ userId: userId });
    if (!academy) {
      return res.status(200).json({
        message: "اکادمی پیدا نشد",
      });
    }
    const {
      price,
      cuorse_name,
      category,
      offer,
      caption,
      course_time,
      number_of_course_content,
      teacher_number,
      teacher_name,
    } = req.body;

    const { course_image } = req.files;

    if (!course_image) {
      return res.status(422).json({
        error: true,
        message: "اطلاعات ارسالی اشتباه است",
      });
    }

    const uploadDir = path.join(__dirname, "../../../../storage/profiles");
    if (!fs.existsSync(uploadDir)) {
      fs.mkdirSync(uploadDir, { recursive: true });
    }

    const uniqueFileName = `${cuorse_name}-${Date.now()}${path.extname(
      course_image.name
    )}`;
    const filePath = path.join(uploadDir, uniqueFileName);

    await fs.move(course_image.path, filePath);

    // ✅ ایجاد رکورد جدید
    const newAcademy = new CourseModel({
      course_image: `/profiles/${uniqueFileName}`,
      price,
      cuorse_name,
      category,
      offer,
      teacher_name,
      academyId: academy._id,
      caption,
      course_time,
      number_of_course_content,
      teacher_number,
    });

    await newAcademy.save();

    res.status(200).json({
      message: "ثبت شد",
    });
  } catch (error) {
    // در صورت بروز خطا، ارسال پیام خطا به کاربر
    console.error("Error:", error);
    res.status(500).json({ message: "err in update" });
  }
};

const updateCourse = 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 userId = decodedToken.id;

    const {
      price,
      cuorse_name,
      category,
      offer,
      courseId,
      teacher_name,
      caption,
      course_time,
      number_of_course_content,
      teacher_number,
    } = req.body;

    // اعتبارسنجی courseId
    if (!courseId) {
      return res.status(422).json({
        error: true,
        message: "آیدی دوره الزامی است",
      });
    }

    const user = await UserModel.findById(userId);
    if (!user) {
      return res.status(422).json({
        error: true,
        message: "کاربر یافت نشد",
      });
    }

    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.status(422).json({
        error: true,
        message: "پکیجی یافت نشد",
      });
    }

    // ========== آپلود عکس جدید (اختیاری) ==========
    const { course_image } = req.files || {};

    if (course_image) {
      // فقط اگه عکس جدید آپلود شده بود، آپلود کن
      const uploadDir = path.join(__dirname, "../../../../storage/profiles");
      if (!fs.existsSync(uploadDir)) {
        fs.mkdirSync(uploadDir, { recursive: true });
      }

      // استفاده از id به جای نام دوره برای نام فایل
      const safeFileName = `course-${courseId}-${Date.now()}${path.extname(
        course_image.name
      )}`;
      const filePath = path.join(uploadDir, safeFileName);

      await fs.move(course_image.path, filePath);
      course.course_image = `/profiles/${safeFileName}`;
    }

    // ========== به روز رسانی فیلدها (فقط فیلدهایی که ارسال شده) ==========
    if (price !== undefined) course.price = price;
    if (cuorse_name !== undefined) course.cuorse_name = cuorse_name;
    if (category !== undefined) course.category = category;
    if (offer !== undefined) course.offer = offer;
    if (caption !== undefined) course.caption = caption;
    if (course_time !== undefined) course.course_time = course_time;
    if (number_of_course_content !== undefined)
      course.number_of_course_content = number_of_course_content;
    if (teacher_number !== undefined) course.teacher_number = teacher_number;
    if (teacher_name !== undefined) course.teacher_name = teacher_name;

    await course.save();

    res.status(200).json({
      success: true,
      message: "دوره با موفقیت به روز رسانی شد",
      data: {
        course: course,
      },
    });
  } catch (error) {
    console.error("Error in updateCourse:", error);
    res.status(500).json({
      success: false,
      message: "خطا در به روز رسانی دوره",
      error: error.message,
    });
  }
};
const deleteCourse = 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 userId = decodedToken.id;
    const { courseId } = req.body;

    const user = await UserModel.findById(userId);
    if (!user) {
      return res.status(422).json({
        error: true,
        message: "کاربر یافت نشد",
      });
    }
    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.status(422).json({
        error: true,
        message: "پکیجی یافت نشد",
      });
    }

    course.status = "reject";
    await course.save();

    res.status(200).json({
      message: "ثبت شد",
    });
  } catch (error) {
    // در صورت بروز خطا، ارسال پیام خطا به کاربر
    console.error("Error:", error);
    res.status(500).json({ message: "err in update" });
  }
};
const getCourse = 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 userId = decodedToken.id;

    // گرفتن پارامترهای صفحه‌بندی
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const skip = (page - 1) * limit;

    const user = await UserModel.findById(userId);
    if (!user) {
      return res.status(422).json({
        error: true,
        message: "کاربر یافت نشد",
      });
    }

    const academy = await AcademyModel.findOne({ userId: userId });
    if (!academy) {
      return res.status(404).json({
        success: false,
        message: "آکادمی پیدا نشد",
      });
    }

    // ✅ شرط جستجو - فقط دوره‌های تایید شده
    const query = {
      academyId: academy._id,
      status: "accept",
    };

    // دریافت تعداد کل دوره‌های تایید شده
    const totalCourses = await CourseModel.countDocuments(query);

    // دریافت دوره‌های تایید شده با صفحه‌بندی
    const courses = await CourseModel.find(query)
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(limit);

    // ✅ اگر دوره‌ای وجود نداشت، خطا نده، بلکه آرایه خالی برگردون
    if (!courses || courses.length === 0) {
      return res.status(200).json({
        success: true,
        message: "هیچ دوره تایید شده‌ای یافت نشد",
        data: {
          courses: [],
          pagination: {
            currentPage: page,
            totalPages: 0,
            totalItems: 0,
            itemsPerPage: limit,
            hasNextPage: false,
            hasPrevPage: false,
            nextPage: null,
            prevPage: null,
          },
        },
      });
    }

    // محاسبات صفحه‌بندی
    const totalPages = Math.ceil(totalCourses / limit);
    const hasNextPage = page < totalPages;
    const hasPrevPage = page > 1;

    res.status(200).json({
      success: true,
      message: "لیست پکیج‌ها با موفقیت دریافت شد",
      data: {
        courses: courses,
        pagination: {
          currentPage: page,
          totalPages: totalPages,
          totalItems: totalCourses,
          itemsPerPage: limit,
          hasNextPage: hasNextPage,
          hasPrevPage: hasPrevPage,
          nextPage: hasNextPage ? page + 1 : null,
          prevPage: hasPrevPage ? page - 1 : null,
        },
      },
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت پکیج‌ها",
      error: error.message,
    });
  }
};

const getCourses = async (req, res, next) => {
  try {
    // ========== 3. دریافت پارامترهای صفحه‌بندی ==========
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const skip = (page - 1) * limit;

    // ========== 4. دریافت پارامترهای جستجو ==========
    const search = req.query.search || "";
    const category = req.query.category || "";
    const minPrice = req.query.minPrice ? parseInt(req.query.minPrice) : 0;
    const maxPrice = req.query.maxPrice
      ? parseInt(req.query.maxPrice)
      : 100000000;
    const hasOffer = req.query.hasOffer === "true"; // تخفیف دار
    const teacherName = req.query.teacherName || "";
    const type = req.query.type || ""; // normal, pro, legend
    const status = req.query.status || "all"; // pending, accept, reject
    const sortBy = req.query.sortBy || "createdAt";
    const sortOrder = req.query.sortOrder === "asc" ? 1 : -1;
    const _id = req.query._id || "";
    // ========== 5. ساخت شرط جستجو (Query) ==========
    let query = {};

    // جستجو در نام دوره و کپشن
    if (search) {
      query.$or = [
        { cuorse_name: { $regex: search, $options: "i" } },
        { caption: { $regex: search, $options: "i" } },
        { teacher_name: { $regex: search, $options: "i" } },
      ];
    }

    // فیلتر بر اساس دسته بندی
    if (category) {
      query.category = category;
    }
    if (_id) {
      query._id = _id;
    }
    // فیلتر بر اساس محدوده قیمت (تبدیل به عدد برای مقایسه)
    if (minPrice > 0 || maxPrice < 100000000) {
      query.price = {
        $gte: minPrice.toString(),
        $lte: maxPrice.toString(),
      };
    }

    // فیلتر بر اساس تخفیف دار (offer وجود داشته باشد و از 0 بیشتر باشد)
    if (hasOffer) {
      query.offer = { $exists: true, $ne: "0", $ne: "" };
    }

    // فیلتر بر اساس نام مدرس
    if (teacherName) {
      query.teacher_name = { $regex: teacherName, $options: "i" };
    }

    // فیلتر بر اساس نوع دوره
    if (type) {
      query.type = type;
    }

    // فیلتر بر اساس وضعیت
    if (status !== "all") {
      query.status = status;
    }

    // ========== 6. دریافت آمار و اطلاعات ==========
    // تعداد کل پکیج‌ها (بدون صفحه‌بندی)
    const totalCourses = await CourseModel.countDocuments(query);

    // مجموع قیمت‌ها (تبدیل به عدد برای محاسبه)
    const priceStats = await CourseModel.aggregate([
      { $match: query },
      {
        $group: {
          _id: null,
          total: { $sum: { $toDouble: "$price" } },
          avg: { $avg: { $toDouble: "$price" } },
          min: { $min: { $toDouble: "$price" } },
          max: { $max: { $toDouble: "$price" } },
        },
      },
    ]);

    // تعداد دوره‌های با تخفیف
    const offeredCourses = await CourseModel.countDocuments({
      ...query,
      offer: { $exists: true, $ne: "0", $ne: "" },
    });

    // تعداد دوره‌ها بر اساس نوع
    const typeStats = await CourseModel.aggregate([
      { $match: query },
      {
        $group: {
          _id: "$type",
          count: { $sum: 1 },
        },
      },
    ]);

    // ========== 7. دریافت پکیج‌ها با صفحه‌بندی ==========
    const courses = await CourseModel.find(query)
      .populate("user_id", "name email") // اطلاعات کاربر سازنده
      .populate("likes", "name") // اطلاعات لایک‌ها
      .sort({ [sortBy]: sortOrder })
      .skip(skip)
      .limit(limit)
      .lean();

    // پردازش داده‌ها برای خروجی
    const processedCourses = courses.map((course) => ({
      ...course,
      priceNumber: parseInt(course.price) || 0,
      offerNumber: parseInt(course.offer) || 0,
      finalPrice: course.offer
        ? (parseInt(course.price) * (100 - parseInt(course.offer))) / 100
        : parseInt(course.price),
      likesCount: course.likes?.length || 0,
    }));

    // ========== 8. محاسبات صفحه‌بندی ==========
    const totalPages = Math.ceil(totalCourses / limit);
    const hasNextPage = page < totalPages;
    const hasPrevPage = page > 1;

    // محاسبه محدوده نمایش
    const startItem = totalCourses === 0 ? 0 : (page - 1) * limit + 1;
    const endItem = Math.min(page * limit, totalCourses);

    // ========== 9. ارسال پاسخ ==========
    res.status(200).json({
      success: true,
      message: "لیست پکیج‌ها با موفقیت دریافت شد",
      data: {
        courses: processedCourses,
        stats: {
          totalCourses,
          offeredCourses,
          averagePrice: Math.round(priceStats[0]?.avg || 0),
          minPrice: priceStats[0]?.min || 0,
          maxPrice: priceStats[0]?.max || 0,
          totalPrice: priceStats[0]?.total || 0,
          typeStats: typeStats,
        },
        pagination: {
          currentPage: page,
          totalPages: totalPages,
          totalItems: totalCourses,
          itemsPerPage: limit,
          hasNextPage: hasNextPage,
          hasPrevPage: hasPrevPage,
          nextPage: hasNextPage ? page + 1 : null,
          prevPage: hasPrevPage ? page - 1 : null,
          startItem: startItem,
          endItem: endItem,
        },
        filters: {
          search: search,
          category: category,
          minPrice: minPrice,
          maxPrice: maxPrice,
          hasOffer: hasOffer,
          teacherName: teacherName,
          type: type,
          sortBy: sortBy,
          sortOrder: sortOrder === 1 ? "asc" : "desc",
          status: status,
        },
      },
    });
  } catch (error) {
    console.error("Error in getCourses:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت پکیج‌ها",
      error: error.message,
    });
  }
};

const proPayment = 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 userId = decodedToken.id;
    const { courseId } = req.body;

    // ========== 1. بررسی وجود CoursePayment ==========
    const coursePayment = await CoursePaymentModel.findOne({
      cuorse_type: "pro",
    });

    if (!coursePayment) {
      return res.status(404).json({
        error: true,
        message: "قیمت‌گذاری برای نوع پرو یافت نشد",
      });
    }

    const price = coursePayment.price;

    // ========== 2. اعتبارسنجی قیمت ==========
    if (!price || isNaN(Number(price)) || Number(price) <= 0) {
      return res.status(422).json({
        error: true,
        message: "مبلغ نامعتبر است",
      });
    }

    // ========== 3. بررسی وجود دوره ==========
    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.status(404).json({
        error: true,
        message: "پکیجی یافت نشد",
      });
    }

    // ========== 4. محاسبه مبلغ ==========
    const amount = Number(price) * 10;

    // مبلغ باید حداقل 1000 تومان باشد (طبق قوانین زرین‌پال)
    if (amount < 1000) {
      return res.status(422).json({
        error: true,
        message: "مبلغ باید حداقل 1000 تومان باشد",
      });
    }

    const callbackUrl = `https://api.modstagram.com/api/v1/academy/academy/course/pro?courseId=${courseId}&userId=${userId}`;

    // ========== 5. درخواست به زرین‌پال ==========
    const zarinpalRes = await axios.post(
      "https://api.zarinpal.com/pg/v4/payment/request.json",
      {
        merchant_id:
          process.env.ZARINPAL_MERCHANT_ID ||
          "c7c41e8a-918f-4741-bcd5-58f3bc51db73",
        amount: Math.round(amount), // حتماً عدد صحیح باشد
        description: `خرید اشتراک پرو برای ${course.cuorse_name}`,
        callback_url: callbackUrl,
        metadata: {
          user_id: userId,
          course_id: courseId,
        },
      },
      {
        headers: { "Content-Type": "application/json" },
        timeout: 10000, // 10 ثانیه تایم‌اوت
      }
    );

    const result = zarinpalRes.data;

    // ========== 6. بررسی پاسخ زرین‌پال ==========
    if (result.data && result.data.code === 100) {
      // ذخیره اطلاعات پرداخت در دیتابیس (اختیاری)
      await PaymentModel.create({
        authority: result.data.authority,
        amount: amount,
        user_id: userId,
        course_id: courseId,
        status: "pending",
        type: "pro",
        createdAt: new Date(),
      });

      return res.status(200).json({
        success: true,
        authority: result.data.authority,
        paymentUrl: `https://www.zarinpal.com/pg/StartPay/${result.data.authority}`,
      });
    }

    // خطای زرین‌پال
    console.error("ZarinPal error:", result);
    return res.status(422).json({
      error: true,
      message: result.errors?.message || "خطا در ارتباط با درگاه پرداخت",
      details: result.errors,
    });
  } catch (error) {
    console.error(
      "Error in proPayment:",
      error.response?.data || error.message
    );
    res.status(500).json({
      error: true,
      message: "خطا در پردازش پرداخت",
      details: error.response?.data || error.message,
    });
  }
};

const handleCoursePaymentCallback = async (req, res) => {
  res.setHeader("Access-Control-Allow-Origin", "*");
  res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");

  try {
    const { Authority, Status, userId, courseId } = req.query;

    if (Status !== "OK") {
      return res.redirect(`${process.env.APP_SITE}/offer/payment/failed`);
    }

    // ========== 1. پیدا کردن قیمت ==========
    const coursePayment = await CoursePaymentModel.findOne({
      cuorse_type: "pro",
    });

    if (!coursePayment) {
      return res.redirect(
        `${process.env.APP_SITE}/offer/payment/failed?message=price_not_found`
      );
    }

    const price = coursePayment.price;
    const amount = Number(price) * 10;

    // ========== 2. تایید پرداخت با زرین‌پال ==========
    const verify = await axios.post(
      "https://api.zarinpal.com/pg/v4/payment/verify.json",
      {
        merchant_id:
          process.env.ZARINPAL_MERCHANT_ID ||
          "c7c41e8a-918f-4741-bcd5-58f3bc51db73",
        authority: Authority,
        amount: Math.round(amount),
      },
      {
        headers: { "Content-Type": "application/json" },
        timeout: 10000,
      }
    );

    const data = verify.data.data;

    // ========== 3. بررسی نتیجه تایید ==========
    if (data.code === 100) {
      // ثبت پرداخت موفق
      await PaymentModel.create({
        amount: amount / 10,
        status: "successful",
        authority: Authority,
        ref_id: data.ref_id,
        user_id: userId,
        course_id: courseId,
        type: "course",
        verifiedAt: new Date(),
      });

      // به روز رسانی نوع دوره به pro
      const course = await CourseModel.findById(courseId);
      if (course) {
        course.type = "pro";
        await course.save();
      }

      // به روز رسانی وضعیت کاربر (اشتراک پرو)
      await UserModel.findByIdAndUpdate(userId, {
        $set: {
          "proSubscription.active": true,
          "proSubscription.courseId": courseId,
          "proSubscription.startDate": new Date(),
          "proSubscription.purchaseDate": new Date(),
        },
      });

      return res.redirect(
        `${process.env.APP_SITE}/settings/academy/course?payment=success`
      );
    }

    // پرداخت ناموفق
    return res.redirect(
      `${process.env.APP_SITE}/offer/payment/failed?code=${data.code}`
    );
  } catch (err) {
    console.error("Error in handleCoursePaymentCallback:", err);
    return res.redirect(
      `${process.env.APP_SITE}/offer/payment/failed?message=verification_error`
    );
  }
};

const creatCourseVideo = async (req, res, next) => {
  console.log("=== New request received ===");
  console.log("Headers:", req.headers);
  console.log("Body:", req.body);
  console.log("File:", req.file);

  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 userId = decodedToken.id;

    const { courseId, is_free, file_name } = req.body;
    const videoFile = req.file;

    if (!videoFile) {
      return res.status(422).json({
        error: true,
        message: "فایل ویدیو ارسال نشده است",
      });
    }

    if (!courseId) {
      return res.status(422).json({
        error: true,
        message: "شناسه دوره الزامی است",
      });
    }

    // مسیر ذخیره‌سازی نهایی (مشابه سیستم پست‌ها)
    const finalVideoDir = path.join(
      __dirname,
      "../../../storage/courses/videos"
    );
    const safeFileName = `course-${courseId}-${Date.now()}${path.extname(
      videoFile.originalname
    )}`;
    const filePath = path.join(finalVideoDir, safeFileName);

    // انتقال فایل از محل موقت به محل نهایی
    await fs.rename(videoFile.path, filePath);

    // ایجاد رکورد جدید در دیتابیس
    const newAcademyContent = new AcademyContentModel({
      course_video: `/storage/posts/videos/${safeFileName}`,
      type: "video",
      is_free: is_free === "true" || is_free === true,
      courseId,
      file_name: file_name || videoFile.originalname,
    });

    await newAcademyContent.save();

    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.status(404).json({
        success: false,
        message: "پکیج پیدا نشد",
      });
    }

    course.number_of_course_content = `${
      Number(course.number_of_course_content) + 1
    }`;
    await course.save();

    res.status(200).json({
      success: true,
      message: "ویدیو با موفقیت ثبت شد",
      data: newAcademyContent,
    });
  } catch (error) {
    console.error("Error in creatCourseVideo:", error);
    res.status(500).json({
      success: false,
      message: "خطا در ثبت ویدیو",
      error: error.message,
    });
  }
};

const creatCourseVideoBase64 = async (req, res, next) => {
  console.log("=== Base64 Video Upload ===");
  console.log("Body:", Object.keys(req.body));

  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 userId = decodedToken.id;

    const { courseId, is_free, file_name, video_base64, mime_type } = req.body;

    // اعتبارسنجی
    if (!video_base64) {
      return res.status(422).json({
        error: true,
        message: "فایل ویدیو ارسال نشده است",
      });
    }

    if (!courseId) {
      return res.status(422).json({
        error: true,
        message: "شناسه دوره الزامی است",
      });
    }

    // تبدیل Base64 به بافر
    const base64Data = video_base64.split(",")[1] || video_base64;
    const buffer = Buffer.from(base64Data, "base64");

    console.log("Buffer size:", buffer.length, "bytes");

    // ایجاد دایرکتوری اگر وجود ندارد
    const finalVideoDir = path.join(
      process.cwd(),
      "storage",
      "courses",
      "videos"
    );
    if (!fs.existsSync(finalVideoDir)) {
      fs.mkdirSync(finalVideoDir, { recursive: true });
    }

    // تعیین پسوند فایل از mime_type
    let extension = ".mp4";
    if (mime_type === "video/mp4") extension = ".mp4";
    else if (mime_type === "video/quicktime") extension = ".mov";
    else if (mime_type === "video/x-msvideo") extension = ".avi";
    else if (mime_type === "video/webm") extension = ".webm";

    const safeFileName = `course-${courseId}-${Date.now()}${extension}`;
    const filePath = path.join(finalVideoDir, safeFileName);

    // ذخیره فایل
    await fs.writeFileSync(filePath, buffer);

    console.log("File saved:", filePath);

    // ایجاد رکورد در دیتابیس
    const newAcademyContent = new AcademyContentModel({
      course_video: `/storage/courses/videos/${safeFileName}`,
      type: "video",
      is_free: is_free === "true" || is_free === true,
      courseId,
      file_name: file_name,
    });

    await newAcademyContent.save();

    // به روز رسانی تعداد محتواهای دوره
    const course = await CourseModel.findById(courseId);
    if (course) {
      course.number_of_course_content = `${
        Number(course.number_of_course_content) + 1
      }`;
      await course.save();
    }

    res.status(200).json({
      success: true,
      message: "ویدیو با موفقیت ثبت شد",
      data: newAcademyContent,
    });
  } catch (error) {
    console.error("Error in creatCourseVideoBase64:", error);
    res.status(500).json({
      success: false,
      message: "خطا در ثبت ویدیو",
      error: error.message,
    });
  }
};

const getCourseContent = async (req, res, next) => {
  try {
    // ✅ اصلاح: دریافت courseId از query یا params
    const courseId = req.query.courseId || req.params.courseId;

    // اعتبارسنجی courseId
    if (!courseId) {
      return res.status(422).json({
        error: true,
        message: "شناسه دوره الزامی است",
      });
    }

    // گرفتن پارامترهای صفحه‌بندی
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const skip = (page - 1) * limit;

    const academy = await CourseModel.findById(courseId);
    if (!academy) {
      return res.status(404).json({
        success: false,
        message: "پکیج پیدا نشد",
      });
    }

    // ✅ شرط جستجو - فقط دوره‌های تایید شده
    const query = {
      courseId: academy._id,
      status: "accept",
    };

    // دریافت تعداد کل دوره‌های تایید شده
    const totalCourses = await AcademyContentModel.countDocuments(query);

    // دریافت دوره‌های تایید شده با صفحه‌بندی
    const courses = await AcademyContentModel.find(query)
      .skip(skip)
      .limit(limit);

    // ✅ اگر دوره‌ای وجود نداشت، خطا نده، بلکه آرایه خالی برگردون
    if (!courses || courses.length === 0) {
      return res.status(200).json({
        success: true,
        message: "هیچ محتوایی یافت نشد",
        data: {
          courses: [],
          pagination: {
            currentPage: page,
            totalPages: 0,
            totalItems: 0,
            itemsPerPage: limit,
            hasNextPage: false,
            hasPrevPage: false,
          },
        },
      });
    }

    // محاسبات صفحه‌بندی
    const totalPages = Math.ceil(totalCourses / limit);
    const hasNextPage = page < totalPages;
    const hasPrevPage = page > 1;

    res.status(200).json({
      success: true,
      message: "لیست محتواها با موفقیت دریافت شد",
      data: {
        courses: courses,
        pagination: {
          currentPage: page,
          totalPages: totalPages,
          totalItems: totalCourses,
          itemsPerPage: limit,
          hasNextPage: hasNextPage,
          hasPrevPage: hasPrevPage,
          nextPage: hasNextPage ? page + 1 : null,
          prevPage: hasPrevPage ? page - 1 : null,
        },
      },
    });
  } catch (error) {
    console.error("Error in getCourseContent:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت محتواها",
      error: error.message,
    });
  }
};
// لایک کردن محتوا
const likeCourseContent = 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 userId = decodedToken.id;

    if (!userId) {
      return res.status(422).json({
        error: true,
        message: "برای لایک کردن وارد حساب کاربری خود شوید",
      });
    }

    const { courseId } = req.body;

    // بررسی وجود دوره
    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.status(404).json({
        success: false,
        message: "پکیج پیدا نشد",
      });
    }

    // بررسی اینکه آیا قبلاً لایک کرده است
    const existingLike = await AcademyLikeModel.findOne({
      user_id: userId,
      course_id: courseId,
    });

    if (existingLike) {
      return res.status(400).json({
        success: false,
        message: "شما قبلاً این دوره را لایک کرده‌اید",
      });
    }

    // افزایش تعداد لایک‌های دوره
    course.likes = (course.likes || 0) + 1;
    await course.save();

    // ایجاد رکورد لایک
    await AcademyLikeModel.create({
      user_id: userId,
      course_id: courseId,
      createdAt: new Date(),
    });

    res.status(200).json({
      success: true,
      message: "دوره با موفقیت لایک شد",
      isLiked: true,
      likesCount: course.likes,
    });
  } catch (error) {
    console.error("Error in likeCourseContent:", error);
    res.status(500).json({
      success: false,
      message: "خطا در لایک کردن محتوا",
      error: error.message,
    });
  }
};

// دیسلایک کردن محتوا (حذف لایک)
const dontLikeCourseContent = 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 userId = decodedToken.id;

    const { courseId } = req.body;

    // بررسی وجود دوره
    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.status(404).json({
        success: false,
        message: "پکیج پیدا نشد",
      });
    }

    // پیدا کردن و حذف لایک
    const deletedLike = await AcademyLikeModel.findOneAndDelete({
      user_id: userId,
      course_id: courseId,
    });

    if (!deletedLike) {
      return res.status(404).json({
        success: false,
        message: "شما این دوره را لایک نکرده‌اید",
      });
    }

    // کاهش تعداد لایک‌های دوره
    course.likes = Math.max((course.likes || 0) - 1, 0); // جلوگیری از منفی شدن
    await course.save();

    res.status(200).json({
      success: true,
      message: "لایک دوره با موفقیت حذف شد",
      isLiked: false,
      likesCount: course.likes,
    });
  } catch (error) {
    console.error("Error in dontLikeCourseContent:", error);
    res.status(500).json({
      success: false,
      message: "خطا در حذف لایک محتوا",
      error: error.message,
    });
  }
};

// بررسی وضعیت لایک (آیا کاربر لایک کرده است یا نه)
const isLikeCourseContent = 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 userId = decodedToken.id;

    const { courseId } = req.body;

    // پیدا کردن لایک
    const academyLike = await AcademyLikeModel.findOne({
      user_id: userId,
      course_id: courseId,
    });

    res.status(200).json({
      success: true,
      isLiked: !!academyLike, // تبدیل به boolean
    });
  } catch (error) {
    console.error("Error in isLikeCourseContent:", error);
    res.status(500).json({
      success: false,
      message: "خطا در بررسی وضعیت لایک",
      error: error.message,
    });
  }
};

// دریافت تعداد لایک‌های یک دوره
const getCourseLikesCount = async (req, res, next) => {
  try {
    const { courseId } = req.params;

    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.status(404).json({
        success: false,
        message: "دوره پیدا نشد",
      });
    }

    const likesCount = await AcademyLikeModel.countDocuments({
      course_id: courseId,
    });

    res.status(200).json({
      success: true,
      likesCount: likesCount,
      courseLikes: course.likes || 0,
    });
  } catch (error) {
    console.error("Error in getCourseLikesCount:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت تعداد لایک‌ها",
      error: error.message,
    });
  }
};

// دریافت همه دوره‌هایی که کاربر لایک کرده است
const getUserLikedCourses = 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 userId = decodedToken.id;

    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const skip = (page - 1) * limit;

    const likes = await AcademyLikeModel.find({ user_id: userId })
      .populate("course_id")
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(limit);

    const total = await AcademyLikeModel.countDocuments({ user_id: userId });

    res.status(200).json({
      success: true,
      data: likes,
      pagination: {
        currentPage: page,
        totalPages: Math.ceil(total / limit),
        totalItems: total,
        itemsPerPage: limit,
      },
    });
  } catch (error) {
    console.error("Error in getUserLikedCourses:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت دوره‌های لایک شده",
      error: error.message,
    });
  }
};

// ==================== ساخت کامنت جدید ====================
const createComment = async (req, res) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token)
      return res.status(401).json({ error: true, message: "Access Denied" });

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

    const { course_id, comment, rate } = req.body;

    // اعتبارسنجی
    if (!course_id || !comment) {
      return res.status(422).json({
        error: true,
        message: "شناسه دوره و متن کامنت الزامی است",
      });
    }

    // بررسی وجود دوره
    const course = await CourseModel.findById(course_id);
    if (!course) {
      return res.status(404).json({
        error: true,
        message: "دوره پیدا نشد",
      });
    }

    // ایجاد کامنت جدید
    const newComment = await CourseComment.create({
      user_id: userId,
      course_id: course_id,
      comment: comment,
      rate: rate || 0,
      status: "accepted", // با توجه به مدل شما که default: 'accepted' است
    });

    // populate کردن اطلاعات کاربر
    const populatedComment = await CourseComment.findById(
      newComment._id
    ).populate("user_id", "name username");

    res.status(201).json({
      success: true,
      message: "کامنت با موفقیت ثبت شد",
      data: populatedComment,
    });
  } catch (error) {
    console.error("Error in createComment:", error);
    res.status(500).json({
      success: false,
      message: "خطا در ثبت کامنت",
      error: error.message,
    });
  }
};

// ==================== دریافت تعداد کل کامنت‌های یک دوره ====================
const getTotalCommentsCount = async (req, res) => {
  try {
    const { courseId } = req.params;
    const { status } = req.query; // اختیاری: فقط کامنت‌های با وضعیت خاص

    const query = { course_id: courseId };
    if (status) {
      query.status = status;
    }

    const totalComments = await CourseComment.countDocuments(query);

    // محاسبه میانگین امتیازات
    const averageRate = await CourseComment.aggregate([
      { $match: { course_id: courseId, status: "accepted" } },
      { $group: { _id: null, avgRate: { $avg: "$rate" } } },
    ]);

    res.status(200).json({
      success: true,
      data: {
        totalComments: totalComments,
        averageRate: averageRate[0]?.avgRate || 0,
        courseId: courseId,
      },
    });
  } catch (error) {
    console.error("Error in getTotalCommentsCount:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت تعداد کامنت‌ها",
      error: error.message,
    });
  }
};

// ==================== دریافت کامنت‌ها با فیلترهای مختلف ====================
const getCourseComments = async (req, res) => {
  try {
    const { courseId } = req.params;
    const {
      page = 1,
      limit = 10,
      status = "accepted", // 'accepted', 'pending', 'rejected', 'all'
      minRate,
      maxRate,
      sortBy = "createdAt",
      sortOrder = "desc",
      userId, // اختیاری: کامنت‌های یک کاربر خاص
    } = req.query;

    // ساخت شرط جستجو
    const query = { course_id: courseId };

    // فیلتر بر اساس وضعیت
    if (status !== "all") {
      query.status = status;
    }

    // فیلتر بر اساس امتیاز
    if (minRate || maxRate) {
      query.rate = {};
      if (minRate) query.rate.$gte = parseInt(minRate);
      if (maxRate) query.rate.$lte = parseInt(maxRate);
    }

    // فیلتر بر اساس کاربر خاص
    if (userId) {
      query.user_id = userId;
    }

    // تنظیمات مرتب‌سازی
    const sortOptions = {};
    sortOptions[sortBy] = sortOrder === "desc" ? -1 : 1;

    // دریافت کامنت‌ها با pagination
    const skip = (parseInt(page) - 1) * parseInt(limit);

    const [comments, totalComments] = await Promise.all([
      CourseComment.find(query)
        .sort(sortOptions)
        .skip(skip)
        .limit(parseInt(limit))
        .populate("user_id", "name username profileImage"),
      CourseComment.countDocuments(query),
    ]);

    // محاسبه آمار کامنت‌ها
    const stats = await CourseComment.aggregate([
      { $match: { course_id: courseId, status: "accepted" } },
      {
        $group: {
          _id: null,
          totalAccepted: { $sum: 1 },
          averageRate: { $avg: "$rate" },
          rateDistribution: {
            $push: "$rate",
          },
        },
      },
    ]);

    const totalPages = Math.ceil(totalComments / parseInt(limit));

    res.status(200).json({
      success: true,
      message: "لیست کامنت‌ها با موفقیت دریافت شد",
      data: {
        comments: comments,
        pagination: {
          currentPage: parseInt(page),
          totalPages: totalPages,
          totalItems: totalComments,
          itemsPerPage: parseInt(limit),
          hasNextPage: parseInt(page) < totalPages,
          hasPrevPage: parseInt(page) > 1,
        },
        stats: {
          totalComments: totalComments,
          acceptedComments: stats[0]?.totalAccepted || 0,
          averageRate: Math.round((stats[0]?.averageRate || 0) * 10) / 10,
          rateDistribution: stats[0]?.rateDistribution || [],
        },
      },
    });
  } catch (error) {
    console.error("Error in getCourseComments:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت کامنت‌ها",
      error: error.message,
    });
  }
};
// ==================== ویرایش وضعیت کامنت (برای همه قابل استفاده است) ====================
const updateCommentStatus = async (req, res) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token)
      return res.status(401).json({ error: true, message: "Access Denied" });

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

    const { commentId } = req.params;
    const { status } = req.body; // 'pending', 'accepted', 'rejected'

    // اعتبارسنجی وضعیت
    if (!["pending", "accepted", "rejected"].includes(status)) {
      return res.status(422).json({
        error: true,
        message:
          "وضعیت نامعتبر است. وضعیت باید یکی از این موارد باشد: pending, accepted, rejected",
      });
    }

    // پیدا کردن کامنت
    const comment = await CourseComment.findById(commentId);
    if (!comment) {
      return res.status(404).json({
        error: true,
        message: "کامنت پیدا نشد",
      });
    }

    // بررسی دسترسی: یا خود صاحب کامنت است یا هر کاربر دیگری (طبق درخواست شما که همه بتوانند)
    // اگر می‌خواهید فقط ادمین بتواند وضعیت را تغییر دهد، این بخش را تغییر دهید
    const user = await UserModel.findById(userId);
    const isOwner = comment.user_id.toString() === userId;
    const isAdmin = user?.role === "admin";

    if (!isOwner && !isAdmin) {
      return res.status(403).json({
        error: true,
        message: "شما اجازه تغییر وضعیت این کامنت را ندارید",
      });
    }

    // به روز رسانی وضعیت
    comment.status = status;
    await comment.save();

    // اگر کامنت تایید شد و امتیاز داشت، میانگین امتیاز دوره را به روز کن
    if (status === "accepted" && comment.rate > 0) {
      const averageRate = await CourseComment.aggregate([
        { $match: { course_id: comment.course_id, status: "accepted" } },
        { $group: { _id: null, avgRate: { $avg: "$rate" } } },
      ]);

      await CourseModel.findByIdAndUpdate(comment.course_id, {
        averageRate: averageRate[0]?.avgRate || 0,
      });
    }

    res.status(200).json({
      success: true,
      message: `وضعیت کامنت با موفقیت به ${
        status === "accepted"
          ? "تایید شده"
          : status === "rejected"
          ? "رد شده"
          : "در انتظار"
      } تغییر یافت`,
      data: comment,
    });
  } catch (error) {
    console.error("Error in updateCommentStatus:", error);
    res.status(500).json({
      success: false,
      message: "خطا در تغییر وضعیت کامنت",
      error: error.message,
    });
  }
};

// ==================== دریافت کامنت‌های یک کاربر خاص ====================
const getUserComments = async (req, res) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token)
      return res.status(401).json({ error: true, message: "Access Denied" });

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

    const { page = 1, limit = 10, status = "all", courseId } = req.query;

    const query = { user_id: userId };

    if (status !== "all") {
      query.status = status;
    }

    if (courseId) {
      query.course_id = courseId;
    }

    const skip = (parseInt(page) - 1) * parseInt(limit);

    const [comments, totalComments] = await Promise.all([
      CourseComment.find(query)
        .sort({ createdAt: -1 })
        .skip(skip)
        .limit(parseInt(limit))
        .populate("course_id", "cuorse_name packageImage"),
      CourseComment.countDocuments(query),
    ]);

    const totalPages = Math.ceil(totalComments / parseInt(limit));

    res.status(200).json({
      success: true,
      data: {
        comments: comments,
        pagination: {
          currentPage: parseInt(page),
          totalPages: totalPages,
          totalItems: totalComments,
          itemsPerPage: parseInt(limit),
        },
      },
    });
  } catch (error) {
    console.error("Error in getUserComments:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت کامنت‌های کاربر",
      error: error.message,
    });
  }
};

// ==================== حذف کامنت (اختیاری) ====================
const deleteComment = async (req, res) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token)
      return res.status(401).json({ error: true, message: "Access Denied" });

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

    const { commentId } = req.params;

    const comment = await CourseComment.findById(commentId);
    if (!comment) {
      return res.status(404).json({
        error: true,
        message: "کامنت پیدا نشد",
      });
    }

    // بررسی دسترسی: یا خود صاحب کامنت است یا ادمین
    const user = await UserModel.findById(userId);
    const isOwner = comment.user_id.toString() === userId;
    const isAdmin = user?.role === "admin";

    if (!isOwner && !isAdmin) {
      return res.status(403).json({
        error: true,
        message: "شما اجازه حذف این کامنت را ندارید",
      });
    }

    await comment.deleteOne();

    res.status(200).json({
      success: true,
      message: "کامنت با موفقیت حذف شد",
    });
  } catch (error) {
    console.error("Error in deleteComment:", error);
    res.status(500).json({
      success: false,
      message: "خطا در حذف کامنت",
      error: error.message,
    });
  }
};
// academyController.js

const coursePayment = async (req, res, next) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token) {
      return res.status(401).json({
        error: true,
        message: "لطفا وارد حساب کاربری خود شوید",
      });
    }

    const decodedToken = jwt.verify(token, process.env.APP_SECRET);
    const userId = decodedToken.id;
    const { courseId } = req.body;

    // ========== 1. بررسی وجود دوره ==========
    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.status(404).json({
        error: true,
        message: "دوره مورد نظر یافت نشد",
      });
    }

    // ========== 2. بررسی خرید قبلی ==========
    const existingPurchase = await IsPaymentCourse.findOne({
      user_id: userId,
      course_id: course._id,
    });

    if (existingPurchase) {
      return res.status(400).json({
        error: true,
        message: "شما قبلاً این دوره را خریداری کرده‌اید",
      });
    }

    // ========== 3. دریافت نرخ مالیات ==========
    let taxRate = 9; // پیش‌فرض 9 درصد
    const tax = await Tax.findOne({ type: "course" });
    if (tax && tax.tax) {
      taxRate = Number(tax.tax);
    }

    // ========== 4. محاسبه قیمت ==========
    const offerNum = Number(course.offer) || 0;
    const priceNum = Number(course.price);

    // قیمت پس از تخفیف
    const discountedPrice = (priceNum / 100) * (100 - offerNum);

    // محاسبه مالیات
    const taxAmount = discountedPrice * (taxRate / 100);

    // قیمت نهایی با مالیات (تومان)
    const finalPrice = discountedPrice;
    const finalTaxPrice = (discountedPrice / 100) * (100 - taxRate);

    // ========== 5. اعتبارسنجی قیمت ==========
    if (!finalPrice || isNaN(finalPrice) || finalPrice <= 0) {
      return res.status(422).json({
        error: true,
        message: "مبلغ نامعتبر است",
      });
    }

    // تبدیل به ریال (ضرب در 10 چون هر تومان = 10 ریال)
    const amountInRials = Math.round(finalPrice * 10);

    // مبلغ باید حداقل 1000 تومان باشد (10000 ریال)
    if (amountInRials < 10000) {
      return res.status(422).json({
        error: true,
        message: "مبلغ باید حداقل 1000 تومان باشد",
      });
    }

    // ========== 6. ساخت کال‌بک URL ==========
    const callbackUrl = `https://api.modstagram.com/api/v1/academy/academy/course/payment/verify?courseId=${courseId}&userId=${userId}`;

    // ========== 7. درخواست به زرین‌پال ==========
    const zarinpalRes = await axios.post(
      "https://api.zarinpal.com/pg/v4/payment/request.json",
      {
        merchant_id: process.env.ZARINPAL_MERCHANT_ID,
        amount: amountInRials,
        description: `خرید دوره ${course.cuorse_name}`,
        callback_url: callbackUrl,
        metadata: {
          user_id: userId,
          course_id: courseId,
          price: finalPrice,
          tax_rate: taxRate,
        },
      },
      {
        headers: { "Content-Type": "application/json" },
        timeout: 90000,
      }
    );

    const result = zarinpalRes.data;

    // ========== 8. بررسی پاسخ زرین‌پال ==========
    if (result.data && result.data.code === 100) {
      // ذخیره اطلاعات پرداخت در حالت pending
      await AcademyPaymentModel.create({
        price: finalPrice,
        discountAmount: priceNum - discountedPrice,
        taxAmount: finalTaxPrice,
        taxRate: taxRate,
        course_name: course.cuorse_name,
        course_id: course._id,
        academy_id: course.academyId,
        user_id: userId,
        payment_authority: result.data.authority,
        status: "pending",
      });

      return res.status(200).json({
        success: true,
        authority: result.data.authority,
        paymentUrl: `https://www.zarinpal.com/pg/StartPay/${result.data.authority}`,
      });
    }

    // خطای زرین‌پال
    console.error("ZarinPal error:", result);
    return res.status(422).json({
      error: true,
      message: result.errors?.message || "خطا در ارتباط با درگاه پرداخت",
      details: result.errors,
    });
  } catch (error) {
    console.error(
      "Error in coursePayment:",
      error.response?.data || error.message
    );
    res.status(500).json({
      error: true,
      message: "خطا در پردازش پرداخت",
      details: error.response?.data || error.message,
    });
  }
};

const CoursePaymentCallback = async (req, res) => {
  try {
    const { Authority, Status, courseId, userId } = req.query;

    // ========== 1. بررسی وضعیت پرداخت ==========
    if (Status !== "OK") {
      return res.redirect(
        `${process.env.APP_SITE}/offer/payment/failed?message=payment_canceled`
      );
    }

    // ========== 2. پیدا کردن دوره ==========
    const course = await CourseModel.findById(courseId);
    if (!course) {
      return res.redirect(
        `${process.env.APP_SITE}/offer/payment/failed?message=course_not_found`
      );
    }

    // ========== 3. پیدا کردن رکورد پرداخت ==========
    const paymentRecord = await AcademyPaymentModel.findOne({
      payment_authority: Authority,
      course_id: courseId,
      user_id: userId,
    });

    if (!paymentRecord) {
      return res.redirect(
        `${process.env.APP_SITE}/offer/payment/failed?message=payment_not_found`
      );
    }

    // ========== 4. محاسبه مبلغ ==========
    const amountInRials = Math.round(paymentRecord.price * 10);

    // ========== 5. تایید پرداخت با زرین‌پال ==========
    const verify = await axios.post(
      "https://api.zarinpal.com/pg/v4/payment/verify.json",
      {
        merchant_id: process.env.ZARINPAL_MERCHANT_ID,
        authority: Authority,
        amount: amountInRials,
      },
      {
        headers: { "Content-Type": "application/json" },
        timeout: 10000,
      }
    );

    const data = verify.data.data;

    // ========== 6. بررسی نتیجه تایید ==========
    if (data.code === 100) {
      // به‌روزرسانی رکورد پرداخت
      await AcademyPaymentModel.findByIdAndUpdate(paymentRecord._id, {
        status: "success",
        payment_ref_id: data.ref_id,
      });

      // ثبت خرید کاربر
      await IsPaymentCourse.create({
        user_id: userId,
        course_id: course._id,
        price_paid: paymentRecord.price,
        purchased_at: new Date(),
      });

      // هدایت به صفحه موفقیت
      return res.redirect(
        `${process.env.APP_SITE}/academy/${course._id}/success?payment=success`
      );
    }

    // پرداخت ناموفق
    await AcademyPaymentModel.findByIdAndUpdate(paymentRecord._id, {
      status: "failed",
    });

    return res.redirect(
      `${process.env.APP_SITE}/offer/payment/failed?code=${data.code}`
    );
  } catch (err) {
    console.error("Error in CoursePaymentCallback:", err);
    return res.redirect(
      `${process.env.APP_SITE}/offer/payment/failed?message=verification_error`
    );
  }
};
const getUserPurchasedCourses = async (req, res) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token)
      return res.status(401).json({ error: true, message: "Access Denied" });

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

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

    // پیدا کردن تمام رکوردهای پرداخت برای این کاربر
    const payments = await IsPaymentCourse.find({ user_id: user_id })
      .sort({ createdAt: -1 }) // جدیدترین اول
      .skip((page - 1) * limit)
      .limit(parseInt(limit));

    // گرفتن اطلاعات کامل دوره‌ها
    const courseIds = payments.map((payment) => payment.course_id);

    const courses = await CourseModel.find({
      _id: { $in: courseIds },
      status: "accept", // فقط دوره‌های تایید شده
    });

    // محاسبه تعداد کل
    const total = await IsPaymentCourse.countDocuments({ user_id: user_id });

    res.status(200).json({
      success: true,
      data: {
        courses: courses,
        pagination: {
          total,
          page: parseInt(page),
          pages: Math.ceil(total / limit),
          limit: parseInt(limit),
        },
      },
    });
  } catch (error) {
    console.error("Error in getUserPurchasedCourses:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت دوره‌های خریداری شده",
      error: error.message,
    });
  }
};

// API با populate (روش بهتر)
const getUserPurchasedCoursesWithPopulate = async (req, res) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token)
      return res.status(401).json({ error: true, message: "Access Denied" });

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

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

    const options = {
      page: parseInt(page),
      limit: parseInt(limit),
      sort: { createdAt: -1 },
      populate: {
        path: "course_id",
        model: "Course",
        match: { status: "accept" }, // فقط دوره‌های تایید شده
      },
    };

    const result = await IsPaymentCourse.paginate(
      { user_id: user_id },
      options
    );

    // فیلتر کردن دوره‌هایی که populate شده‌اند و وجود دارند
    const validCourses = result.docs
      .filter((doc) => doc.course_id !== null)
      .map((doc) => doc.course_id);

    res.status(200).json({
      success: true,
      data: {
        courses: validCourses,
        pagination: {
          total: result.totalDocs,
          page: result.page,
          totalPages: result.totalPages,
          limit: result.limit,
          hasNextPage: result.hasNextPage,
          hasPrevPage: result.hasPrevPage,
        },
      },
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت دوره‌های خریداری شده",
    });
  }
};

const getAllAcademyPayments = async (req, res) => {
  try {
    // 1. بررسی توکن
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token) {
      return res.status(401).json({
        success: false,
        message: "دسترسی غیرمجاز",
      });
    }

    // 2. verify توکن
    let decodedToken;
    try {
      decodedToken = jwt.verify(token, process.env.APP_SECRET);
    } catch (jwtError) {
      return res.status(401).json({
        success: false,
        message: "توکن نامعتبر است",
      });
    }

    const userId = decodedToken.id;

    // 3. پیدا کردن آکادمی
    const academy = await AcademyModel.findOne({ userId: userId });

    if (!academy) {
      return res.status(404).json({
        success: false,
        message: "آکادمی برای این کاربر یافت نشد",
      });
    }

    const academy_id = academy._id;
    const { page = 1, limit = 10, status } = req.query;

    // 4. ساخت فیلتر
    let filter = { academy_id: academy_id };

    if (
      status &&
      ["pending", "success", "failed", "settled"].includes(status)
    ) {
      filter.status = status;
    }

    // 5. تنظیمات صفحه‌بندی
    const pageNum = parseInt(page);
    const limitNum = parseInt(limit);
    const skip = (pageNum - 1) * limitNum;

    const options = {
      page: pageNum,
      limit: limitNum,
      sort: { createdAt: -1 },
      populate: [
        {
          path: "course_id",
          model: "Course",
          select: "cuorse_name price course_image category teacher_name",
        },
        {
          path: "user_id",
          model: "User",
          select: "user_name profile_image email phone",
        },
      ],
    };

    // 6. دریافت پرداخت‌ها
    const result = await AcademyPaymentModel.paginate(filter, options);

    // 7. محاسبه آمار دقیق‌تر
    let totalAmount = 0;
    let pendingCount = 0;
    let acceptedCount = 0;

    if (result.docs && Array.isArray(result.docs)) {
      totalAmount = result.docs.reduce((sum, p) => {
        const price = parseInt(p.taxAmount) || 0;
        return sum + price;
      }, 0);

      pendingCount = result.docs.filter((p) => p.status === "pending").length;
      acceptedCount = result.docs.filter((p) => p.status === "accept").length;
    }

    // 8. پاسخ نهایی
    res.status(200).json({
      success: true,
      data: {
        academy: {
          _id: academy._id,
          academy_name: academy.academy_name,
          academy_image: academy.academy_image,
          bio: academy.bio,
        },
        payments: result.docs || [],
        pagination: {
          total: result.totalDocs || 0,
          page: result.page || pageNum,
          totalPages: result.totalPages || 1,
          limit: result.limit || limitNum,
          hasNextPage: result.hasNextPage || false,
          hasPrevPage: result.hasPrevPage || false,
        },
        stats: {
          totalAmount: totalAmount,
          pendingCount: pendingCount,
          acceptedCount: acceptedCount,
        },
      },
    });
  } catch (error) {
    console.error("Error in getAllAcademyPayments:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت لیست پرداخت‌ها",
      error: process.env.NODE_ENV === "development" ? error.message : undefined,
    });
  }
};
const checkCoursePurchase = async (req, res) => {
  try {
    const token = req.header("Authorization")?.split(" ")[1];
    if (!token)
      return res.status(401).json({ error: true, message: "Access Denied" });

    const decodedToken = jwt.verify(token, process.env.APP_SECRET);
    const userId = decodedToken.id;
    const { courseId } = req.params;

    // بررسی وجود کاربر و دوره
    if (!userId || !courseId) {
      return res.status(400).json({
        success: false,
        message: "userId و courseId الزامی هستند",
      });
    }

    // جستجو در دیتابیس
    const purchase = await IsPaymentCourse.findOne({
      user_id: userId,
      course_id: courseId,
    });

    // نتیجه
    if (purchase) {
      return res.status(200).json({
        success: true,
        isPurchased: true,
        message: "این دوره قبلاً خریداری شده است",
        purchaseData: purchase,
      });
    } else {
      return res.status(200).json({
        success: true,
        isPurchased: false,
        message: "این دوره خریداری نشده است",
      });
    }
  } catch (error) {
    console.error("Error in checkCoursePurchase:", error);
    res.status(500).json({
      success: false,
      message: "خطا در بررسی خرید دوره",
      error: error.message,
    });
  }
};

const getAcademyCourse = async (req, res, next) => {
  try {
    const { Id } = req.params;

    // گرفتن پارامترهای صفحه‌بندی
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const skip = (page - 1) * limit;

    const academy = await AcademyModel.findById(Id);
    if (!academy) {
      return res.status(404).json({
        success: false,
        message: "آکادمی پیدا نشد",
      });
    }

    // ✅ شرط جستجو - فقط دوره‌های تایید شده
    const query = {
      academyId: academy._id,
      status: "accept",
    };

    // دریافت تعداد کل دوره‌های تایید شده
    const totalCourses = await CourseModel.countDocuments(query);

    // دریافت دوره‌های تایید شده با صفحه‌بندی
    const courses = await CourseModel.find(query)
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(limit);

    // ✅ اگر دوره‌ای وجود نداشت، خطا نده، بلکه آرایه خالی برگردون
    if (!courses || courses.length === 0) {
      return res.status(200).json({
        success: true,
        message: "هیچ دوره تایید شده‌ای یافت نشد",
        data: {
          courses: [],
          pagination: {
            currentPage: page,
            totalPages: 0,
            totalItems: 0,
            itemsPerPage: limit,
            hasNextPage: false,
            hasPrevPage: false,
            nextPage: null,
            prevPage: null,
          },
        },
      });
    }

    // محاسبات صفحه‌بندی
    const totalPages = Math.ceil(totalCourses / limit);
    const hasNextPage = page < totalPages;
    const hasPrevPage = page > 1;

    res.status(200).json({
      success: true,
      message: "لیست پکیج‌ها با موفقیت دریافت شد",
      data: {
        courses: courses,
        pagination: {
          currentPage: page,
          totalPages: totalPages,
          totalItems: totalCourses,
          itemsPerPage: limit,
          hasNextPage: hasNextPage,
          hasPrevPage: hasPrevPage,
          nextPage: hasNextPage ? page + 1 : null,
          prevPage: hasPrevPage ? page - 1 : null,
        },
      },
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت پکیج‌ها",
      error: error.message,
    });
  }
};

// ==================== مدیریت پرداخت‌ها ====================
const getAllPayments = async (req, res) => {
  try {
    const { page = 1, limit = 20, status, startDate, endDate } = req.query;
    const skip = (parseInt(page) - 1) * parseInt(limit);

    let query = {};
    if (status) query.status = status;
    if (startDate && endDate) {
      query.createdAt = {
        $gte: new Date(startDate),
        $lte: new Date(endDate),
      };
    }

    const payments = await AcademyPaymentModel.find(query)
      .populate("user_id", "user_name profile_image email")
      .populate("course_id", "cuorse_name price course_image")
      .populate("academy_id", "academy_name academy_image sheba")
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(parseInt(limit));

    const total = await AcademyPaymentModel.countDocuments(query);

    // آمار کلی پرداخت‌ها
    const stats = await AcademyPaymentModel.aggregate([
      { $match: query },
      {
        $group: {
          _id: null,
          totalAmount: { $sum: { $toDouble: "$price" } },
          totalCount: { $sum: 1 },
          pendingCount: {
            $sum: { $cond: [{ $eq: ["$status", "pending"] }, 1, 0] },
          },
          settledCount: {
            $sum: { $cond: [{ $eq: ["$status", "settled"] }, 1, 0] },
          },
          successCount: {
            $sum: { $cond: [{ $eq: ["$status", "success"] }, 1, 0] },
          },
        },
      },
    ]);

    res.status(200).json({
      success: true,
      data: {
        payments,
        stats: stats[0] || {
          totalAmount: 0,
          totalCount: 0,
          pendingCount: 0,
          settledCount: 0,
          successCount: 0,
        },
        pagination: {
          currentPage: parseInt(page),
          totalPages: Math.ceil(total / parseInt(limit)),
          totalItems: total,
          itemsPerPage: parseInt(limit),
        },
      },
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در دریافت پرداخت‌ها" });
  }
};

const updatePaymentStatus = async (req, res) => {
  try {
    const { paymentId, status } = req.body;

    const payment = await AcademyPaymentModel.findByIdAndUpdate(
      paymentId,
      { status, updatedAt: new Date() },
      { new: true }
    );

    if (!payment) {
      return res
        .status(404)
        .json({ success: false, message: "پرداخت یافت نشد" });
    }

    res.status(200).json({
      success: true,
      message: "وضعیت پرداخت با موفقیت تغییر کرد",
      data: payment,
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در تغییر وضعیت پرداخت" });
  }
};

// ==================== مدیریت دوره‌ها ====================
const getAllCourses = async (req, res) => {
  try {
    const { page = 1, limit = 20, status, type, category, search } = req.query;
    const skip = (parseInt(page) - 1) * parseInt(limit);

    let query = {};
    if (status) query.status = status;
    if (type) query.type = type;
    if (category) query.category = category;
    if (search) {
      query.$or = [
        { cuorse_name: { $regex: search, $options: "i" } },
        { caption: { $regex: search, $options: "i" } },
        { teacher_name: { $regex: search, $options: "i" } },
      ];
    }

    const courses = await CourseModel.find(query)
      .populate("academyId", "academy_name academy_image")
      .populate("user_id", "user_name profile_image")
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(parseInt(limit));

    const total = await CourseModel.countDocuments(query);

    // آمار دوره‌ها
    const stats = await CourseModel.aggregate([
      { $match: query },
      {
        $group: {
          _id: null,
          totalCourses: { $sum: 1 },
          totalPrice: { $sum: { $toDouble: "$price" } },
          normalCount: {
            $sum: { $cond: [{ $eq: ["$type", "normal"] }, 1, 0] },
          },
          proCount: { $sum: { $cond: [{ $eq: ["$type", "pro"] }, 1, 0] } },
          legendCount: {
            $sum: { $cond: [{ $eq: ["$type", "legend"] }, 1, 0] },
          },
          pendingCount: {
            $sum: { $cond: [{ $eq: ["$status", "pending"] }, 1, 0] },
          },
          acceptCount: {
            $sum: { $cond: [{ $eq: ["$status", "accept"] }, 1, 0] },
          },
        },
      },
    ]);

    res.status(200).json({
      success: true,
      data: {
        courses,
        stats: stats[0] || {},
        pagination: {
          currentPage: parseInt(page),
          totalPages: Math.ceil(total / parseInt(limit)),
          totalItems: total,
          itemsPerPage: parseInt(limit),
        },
      },
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در دریافت دوره‌ها" });
  }
};

const updateCourseStatus = async (req, res) => {
  try {
    const { courseId, status, type } = req.body;

    console.log(courseId, status, type);

    const course = await CourseModel.findById(courseId);

    if (!course) {
      return res.status(404).json({ success: false, message: "دوره یافت نشد" });
    }

    if (status) course.status = status;
    if (type) course.type = type;
    await course.save();

    res.status(200).json({
      success: true,
      message: "دوره با موفقیت به‌روزرسانی شد",
      data: course,
      courseId: courseId,
      status: status,
      type: type,
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در به‌روزرسانی دوره" });
  }
};

const admindeleteCourse = async (req, res) => {
  try {
    const { courseId } = req.params;

    const course = await CourseModel.findByIdAndDelete(courseId);

    if (!course) {
      return res.status(404).json({ success: false, message: "دوره یافت نشد" });
    }

    // حذف تمام پرداخت‌های مرتبط با این دوره
    await AcademyPaymentModel.deleteMany({ course_id: courseId });

    res.status(200).json({
      success: true,
      message: "دوره با موفقیت حذف شد",
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در حذف دوره" });
  }
};

// ==================== مدیریت دوره‌های خریداری شده ====================
const getAllPurchasedCourses = async (req, res) => {
  try {
    const { page = 1, limit = 20, userId, courseId, status } = req.query;
    const skip = (parseInt(page) - 1) * parseInt(limit);

    let query = {};
    if (userId) query.user_id = userId;
    if (courseId) query.course_id = courseId;
    if (status) query.status = status;

    const purchases = await IsPaymentCourse.find(query)
      .populate("user_id", "user_name profile_image email phone")
      .populate("course_id", "cuorse_name price course_image teacher_name")
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(parseInt(limit));

    const total = await IsPaymentCourse.countDocuments(query);

    // آمار خریدها
    const stats = await IsPaymentCourse.aggregate([
      { $match: query },
      {
        $group: {
          _id: null,
          totalPurchases: { $sum: 1 },
          uniqueUsers: { $addToSet: "$user_id" },
        },
      },
    ]);

    res.status(200).json({
      success: true,
      data: {
        purchases,
        stats: {
          totalPurchases: stats[0]?.totalPurchases || 0,
          uniqueUsers: stats[0]?.uniqueUsers?.length || 0,
        },
        pagination: {
          currentPage: parseInt(page),
          totalPages: Math.ceil(total / parseInt(limit)),
          totalItems: total,
          itemsPerPage: parseInt(limit),
        },
      },
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در دریافت دوره‌های خریداری شده" });
  }
};

// ==================== مدیریت آکادمی‌ها ====================
const getAllAcademies = async (req, res) => {
  try {
    const { page = 1, limit = 20, search } = req.query;
    const skip = (parseInt(page) - 1) * parseInt(limit);

    let query = {};
    if (search) {
      query.academy_name = { $regex: search, $options: "i" };
    }

    const academies = await AcademyModel.find(query)
      .populate("userId", "user_name profile_image email")
      .sort({ createdAt: -1 })
      .skip(skip)
      .limit(parseInt(limit));

    const total = await AcademyModel.countDocuments(query);

    // آمار آکادمی‌ها
    const stats = await AcademyModel.aggregate([
      {
        $group: {
          _id: null,
          totalAcademies: { $sum: 1 },
          totalRate: { $sum: "$rate" },
          avgRate: { $avg: "$rate" },
        },
      },
    ]);

    res.status(200).json({
      success: true,
      data: {
        academies,
        stats: stats[0] || {},
        pagination: {
          currentPage: parseInt(page),
          totalPages: Math.ceil(total / parseInt(limit)),
          totalItems: total,
          itemsPerPage: parseInt(limit),
        },
      },
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در دریافت آکادمی‌ها" });
  }
};

const updateAcademyStatus = async (req, res) => {
  try {
    const { academyId, status, rate, sheba } = req.body;

    const updateData = {};
    if (status) updateData.status = status;
    if (rate) updateData.rate = rate;
    if (sheba) updateData.sheba = sheba;

    const academy = await AcademyModel.findByIdAndUpdate(
      academyId,
      updateData,
      { new: true }
    );

    if (!academy) {
      return res
        .status(404)
        .json({ success: false, message: "آکادمی یافت نشد" });
    }

    res.status(200).json({
      success: true,
      message: "آکادمی با موفقیت به‌روزرسانی شد",
      data: academy,
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در به‌روزرسانی آکادمی" });
  }
};

// ==================== مدیریت تنظیمات (تکس و قیمت پرو) ====================
const getSettings = async (req, res) => {
  try {
    let settings = await SettingModel.findOne();

    if (!settings) {
      settings = await SettingModel.create({
        taxRate: 9,
        proPrice: 99000,
        legendPrice: 199000,
        minWithdrawAmount: 50000,
        maxWithdrawAmount: 10000000,
      });
    }

    res.status(200).json({
      success: true,
      data: settings,
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در دریافت تنظیمات" });
  }
};

const updateSettings = async (req, res) => {
  try {
    const {
      taxRate,
      proPrice,
      legendPrice,
      minWithdrawAmount,
      maxWithdrawAmount,
    } = req.body;

    const settings = await SettingModel.findOneAndUpdate(
      {},
      {
        taxRate,
        proPrice,
        legendPrice,
        minWithdrawAmount,
        maxWithdrawAmount,
        updatedAt: new Date(),
      },
      { new: true, upsert: true }
    );

    res.status(200).json({
      success: true,
      message: "تنظیمات با موفقیت به‌روزرسانی شد",
      data: settings,
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در به‌روزرسانی تنظیمات" });
  }
};

const getCoursePrices = async (req, res) => {
  try {
    const proPrice = await CoursePaymentModel.findOne({ cuorse_type: "pro" });

    const legendPrice = await CoursePaymentModel.findOne({
      cuorse_type: "legend",
    });

    const normalPrice = await CoursePaymentModel.findOne({
      cuorse_type: "normal",
    });

    res.status(200).json({
      success: true,
      data: {
        pro: proPrice
          ? { price: proPrice.price, _id: proPrice._id }
          : { price: "60000" },
        legend: legendPrice
          ? { price: legendPrice.price, _id: legendPrice._id }
          : { price: "199000" },
        normal: normalPrice
          ? { price: normalPrice.price, _id: normalPrice._id }
          : { price: "0" },
      },
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در دریافت قیمت دوره‌ها" });
  }
};

const updateCoursePrice = async (req, res) => {
  try {
    const { courseType, price } = req.body;

    if (!courseType || !price) {
      return res
        .status(400)
        .json({ success: false, message: "نوع دوره و قیمت الزامی است" });
    }

    let coursePayment = await CoursePaymentModel.findOne({
      cuorse_type: courseType,
    });

    if (coursePayment) {
      coursePayment.price = price.toString();
      await coursePayment.save();
    } else {
      coursePayment = new CoursePaymentModel({
        price: price.toString(),
        cuorse_type: courseType,
      });
      await coursePayment.save();
    }

    res.status(200).json({
      success: true,
      message: `قیمت دوره ${
        courseType === "pro"
          ? "پرو"
          : courseType === "legend"
          ? "لجند"
          : "معمولی"
      } با موفقیت به‌روزرسانی شد`,
      data: coursePayment,
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در به‌روزرسانی قیمت دوره" });
  }
};

const getTax = async (req, res) => {
  try {
    let tax = await Tax.findOne({ type: "course" });

    if (!tax) {
      tax = new Tax({ tax: 8, type: "course" });
      await tax.save();
    }

    res.status(200).json({
      success: true,
      data: {
        tax: tax.tax,
        _id: tax._id,
        type: tax.type,
      },
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در دریافت مالیات" });
  }
};

const updateTax = async (req, res) => {
  try {
    const { tax } = req.body;

    if (tax === undefined || tax === null) {
      return res
        .status(400)
        .json({ success: false, message: "مقدار مالیات الزامی است" });
    }

    let taxRecord = await Tax.findOne({ type: "course" });

    if (taxRecord) {
      taxRecord.tax = tax;
      await taxRecord.save();
    } else {
      taxRecord = new Tax({ tax: tax, type: "course" });
      await taxRecord.save();
    }

    res.status(200).json({
      success: true,
      message: "مالیات با موفقیت به‌روزرسانی شد",
      data: taxRecord,
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در به‌روزرسانی مالیات" });
  }
};

const getAllSettings = async (req, res) => {
  try {
    const proPrice = await CoursePaymentModel.findOne({ cuorse_type: "pro" });
    const legendPrice = await CoursePaymentModel.findOne({
      cuorse_type: "legend",
    });

    let tax = await Tax.findOne({ type: "course" });
    if (!tax) {
      tax = new Tax({ tax: 8, type: "course" });
      await tax.save();
    }

    res.status(200).json({
      success: true,
      data: {
        tax: tax.tax,
        prices: {
          pro: proPrice ? proPrice.price : "60000",
          legend: legendPrice ? legendPrice.price : "199000",
        },
      },
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در دریافت تنظیمات" });
  }
};

const updateAllSettings = async (req, res) => {
  try {
    const { tax, proPrice, legendPrice } = req.body;

    if (tax !== undefined) {
      let taxRecord = await Tax.findOne({ type: "course" });
      if (taxRecord) {
        taxRecord.tax = tax;
        await taxRecord.save();
      } else {
        taxRecord = new Tax({ tax: tax, type: "course" });
        await taxRecord.save();
      }
    }

    if (proPrice !== undefined) {
      let proRecord = await CoursePaymentModel.findOne({ cuorse_type: "pro" });
      if (proRecord) {
        proRecord.price = proPrice.toString();
        await proRecord.save();
      } else {
        proRecord = new CoursePaymentModel({
          price: proPrice.toString(),
          cuorse_type: "pro",
        });
        await proRecord.save();
      }
    }

    if (legendPrice !== undefined) {
      let legendRecord = await CoursePaymentModel.findOne({
        cuorse_type: "legend",
      });
      if (legendRecord) {
        legendRecord.price = legendPrice.toString();
        await legendRecord.save();
      } else {
        legendRecord = new CoursePaymentModel({
          price: legendPrice.toString(),
          cuorse_type: "legend",
        });
        await legendRecord.save();
      }
    }

    res.status(200).json({
      success: true,
      message: "تنظیمات با موفقیت به‌روزرسانی شد",
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در به‌روزرسانی تنظیمات" });
  }
};

const getPaymentStats = async (req, res) => {
  try {
    const stats = await AcademyPaymentModel.aggregate([
      {
        $group: {
          _id: null,
          totalAmount: { $sum: { $toDouble: "$price" } },
          totalCount: { $sum: 1 },
          pendingCount: {
            $sum: { $cond: [{ $eq: ["$status", "pending"] }, 1, 0] },
          },
          settledCount: {
            $sum: { $cond: [{ $eq: ["$status", "settled"] }, 1, 0] },
          },
          successCount: {
            $sum: { $cond: [{ $eq: ["$status", "success"] }, 1, 0] },
          },
        },
      },
    ]);

    const result = stats[0] || {
      totalAmount: 0,
      totalCount: 0,
      pendingCount: 0,
      settledCount: 0,
      successCount: 0,
    };

    result.averageAmount =
      result.totalCount > 0
        ? Math.round(result.totalAmount / result.totalCount)
        : 0;

    res.status(200).json({
      success: true,
      data: result,
    });
  } catch (error) {
    console.error("Error in getPaymentStats:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت آمار پرداخت‌ها",
      error: process.env.NODE_ENV === "development" ? error.message : undefined,
    });
  }
};

const getCourseById = async (req, res) => {
  try {
    const { id } = req.params;
    const course = await CourseModel.findById(id)
      .populate("academyId", "academy_name academy_image")
      .populate("user_id", "user_name profile_image");

    if (!course) {
      return res.status(404).json({ success: false, message: "دوره یافت نشد" });
    }

    res.status(200).json({
      success: true,
      data: course,
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در دریافت دوره" });
  }
};

const createCourse = async (req, res) => {
  try {
    const courseData = req.body;
    const newCourse = new CourseModel(courseData);
    await newCourse.save();

    res.status(201).json({
      success: true,
      message: "دوره با موفقیت ایجاد شد",
      data: newCourse,
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در ایجاد دوره" });
  }
};

const getCourseStats = async (req, res) => {
  try {
    const stats = await CourseModel.aggregate([
      {
        $group: {
          _id: null,
          totalCourses: { $sum: 1 },
          normalCount: {
            $sum: { $cond: [{ $eq: ["$type", "normal"] }, 1, 0] },
          },
          proCount: { $sum: { $cond: [{ $eq: ["$type", "pro"] }, 1, 0] } },
          legendCount: {
            $sum: { $cond: [{ $eq: ["$type", "legend"] }, 1, 0] },
          },
          pendingCount: {
            $sum: { $cond: [{ $eq: ["$status", "pending"] }, 1, 0] },
          },
          acceptCount: {
            $sum: { $cond: [{ $eq: ["$status", "accept"] }, 1, 0] },
          },
          rejectCount: {
            $sum: { $cond: [{ $eq: ["$status", "reject"] }, 1, 0] },
          },
        },
      },
    ]);

    res.status(200).json({
      success: true,
      data: stats[0] || {},
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در دریافت آمار دوره‌ها" });
  }
};

const getPurchasedStats = async (req, res) => {
  try {
    const stats = await IsPaymentCourse.aggregate([
      {
        $group: {
          _id: null,
          totalPurchases: { $sum: 1 },
          uniqueUsers: { $addToSet: "$user_id" },
        },
      },
    ]);

    res.status(200).json({
      success: true,
      data: {
        totalPurchases: stats[0]?.totalPurchases || 0,
        uniqueUsers: stats[0]?.uniqueUsers?.length || 0,
      },
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در دریافت آمار خریدها" });
  }
};

const getAcademyById = async (req, res) => {
  try {
    const { id } = req.params;
    const academy = await AcademyModel.findById(id).populate(
      "userId",
      "user_name profile_image email"
    );

    if (!academy) {
      return res
        .status(404)
        .json({ success: false, message: "آکادمی یافت نشد" });
    }

    res.status(200).json({
      success: true,
      data: academy,
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در دریافت آکادمی" });
  }
};

const createAcademy = async (req, res) => {
  try {
    const academyData = req.body;
    const newAcademy = new AcademyModel(academyData);
    await newAcademy.save();

    res.status(201).json({
      success: true,
      message: "آکادمی با موفقیت ایجاد شد",
      data: newAcademy,
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در ایجاد آکادمی" });
  }
};

const updateAcademy = async (req, res) => {
  try {
    const { id } = req.params;
    const updateData = req.body;

    const academy = await AcademyModel.findByIdAndUpdate(id, updateData, {
      new: true,
    });

    if (!academy) {
      return res
        .status(404)
        .json({ success: false, message: "آکادمی یافت نشد" });
    }

    res.status(200).json({
      success: true,
      message: "آکادمی با موفقیت به‌روزرسانی شد",
      data: academy,
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در به‌روزرسانی آکادمی" });
  }
};

const deleteAcademy = async (req, res) => {
  try {
    const { id } = req.params;
    const academy = await AcademyModel.findByIdAndDelete(id);

    if (!academy) {
      return res
        .status(404)
        .json({ success: false, message: "آکادمی یافت نشد" });
    }

    await CourseModel.deleteMany({ academyId: id });

    res.status(200).json({
      success: true,
      message: "آکادمی با موفقیت حذف شد",
    });
  } catch (error) {
    console.error(error);
    res.status(500).json({ success: false, message: "خطا در حذف آکادمی" });
  }
};

const getAcademyStats = async (req, res) => {
  try {
    const stats = await AcademyModel.aggregate([
      {
        $group: {
          _id: null,
          totalAcademies: { $sum: 1 },
          totalRate: { $sum: "$rate" },
          avgRate: { $avg: "$rate" },
        },
      },
    ]);

    res.status(200).json({
      success: true,
      data: stats[0] || {
        totalAcademies: 0,
        totalRate: 0,
        avgRate: 0,
      },
    });
  } catch (error) {
    console.error(error);
    res
      .status(500)
      .json({ success: false, message: "خطا در دریافت آمار آکادمی‌ها" });
  }
};
const deleteCourseVideo = 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 userId = decodedToken.id;

    const { courseContentId, courseId } = req.body;
    const courseContent = await AcademyContentModel.findById(courseContentId);

    if (!courseContent) {
      return res.status(404).json({
        error: true,
        message: "ویدعو یافت نشد",
      });
    }

    courseContent.status = "reject";

    await courseContent.save();

    const course = await CourseModel.findById(courseId);
    if (course) {
      course.number_of_course_content = `${
        Number(course.number_of_course_content) - 1
      }`;
      await course.save();
    }

    res.status(200).json({
      success: true,
      message: "ویدیو با موفقیت پاک شد",
    });
  } catch (error) {
    console.error("Error:", error);
    res.status(500).json({
      success: false,
      message: "خطا در حذف ویدیو",
      error: error.message,
    });
  }
};

const getChunkDir = (uploadKey) => {
  return path.join(process.cwd(), "storage", "temp-chunks", uploadKey);
};

setInterval(async () => {
  const tempDir = path.join(process.cwd(), "storage", "temp-chunks");
  if (await fs.pathExists(tempDir)) {
    const dirs = await fs.readdir(tempDir);
    const now = Date.now();
    for (const dir of dirs) {
      const dirPath = path.join(tempDir, dir);
      const stat = await fs.stat(dirPath);
      if (now - stat.mtimeMs > 30 * 60 * 1000) {
        // 30 دقیقه
        await fs.remove(dirPath);
        console.log(`Cleaned up old upload: ${dir}`);
      }
    }
  }
}, 60 * 60 * 1000);

const creatCourseVideoChunk = async (req, res, next) => {
  console.log("=== Chunk Video Upload ===");
  console.log("Chunk index:", req.body.chunkIndex);

  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 userId = decodedToken.id;

    const {
      courseId,
      is_free,
      file_name,
      chunk,
      chunkIndex,
      totalChunks,
      originalFileName,
      fileSize,
      mime_type,
    } = req.body;

    if (!chunk) {
      return res.status(422).json({
        error: true,
        message: "تکه فایل ارسال نشده است",
      });
    }

    if (!courseId) {
      return res.status(422).json({
        error: true,
        message: "شناسه دوره الزامی است",
      });
    }

    const base64Data = chunk.split(",")[1] || chunk;
    const buffer = Buffer.from(base64Data, "base64");

    const uploadKey = `${courseId}_${originalFileName}`;
    const chunkDir = getChunkDir(uploadKey);

    await fs.ensureDir(chunkDir);

    const metaPath = path.join(chunkDir, "meta.json");
    if (chunkIndex === "0" || chunkIndex === 0) {
      const metaData = {
        totalChunks: parseInt(totalChunks),
        file_name: file_name,
        originalFileName: originalFileName,
        fileSize: fileSize,
        mime_type: mime_type,
        courseId: courseId,
        is_free: is_free,
        createdAt: Date.now(),
      };
      await fs.writeJson(metaPath, metaData);
    }

    if (!(await fs.pathExists(metaPath))) {
      return res.status(404).json({
        error: true,
        message: "جلسه آپلود یافت نشد",
      });
    }

    const chunkPath = path.join(chunkDir, `chunk_${chunkIndex}`);
    await fs.writeFile(chunkPath, buffer);

    console.log(
      `✅ Chunk ${parseInt(chunkIndex) + 1}/${totalChunks} saved to disk (${
        buffer.length
      } bytes)`
    );

    res.status(200).json({
      success: true,
      message: `تکه ${
        parseInt(chunkIndex) + 1
      } از ${totalChunks} با موفقیت دریافت شد`,
      chunkIndex: chunkIndex,
      totalChunks: totalChunks,
    });
  } catch (error) {
    console.error("Error in creatCourseVideoChunk:", error);
    res.status(500).json({
      success: false,
      message: "خطا در دریافت تکه ویدیو",
      error: error.message,
    });
  }
};

const mergeVideoChunks = async (req, res, next) => {
  console.log("=== Merge Video Chunks ===");

  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 userId = decodedToken.id;

    const { courseId, originalFileName, totalChunks } = req.body;

    const uploadKey = `${courseId}_${originalFileName}`;
    const chunkDir = getChunkDir(uploadKey);
    const metaPath = path.join(chunkDir, "meta.json");

    if (!(await fs.pathExists(chunkDir)) || !(await fs.pathExists(metaPath))) {
      return res.status(404).json({
        error: true,
        message: "داده‌های آپلود یافت نشد",
      });
    }

    const metaData = await fs.readJson(metaPath);

    const existingChunks = await fs.readdir(chunkDir);
    const chunkFiles = existingChunks.filter((f) => f.startsWith("chunk_"));

    if (chunkFiles.length !== parseInt(totalChunks)) {
      return res.status(422).json({
        error: true,
        message: `تعداد تکه‌ها کامل نیست. دریافت شده: ${chunkFiles.length}، مورد نیاز: ${totalChunks}`,
      });
    }

    const chunks = [];
    for (let i = 0; i < parseInt(totalChunks); i++) {
      const chunkPath = path.join(chunkDir, `chunk_${i}`);
      if (!(await fs.pathExists(chunkPath))) {
        return res.status(422).json({
          error: true,
          message: `تکه ${i + 1} پیدا نشد`,
        });
      }
      const chunkBuffer = await fs.readFile(chunkPath);
      chunks.push(chunkBuffer);
    }

    const completeBuffer = Buffer.concat(chunks);
    console.log("Original file size:", completeBuffer.length, "bytes");

    const finalVideoDir = path.join(
      process.cwd(),
      "storage",
      "courses",
      "videos"
    );
    await fs.ensureDir(finalVideoDir);

    let extension = ".mp4";
    if (metaData.mime_type === "video/mp4") extension = ".mp4";
    else if (metaData.mime_type === "video/quicktime") extension = ".mov";
    else if (metaData.mime_type === "video/x-msvideo") extension = ".avi";
    else if (metaData.mime_type === "video/webm") extension = ".webm";

    const safeFileName = `course-${courseId}-${Date.now()}${extension}`;
    const filePath = path.join(finalVideoDir, safeFileName);

    await fs.writeFile(filePath, completeBuffer);
    console.log("Original file saved:", filePath);

    const newAcademyContent = new AcademyContentModel({
      course_video: `/storage/courses/videos/${safeFileName}`,
      type: "video",
      is_free: metaData.is_free === "true" || metaData.is_free === true,
      courseId: courseId,
      file_name: metaData.file_name || metaData.originalFileName,
    });

    await newAcademyContent.save();

    const course = await CourseModel.findById(courseId);
    if (course) {
      course.number_of_course_content = `${
        Number(course.number_of_course_content) + 1
      }`;
      await course.save();
    }

    await fs.remove(chunkDir);

    res.status(200).json({
      success: true,
      message: "ویدیو با موفقیت ثبت شد (در حال پردازش...)",
      data: newAcademyContent,
    });

    if (completeBuffer.length > 20 * 1024 * 1024) {
      // اجرای غیرهمزمان بدون await
      compressVideoInBackground(filePath, safeFileName, newAcademyContent._id);
    }
  } catch (error) {
    console.error("Error in mergeVideoChunks:", error);
    res.status(500).json({
      success: false,
      message: "خطا در ترکیب ویدیو",
      error: error.message,
    });
  }
};

const compressVideoInBackground = async (filePath, fileName, contentId) => {
  console.log(`Starting background compression for ${fileName}`);

  const dir = path.dirname(filePath);
  const tempPath = path.join(dir, `temp-${fileName}`);
  const { exec } = require("child_process");
  const util = require("util");
  const execPromise = util.promisify(exec);

  try {
    await execPromise(
      `ffmpeg -i "${filePath}" -c:v libx264 -crf 28 -preset veryfast -c:a aac -b:a 128k -movflags +faststart "${tempPath}" -y`
    );

    const compressedStat = await fs.stat(tempPath);
    const originalStat = await fs.stat(filePath);

    if (compressedStat.size < originalStat.size) {
      await fs.rename(tempPath, filePath);
      console.log(
        `✅ Background compression done: ${(
          originalStat.size /
          1024 /
          1024
        ).toFixed(2)}MB → ${(compressedStat.size / 1024 / 1024).toFixed(2)}MB`
      );
    } else {
      await fs.remove(tempPath);
      console.log("Compression didn't reduce size, keeping original");
    }
  } catch (error) {
    console.error("Background compression failed:", error.message);
    if (await fs.pathExists(tempPath)) {
      await fs.remove(tempPath);
    }
  }
};

const getUploadStatus = async (req, res) => {
  try {
    const { courseId, originalFileName } = req.query;
    const uploadKey = `${courseId}_${originalFileName}`;
    const chunkDir = getChunkDir(uploadKey);

    if (!(await fs.pathExists(chunkDir))) {
      return res.status(200).json({
        success: true,
        uploadedChunks: [],
        totalChunks: 0,
      });
    }

    const files = await fs.readdir(chunkDir);
    const chunkFiles = files
      .filter((f) => f.startsWith("chunk_"))
      .map((f) => parseInt(f.replace("chunk_", "")))
      .sort((a, b) => a - b);

    const metaPath = path.join(chunkDir, "meta.json");
    let totalChunks = 0;
    if (await fs.pathExists(metaPath)) {
      const metaData = await fs.readJson(metaPath);
      totalChunks = metaData.totalChunks;
    }

    res.status(200).json({
      success: true,
      uploadedChunks: chunkFiles,
      totalChunks: totalChunks,
    });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
};



// ایجاد slug یکتا
const generateUniqueSlug = async (title, excludeId = null) => {
    let slug = title
        .replace(/[^\u0600-\u06FF\uFB8A\u067E\u0686\u06AF\u200C\uFB8E\u0698a-zA-Z0-9\s]/g, '')
        .trim()
        .replace(/\s+/g, '-')
        .toLowerCase();
    
    let uniqueSlug = slug;
    let counter = 1;
    
    while (true) {
        const query = { slug: uniqueSlug };
        if (excludeId) query._id = { $ne: excludeId };
        const exists = await AcademyCategoryModel.findOne(query);
        if (!exists) break;
        uniqueSlug = `${slug}-${counter}`;
        counter++;
    }
    
    return uniqueSlug;
};

// ==================== GET - دریافت لیست دسته‌بندی‌ها ====================
const getAll = async (req, res) => {
    try {
        const {
            page = 1,
            limit = 20,
            sortBy = 'order',
            sortOrder = 'asc',
            status,
            parent,
            search,
            is_featured,
            withChildren = 'false'
        } = req.query;

        let query = {};
        
        if (status) query.status = status;
        if (parent !== undefined) query.parent = parent === 'null' ? null : parent;
        if (is_featured === 'true') query.is_featured = true;
        
        if (search) {
            query.$or = [
                { title: { $regex: search, $options: 'i' } },
                { description: { $regex: search, $options: 'i' } }
            ];
        }

        const sortOptions = {};
        sortOptions[sortBy] = sortOrder === 'asc' ? 1 : -1;

        const options = {
            page: parseInt(page),
            limit: parseInt(limit),
            sort: sortOptions,
            populate: [
                { path: 'parent', select: 'title slug' },
                { path: 'created_by', select: 'user_name name' },
                { path: 'updated_by', select: 'user_name name' }
            ]
        };

        let categories = await AcademyCategoryModel.paginate(query, options);
        
        // دریافت درخت دسته‌بندی (اختیاری)
        if (withChildren === 'true' && !parent) {
            const tree = await AcademyCategoryModel.getTree();
            categories = { ...categories, tree };
        }

        res.status(200).json({
            success: true,
            message: 'لیست دسته‌بندی‌ها با موفقیت دریافت شد',
            data: categories
        });
    } catch (error) {
        console.error('Error in getAll:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در دریافت دسته‌بندی‌ها',
            error: error.message
        });
    }
};

// ==================== GET - دریافت یک دسته‌بندی ====================
const getOne = async (req, res) => {
    try {
        const { id } = req.params;
        const { includeCourses = 'false' } = req.query;

        let query = AcademyCategoryModel.findById(id);
        
        query = query.populate('parent', 'title slug icon color');
        query = query.populate('children', 'title slug icon color course_count order');
        query = query.populate('created_by', 'user_name name');
        
        if (includeCourses === 'true') {
            query = query.populate({
                path: 'courses',
                select: 'cuorse_name course_image price offer',
                options: { limit: 10 }
            });
        }

        const category = await query;

        if (!category) {
            return res.status(404).json({
                success: false,
                message: 'دسته‌بندی یافت نشد'
            });
        }

        res.status(200).json({
            success: true,
            message: 'دسته‌بندی با موفقیت دریافت شد',
            data: category
        });
    } catch (error) {
        console.error('Error in getOne:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در دریافت دسته‌بندی',
            error: error.message
        });
    }
};

// ==================== GET - دریافت درخت دسته‌بندی ====================
const getTree = async (req, res) => {
    try {
        const tree = await AcademyCategoryModel.getTree();
        
        res.status(200).json({
            success: true,
            message: 'درخت دسته‌بندی با موفقیت دریافت شد',
            data: tree
        });
    } catch (error) {
        console.error('Error in getTree:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در دریافت درخت دسته‌بندی',
            error: error.message
        });
    }
};

// ==================== GET - دریافت توسط اسلاگ ====================
const getBySlug = async (req, res) => {
    try {
        const { slug } = req.params;
        const { page = 1, limit = 20 } = req.query;

        const category = await AcademyCategoryModel.getBySlug(slug);

        if (!category) {
            return res.status(404).json({
                success: false,
                message: 'دسته‌بندی یافت نشد'
            });
        }

        // دریافت دوره‌های این دسته
        const courses = await CourseModel.find({
            category_id: category._id,
            status: 'accept'
        })
        .sort({ createdAt: -1 })
        .skip((page - 1) * limit)
        .limit(parseInt(limit));

        const totalCourses = await CourseModel.countDocuments({
            category_id: category._id,
            status: 'accept'
        });

        res.status(200).json({
            success: true,
            message: 'دسته‌بندی با موفقیت دریافت شد',
            data: {
                category,
                courses: {
                    data: courses,
                    pagination: {
                        page: parseInt(page),
                        limit: parseInt(limit),
                        total: totalCourses,
                        pages: Math.ceil(totalCourses / limit)
                    }
                }
            }
        });
    } catch (error) {
        console.error('Error in getBySlug:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در دریافت دسته‌بندی',
            error: error.message
        });
    }
};

// ==================== POST - ایجاد دسته‌بندی جدید ====================
const create = async (req, res) => {
    try {
        const token = req.header("Authorization")?.split(" ")[1];
        if (!token) return res.status(401).json({ success: false, message: "Access Denied" });
        
        const decodedToken = jwt.verify(token, process.env.APP_SECRET);
        const userId = decodedToken.id;

        const {
            title,
            description,
            icon,
            color,
            parent,
            order,
            image,
            is_featured,
            seo_title,
            seo_description
        } = req.body;

        // اعتبارسنجی
        if (!title || title.trim().length < 2) {
            return res.status(422).json({
                success: false,
                message: 'عنوان دسته‌بندی باید حداقل ۲ کاراکتر باشد'
            });
        }

        // بررسی تکراری نبودن عنوان
        const existingTitle = await AcademyCategoryModel.findOne({ title });
        if (existingTitle) {
            return res.status(409).json({
                success: false,
                message: 'این عنوان قبلاً ثبت شده است'
            });
        }

        // تولید slug یکتا
        const slug = await generateUniqueSlug(title);

        // بررسی وجود parent
        let level = 0;
        if (parent) {
            const parentCategory = await AcademyCategoryModel.findById(parent);
            if (!parentCategory) {
                return res.status(404).json({
                    success: false,
                    message: 'دسته‌بندی والد یافت نشد'
                });
            }
            level = parentCategory.level + 1;
            
            if (level > 3) {
                return res.status(422).json({
                    success: false,
                    message: 'عمق دسته‌بندی نمی‌تواند بیشتر از ۳ سطح باشد'
                });
            }
        }

        const newCategory = new AcademyCategoryModel({
            title,
            slug,
            description: description || null,
            icon: icon || null,
            color: color || '#3B82F6',
            parent: parent || null,
            level,
            order: order || 0,
            image: image || null,
            is_featured: is_featured || false,
            seo_title: seo_title || title,
            seo_description: seo_description || description,
            created_by: userId,
            status: 'active'
        });

        await newCategory.save();

        res.status(201).json({
            success: true,
            message: 'دسته‌بندی با موفقیت ایجاد شد',
            data: newCategory
        });
    } catch (error) {
        console.error('Error in create:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در ایجاد دسته‌بندی',
            error: error.message
        });
    }
};

// ==================== PUT/PATCH - ویرایش دسته‌بندی ====================
const update = async (req, res) => {
    try {
        const token = req.header("Authorization")?.split(" ")[1];
        if (!token) return res.status(401).json({ success: false, message: "Access Denied" });
        
        const decodedToken = jwt.verify(token, process.env.APP_SECRET);
        const userId = decodedToken.id;

        const { id } = req.params;
        const updateData = req.body;

        const category = await AcademyCategoryModel.findById(id);
        if (!category) {
            return res.status(404).json({
                success: false,
                message: 'دسته‌بندی یافت نشد'
            });
        }

        // بررسی تکراری نبودن عنوان
        if (updateData.title && updateData.title !== category.title) {
            const existingTitle = await AcademyCategoryModel.findOne({ 
                title: updateData.title,
                _id: { $ne: id }
            });
            if (existingTitle) {
                return res.status(409).json({
                    success: false,
                    message: 'این عنوان قبلاً ثبت شده است'
                });
            }
            
            // آپدیت slug
            updateData.slug = await generateUniqueSlug(updateData.title, id);
        }

        // بررسی parent
        if (updateData.parent) {
            if (updateData.parent === id) {
                return res.status(422).json({
                    success: false,
                    message: 'یک دسته‌بندی نمی‌تواند والد خودش باشد'
                });
            }
            
            const parentCategory = await AcademyCategoryModel.findById(updateData.parent);
            if (!parentCategory) {
                return res.status(404).json({
                    success: false,
                    message: 'دسته‌بندی والد یافت نشد'
                });
            }
            
            updateData.level = parentCategory.level + 1;
            
            if (updateData.level > 3) {
                return res.status(422).json({
                    success: false,
                    message: 'عمق دسته‌بندی نمی‌تواند بیشتر از ۳ سطح باشد'
                });
            }
        }

        updateData.updated_by = userId;
        updateData.updatedAt = new Date();

        const updatedCategory = await AcademyCategoryModel.findByIdAndUpdate(
            id,
            updateData,
            { new: true, runValidators: true }
        );

        res.status(200).json({
            success: true,
            message: 'دسته‌بندی با موفقیت به‌روزرسانی شد',
            data: updatedCategory
        });
    } catch (error) {
        console.error('Error in update:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در به‌روزرسانی دسته‌بندی',
            error: error.message
        });
    }
};

// ==================== DELETE - حذف (سافت دیلیت) ====================
const remove = async (req, res) => {
    try {
        const token = req.header("Authorization")?.split(" ")[1];
        if (!token) return res.status(401).json({ success: false, message: "Access Denied" });
        
        const decodedToken = jwt.verify(token, process.env.APP_SECRET);
        const userId = decodedToken.id;

        const { id } = req.params;
        const { permanent = 'false' } = req.query;

        const category = await AcademyCategoryModel.findById(id);
        if (!category) {
            return res.status(404).json({
                success: false,
                message: 'دسته‌بندی یافت نشد'
            });
        }

        // بررسی وجود زیردسته‌ها
        const hasChildren = await AcademyCategoryModel.exists({ parent: id });
        if (hasChildren) {
            return res.status(422).json({
                success: false,
                message: 'این دسته‌بندی دارای زیردسته است. ابتدا زیردسته‌ها را حذف کنید'
            });
        }

        // بررسی وجود دوره در این دسته
        const hasCourses = await CourseModel.exists({ category_id: id });
        if (hasCourses && permanent === 'true') {
            return res.status(422).json({
                success: false,
                message: 'این دسته‌بندی دارای دوره است. ابتدا دوره‌ها را جابه‌جا کنید'
            });
        }

        if (permanent === 'true') {
            // حذف فیزیکی
            await category.deleteOne();
            res.status(200).json({
                success: true,
                message: 'دسته‌بندی با موفقیت حذف شد'
            });
        } else {
            // سافت دیلیت
            category.status = 'deleted';
            category.updated_by = userId;
            await category.save();
            
            res.status(200).json({
                success: true,
                message: 'دسته‌بندی با موفقیت غیرفعال شد'
            });
        }
    } catch (error) {
        console.error('Error in remove:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در حذف دسته‌بندی',
            error: error.message
        });
    }
};

// ==================== POST - تغییر وضعیت (اکتیو/غیراکتیو) ====================
const toggleStatus = async (req, res) => {
    try {
        const token = req.header("Authorization")?.split(" ")[1];
        if (!token) return res.status(401).json({ success: false, message: "Access Denied" });
        
        const decodedToken = jwt.verify(token, process.env.APP_SECRET);
        const userId = decodedToken.id;

        const { id } = req.params;
        const { status } = req.body; // 'active' or 'inactive'

        if (!['active', 'inactive'].includes(status)) {
            return res.status(422).json({
                success: false,
                message: 'وضعیت نامعتبر است'
            });
        }

        const category = await AcademyCategoryModel.findByIdAndUpdate(
            id,
            { 
                status, 
                updated_by: userId,
                updatedAt: new Date()
            },
            { new: true }
        );

        if (!category) {
            return res.status(404).json({
                success: false,
                message: 'دسته‌بندی یافت نشد'
            });
        }

        res.status(200).json({
            success: true,
            message: `وضعیت دسته‌بندی با موفقیت به ${status === 'active' ? 'فعال' : 'غیرفعال'} تغییر کرد`,
            data: category
        });
    } catch (error) {
        console.error('Error in toggleStatus:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در تغییر وضعیت دسته‌بندی',
            error: error.message
        });
    }
};

// ==================== POST - افزایش تعداد دوره‌ها ====================
const incrementCourseCount = async (req, res) => {
    try {
        const { id } = req.params;
        const { increment = 1 } = req.body;

        const category = await AcademyCategoryModel.incrementCourseCount(id, increment);
        
        if (!category) {
            return res.status(404).json({
                success: false,
                message: 'دسته‌بندی یافت نشد'
            });
        }

        res.status(200).json({
            success: true,
            message: 'تعداد دوره‌ها به‌روزرسانی شد',
            data: { course_count: category.course_count }
        });
    } catch (error) {
        console.error('Error in incrementCourseCount:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در به‌روزرسانی تعداد دوره‌ها',
            error: error.message
        });
    }
};

// ==================== GET - دریافت دسته‌بندی‌های ویژه (featured) ====================
const getFeatured = async (req, res) => {
    try {
        const { limit = 10 } = req.query;
        
        const categories = await AcademyCategoryModel.find({
            is_featured: true,
            status: 'active'
        })
        .sort({ order: 1 })
        .limit(parseInt(limit))
        .populate('parent', 'title slug');

        res.status(200).json({
            success: true,
            message: 'دسته‌بندی‌های ویژه با موفقیت دریافت شد',
            data: categories
        });
    } catch (error) {
        console.error('Error in getFeatured:', error);
        res.status(500).json({
            success: false,
            message: 'خطا در دریافت دسته‌بندی‌های ویژه',
            error: error.message
        });
    }
};


module.exports = {
  // ==========================================
  // 🏢 ماژول آکادمی (Academy)
  // ==========================================
  
  // پیدا کردن آکادمی کاربر جاری
  findAcademy,
  
  // پیدا کردن آکادمی با شناسه
  findAcademyById,
  
  // تکمیل و ویرایش پروفایل آکادمی
  academyProfile,
  
  // تغییر وضعیت آکادمی (فعال/غیرفعال - فقط ادمین)
  updateAcademyStatus,
  
  // دریافت اطلاعات یک آکادمی با شناسه
  getAcademyById,
  
  // ایجاد آکادمی جدید (دستی - معمولاً خودکار ایجاد می‌شود)
  createAcademy,
  
  // ویرایش اطلاعات آکادمی
  updateAcademy,
  
  // حذف آکادمی (به همراه تمام دوره‌های آن)
  deleteAcademy,
  
  // دریافت آمار کلی آکادمی‌ها (تعداد، میانگین امتیاز و...)
  getAcademyStats,

  // ==========================================
  // 📚 ماژول دوره‌ها (Course)
  // ==========================================
  
  // ایجاد دوره جدید
  creatCourse,
  
  // ویرایش اطلاعات دوره
  updateCourse,
  
  // حذف دوره (تغییر وضعیت به reject)
  deleteCourse,
  
  // دریافت لیست دوره‌های آکادمی جاری
  getCourse,
  
  // دریافت لیست همه دوره‌ها با فیلتر و جستجو
  getCourses,
  
  // دریافت دوره‌های یک آکادمی خاص
  getAcademyCourse,
  
  // آپلود ویدیو با روش Multipart
  creatCourseVideo,
  
  // آپلود ویدیو با روش Base64 (برای فایل‌های کوچک)
  creatCourseVideoBase64,

  // ==========================================
  // 💳 ماژول پرداخت (Payment)
  // ==========================================
  
  // پرداخت برای اشتراک پرو
  proPayment,
  
  // کال‌بک درگاه پرداخت زرین‌پال (اشتراک پرو)
  handleCoursePaymentCallback,
  
  // پرداخت برای خرید دوره
  coursePayment,
  
  // کال‌بک درگاه پرداخت زرین‌پال (خرید دوره)
  CoursePaymentCallback,

  // ==========================================
  // 🎬 ماژول محتوای دوره (Course Content)
  // ==========================================
  
  // دریافت محتوای دوره (لیست ویدیوها و فایل‌ها)
  getCourseContent,
  
  // حذف ویدیو از دوره
  deleteCourseVideo,
  
  // لایک کردن محتوا
  likeCourseContent,
  
  // حذف لایک (دیسلایک)
  dontLikeCourseContent,
  
  // دریافت تعداد لایک‌های یک دوره
  getCourseLikesCount,
  
  // دریافت لیست دوره‌های لایک شده توسط کاربر
  getUserLikedCourses,
  
  // بررسی وضعیت لایک کاربر (آیا لایک کرده یا نه)
  isLikeCourseContent,
  
  // ==========================================
  // 💬 ماژول کامنت‌ها (Comments)
  // ==========================================
  
  // ایجاد کامنت جدید
  createComment,
  
  // دریافت تعداد کل کامنت‌های یک دوره
  getTotalCommentsCount,
  
  // دریافت لیست کامنت‌های یک دوره (با فیلتر و صفحه‌بندی)
  getCourseComments,
  
  // تغییر وضعیت کامنت (تایید/رد/در انتظار)
  updateCommentStatus,
  
  // دریافت کامنت‌های یک کاربر خاص
  getUserComments,
  
  // حذف کامنت
  deleteComment,
  
  // ==========================================
  // 🛒 ماژول دوره‌های خریداری شده (Purchased)
  // ==========================================
  
  // دریافت دوره‌های خریداری شده توسط کاربر جاری
  getUserPurchasedCourses,
  
  // دریافت دوره‌های خریداری شده (با populate - روش بهینه)
  getUserPurchasedCoursesWithPopulate,
  
  // دریافت همه پرداخت‌های آکادمی
  getAllAcademyPayments,
  
  // بررسی خرید یک دوره توسط کاربر (برای صفحه دوره)
  checkCoursePurchase,

  // ==========================================
  // 👑 ماژول مدیریتی (Admin Panel)
  // ==========================================
  
  // ------ مدیریت پرداخت‌ها ------
  
  // دریافت همه پرداخت‌های سیستم (ادمین)
  getAllPayments,
  
  // تغییر وضعیت پرداخت (pending/success/settled/failed)
  updatePaymentStatus,
  
  // ------ مدیریت دوره‌ها ------
  
  // دریافت همه دوره‌های سیستم (ادمین)
  getAllCourses,
  
  // تغییر وضعیت دوره (تایید/رد/در انتظار)
  updateCourseStatus,
  
  // حذف کامل دوره از سیستم (ادمین)
  admindeleteCourse,
  
  // ------ مدیریت دوره‌های خریداری شده ------
  
  // دریافت همه خریدهای سیستم (ادمین)
  getAllPurchasedCourses,
  
  // ------ مدیریت آکادمی‌ها ------
  
  // دریافت همه آکادمی‌های سیستم (ادمین)
  getAllAcademies,
  
  // ------ مدیریت تنظیمات ------
  
  // دریافت تنظیمات (تکس، قیمت‌ها و...)
  getSettings,
  
  // به‌روزرسانی تنظیمات
  updateSettings,
  
  // دریافت قیمت دوره‌ها (پرو، لجند، معمولی)
  getCoursePrices,
  
  // به‌روزرسانی قیمت یک نوع دوره
  updateCoursePrice,
  
  // دریافت درصد مالیات
  getTax,
  
  // به‌روزرسانی درصد مالیات
  updateTax,
  
  // دریافت همه تنظیمات یکجا
  getAllSettings,
  
  // به‌روزرسانی همه تنظیمات یکجا
  updateAllSettings,

  // ==========================================
  // 📊 ماژول آمار (Stats)
  // ==========================================
  
  // دریافت آمار پرداخت‌ها
  getPaymentStats,
  
  // دریافت اطلاعات یک دوره با شناسه
  getCourseById,
  
  // ایجاد دوره جدید (ادمین)
  createCourse,
  
  // ویرایش دوره (ادمین)
  updateCourse,
  
  // دریافت آمار کلی دوره‌ها
  getCourseStats,
  
  // دریافت آمار دوره‌های خریداری شده
  getPurchasedStats,
  
  // ==========================================
  // 📹 ماژول آپلود تکه‌تکه (Chunk Upload)
  // ==========================================
  
  // دریافت تکه ویدیو (هر بار یک تکه)
  creatCourseVideoChunk,
  
  // ادغام تکه‌ها بعد از اتمام آپلود
  mergeVideoChunks,
  
  // بررسی وضعیت آپلود (برای ادامه از جای قطع شده)
  getUploadStatus,

  // ==========================================
  // 🏷️ ماژول دسته‌بندی آکادمی (Category)
  // ==========================================
  
  // دریافت لیست دسته‌بندی‌ها (با فیلتر و صفحه‌بندی)
  getAll,
  
  // دریافت یک دسته‌بندی با شناسه
  getOne,
  
  // دریافت درخت دسته‌بندی (ساختار سلسله‌مراتبی والد-فرزند)
  getTree,
  
  // دریافت دسته‌بندی با اسلاگ (برای سئو و لینک‌های زیبا)
  getBySlug,
  
  // ایجاد دسته‌بندی جدید
  create,
  
  // ویرایش دسته‌بندی
  update,
  
  // حذف دسته‌بندی (سافت دیلیت - فقط غیرفعال می‌شود)
  remove,
  
  // تغییر وضعیت دسته‌بندی (فعال/غیرفعال)
  toggleStatus,
  
  // افزایش تعداد دوره‌های دسته‌بندی
  incrementCourseCount,
  
  // دریافت دسته‌بندی‌های ویژه (برای نمایش در صفحه اصلی)
  getFeatured
};