const News = require("../models/News");
const { body, validationResult } = require("express-validator");
const sharp = require("sharp");
const { _sr } = require("../plugins/serverResponses");
const {
  res404,
  res500,
  checkValidations,
} = require("../plugins/controllersHelperFunctions");
const Category = require("../models/Category");
const Comment = require("../models/Comment");
const User = require("../models/User");
const fs = require("fs");
const NewsFile = require("../models/NewsFile");
const Polls = require("../models/Polls");
const moment = require("moment-jalaali");

////// variables
const noCover = "/img/no-cover.jpg";
const coverNewsWidth = 1920;
const coverNewsHeight = 1080;
const coverQuality = 100;

const thumbCoverNewsWidth = 600;
const thumbCoverNewsHeight = 300;
const thumbCoverQuality = 100;

const limit = 20;
const newsPerPageLimit = 16;
const galleryPerPageLimit = 5;

const shortTitleFront = 150;
const shortTitlePanel = 20;
const shortSumTitle = 250;

const titleFilterRegex = new RegExp("/", "g");

// helper functions

const changePriority = async (catId, modelType) => {
  try {
    const getAllNews = await News.find({
      catId,
      modelType,
      priority: true,
    });

    for (const item of getAllNews) {
      item.priority = false;
      await item.save();
    }

    return true;
  } catch (error) {
    console.log(error);
    return false;
  }
};

const randomNews = async (queryObject) => {
  let setSkip;
  try {
    let temp = [];
    const result = [];
    /** total of news */
    const count = await News.countDocuments(queryObject);

    if (count < 3) {
      return await News.find(queryObject);
    }

    /** get random index number */
    while (temp.length < 3) {
      setSkip = Math.floor(Math.random() * count);
      temp.push(setSkip);
      /** remove duplicate numbers */
      temp = [...new Set(temp)];
    }

    /** get news and push to result */
    for (let i = 0; i < 3; i++) {
      const getNews = await News.findOne(queryObject).skip(temp[i]);

      if (getNews) {
        result.push(getNews);
      }
    }

    /** return result */
    return result;
  } catch (error) {
    console.log(error);
    /** return error */
    return [];
  }
};

const _checkSpecPermission = async (req, category) => {
  return (
    !req.user.specialPermissions.includes(category._id) && //check parent id exist in special permissions or not
    !req.user.specialPermissions.some((item) =>
      category?.treeCat?.join().includes(item)
    )
  );
};

const handleFileUploads = async (req, res, targetNews) => {
  let hasCover = false;
  let hasThumb = false;
  const timestamp = Date.now();

  if (req.files.cover) {
    const image = req.files.cover;
    if (!_sr.supportedImageFormats.includes(image.mimetype.split("/")[1])) {
      throw new Error(_sr["fa"].format.image);
    }

    // حذف کاور قدیمی در صورت وجود
    if (targetNews.cover && targetNews.cover !== noCover) {
      const oldCoverPath = `./static/uploads/images/news/${targetNews.cover}`;
      if (fs.existsSync(oldCoverPath)) {
        fs.unlinkSync(oldCoverPath);
      }
    }

    const imageName = `news_cover_${timestamp}_${targetNews._id}.${
      image.mimetype.split("/")[1]
    }`;
    try {
      const target = sharp(image.data);
      await target
        .resize(coverNewsWidth, coverNewsHeight, {
          fit: "cover",
        })
        .jpeg({
          quality: coverQuality,
        })
        .toFile(`./static/uploads/images/news/${imageName}`);

      targetNews.cover = imageName;
      hasCover = true;
    } catch (e) {
      throw new Error(e?.message);
    }

    // اگر thumbCover ارسال نشده، از همین تصویر thumbCover بسازیم
    if (!req.files.thumbCover) {
      if (targetNews.thumbCover && targetNews.thumbCover !== noCover) {
        const oldThumbPath = `./static/uploads/images/news/${targetNews.thumbCover}`;
        if (fs.existsSync(oldThumbPath)) {
          fs.unlinkSync(oldThumbPath);
        }
      }

      const thumbImageName = `news_thumb_${timestamp}_${targetNews._id}.${
        image.mimetype.split("/")[1]
      }`;
      try {
        const target = sharp(image.data);
        await target
          .resize(thumbCoverNewsWidth, thumbCoverNewsHeight, {
            fit: "cover",
          })
          .jpeg({
            quality: thumbCoverQuality,
          })
          .toFile(`./static/uploads/images/news/${thumbImageName}`);

        targetNews.thumbCover = thumbImageName;
        hasThumb = true;
      } catch (e) {
        throw new Error(e?.message);
      }
    }
  }

  if (req.files.thumbCover) {
    const image = req.files.thumbCover;
    if (!_sr.supportedImageFormats.includes(image.mimetype.split("/")[1])) {
      throw new Error(_sr["fa"].format.image);
    }

    // حذف thumb قدیمی در صورت وجود
    if (targetNews.thumbCover && targetNews.thumbCover !== noCover) {
      const oldThumbPath = `./static/uploads/images/news/${targetNews.thumbCover}`;
      if (fs.existsSync(oldThumbPath)) {
        fs.unlinkSync(oldThumbPath);
      }
    }

    const thumbImageName = `news_thumb_${timestamp}_${targetNews._id}.${
      image.mimetype.split("/")[1]
    }`;
    try {
      const target = sharp(image.data);
      await target
        .resize(thumbCoverNewsWidth, thumbCoverNewsHeight, {
          fit: "cover",
        })
        .jpeg({
          quality: thumbCoverQuality,
        })
        .toFile(`./static/uploads/images/news/${thumbImageName}`);

      targetNews.thumbCover = thumbImageName;
      hasThumb = true;
    } catch (e) {
      throw new Error(e?.message);
    }

    // اگر cover ارسال نشده، از همین تصویر cover بسازیم
    if (!req.files.cover) {
      if (targetNews.cover && targetNews.cover !== noCover) {
        const oldCoverPath = `./static/uploads/images/news/${targetNews.cover}`;
        if (fs.existsSync(oldCoverPath)) {
          fs.unlinkSync(oldCoverPath);
        }
      }

      const coverImageName = `news_cover_${timestamp}_${targetNews._id}.${
        image.mimetype.split("/")[1]
      }`;
      try {
        const target = sharp(image.data);
        await target
          .resize(coverNewsWidth, coverNewsHeight, {
            fit: "cover",
          })
          .jpeg({
            quality: coverQuality,
          })
          .toFile(`./static/uploads/images/news/${coverImageName}`);

        targetNews.cover = coverImageName;
        hasCover = true;
      } catch (e) {
        throw new Error(e?.message);
      }
    }
  }

  // به‌روزرسانی وضعیت خبر - خبر کامل است اگر حداقل یکی از تصاویر آپلود شده باشد یا قبلاً موجود باشد
  const currentHasCover = targetNews.cover && targetNews.cover !== noCover;
  const currentHasThumb =
    targetNews.thumbCover && targetNews.thumbCover !== noCover;
  targetNews.newsStatus =
    hasCover || hasThumb || currentHasCover || currentHasThumb;
};

/////////////////////////////////////////////////////////////////////// admin
module.exports.addNews = [
  [
    body("title")
      .notEmpty()
      .withMessage(_sr["fa"].required.title)
      .custom((value) => {
        return News.findOne({
          title: value,
        }).then((news) => {
          if (news) return Promise.reject(_sr["fa"].duplicated.title);
          else return true;
        });
      }),

    // body('summaryTitle')
    //     .notEmpty().withMessage(_sr['fa'].required.caption),

    body("leadTitle").notEmpty().withMessage(_sr["fa"].required.caption),

    body("catId")
      .isMongoId()
      .withMessage(_sr["fa"].required.field)
      .if((value, { req }) => {
        return req.body.catId;
      })
      .custom((value) => {
        return Category.findOne({
          _id: value,
        }).then((category) => {
          if (!category) return Promise.reject(_sr["fa"].not_found.category);
          else return true;
        });
      }),

    body("priority")
      .optional()
      .isBoolean()
      .withMessage(_sr["fa"].format.boolean),

    body("allowComment")
      .optional()
      .isBoolean()
      .withMessage(_sr["fa"].format.boolean),

    body("showInHome").isBoolean().withMessage(_sr["fa"].format.boolean),

    body("notifications").isBoolean().withMessage(_sr["fa"].format.boolean),

    // body('slider')
    //   .optional().isBoolean().withMessage(_sr['fa'].format.boolean),

    body("special").isBoolean().withMessage(_sr["fa"].format.boolean),

    body("siteMap")
      .optional()
      .isBoolean()
      .withMessage(_sr["fa"].format.boolean),

    body("publish").isBoolean().withMessage(_sr["fa"].format.boolean),

    body("keywords")
      .if((value) => {
        return value;
      })
      .custom((value) => {
        const keywords = _.isString(value) ? JSON.parse(value) : value;
        if (!_.isArray(keywords)) {
          return Promise.reject(`این فیلد باید به صورت آرایه فرستاده شود`);
        }

        return true;
      }),

    body("metaTagDesc").optional(),

    body("modelType").custom((value, { req }) => {
      if (req.user.portals.join() === portal.join()) {
        if (!portal.includes(value)) {
          return Promise.reject(`${_sr["fa"].optional.onlyValid} => ${portal}`);
        } else {
          return true;
        }
      } else {
        return true;
      }
    }),

    body("newsFileId")
      .optional()
      .isMongoId()
      .withMessage(`لطفا یک ای دی صحیح ارسال کنید`),
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty())
      return res.status(422).json({
        validation: errors.mapped(),
      });

    try {
      let {
        title,
        summaryTitle,
        leadTitle,
        catId,
        PublisherId,
        priority,
        allowComment,
        showInHome,
        special,
        notifications,
        siteMap,
        publish,
        pageContent,
        content,
        keywords,
        metaTagDesc,
        modelType,
        // slider,
        newsFileId,
      } = req.body;

      keywords = _.isString(keywords) ? JSON.parse(keywords) : keywords;

      /** set portals */
      modelType =
        req.user.portals.join() === portal.join()
          ? modelType
          : req.user.portals[0];
      //  const isPublisher = await User.findById(PublisherId)
      //  if(!isPublisher){
      //      return res.status(404).json({message:"کاربر وجود ندارد"})
      //  }
      // if(!isPublisher.scope.includes('PublisherNews')){
      //    return res.status(401).json({message:"شما دسترسی برای انتشار را ندارید"})
      // }
      if (newsFileId) {
        let checkNewsFile = await NewsFile.findOne({
          _id: newsFileId,
        });

        if (!checkNewsFile) {
          return res404(res, `پرونده خبری انخاب شده وجود ندارد`);
        }

        if (checkNewsFile.modelType !== modelType) {
          return res.status(422).json({
            validation: {
              newsFileId: {
                msg: `نوع خبر مورد نظر با نوع پرونده خبری متفاوت است`,
              },
            },
          });
        }
      }

      const newsData = {
        title: title?.trim()?.replace(titleFilterRegex, "/"),
        summaryTitle: summaryTitle?.trim(),
        leadTitle: leadTitle?.trim(),
        catId,
        priority,
        showInHome,
        publish,
        pageContent,
        PublisherId,
        special,
        content,
        allowComment,
        notifications,
        siteMap,
        keywords,
        // slider,
        _creator: req.user._id,
        _updatedBy: req.user._id,
        metaTagDesc: metaTagDesc ? metaTagDesc : leadTitle,
        modelType,
        newsFileId,
        shortTitleFront: title?.trim()?.slice(0, shortTitleFront),
        shortTitlePanel: title?.trim()?.slice(0, shortTitlePanel),
        shortSummaryTitle: summaryTitle?.trim()?.slice(0, shortSumTitle),
      };

      if (catId) {
        /** get category with populate parent */
        const category = await Category.findOne({
          _id: catId,
        }).populate({
          path: "parent",
          populate: {
            path: "parent",
            model: "Category",
          },
        });

        /** if undefined we have error from database */
        if (!category) {
          return res404(res, `دسته بندی انتخاب شده برای این خبر پیدا نشد`);
        }

        /** check special permission */
        if (
          req.user.specialPermissions.length &&
          (await _checkSpecPermission(req, category))
        ) {
          return res.status(403).json({
            message: `شما نمیتوانید این دسته بندی را انتخاب کنید`,
          });
        }

        if (category.modelType !== modelType) {
          return res.status(403).json({
            message: `شما اجازه استفاده از این دسته بندی را ندارید`,
          });
        }

        newsData.allCat = category.treeCat;
        newsData.rootParent = category.rootParent || category._id;

        if (priority === "true") {
          await changePriority(category._id, modelType);
        }
      }

      const createNews = await News.create(newsData);

      if (!createNews) {
        return res500(res, `error in add news to data base`);
      }

      /**
       * if we have pic upload to server
       */
      if (req.files) {
        let hasCover = false;
        let hasThumb = false;
        const timestamp = Date.now();

        if (req.files.cover) {
          const image = req.files.cover;
          if (
            !_sr.supportedImageFormats.includes(image.mimetype.split("/")[1])
          ) {
            return res.status(422).json({
              validation: {
                cover: {
                  msg: _sr["fa"].format.image,
                },
              },
            });
          }
          const imageName = `news_cover_${timestamp}_${createNews._id}.${
            image.mimetype.split("/")[1]
          }`;
          try {
            const target = sharp(image.data);
            await target
              .resize(coverNewsWidth, coverNewsHeight, {
                fit: "cover",
              })
              .jpeg({
                quality: coverQuality,
              })
              .toFile(`./static/uploads/images/news/${imageName}`);

            createNews.cover = imageName;
            hasCover = true;
          } catch (e) {
            return res500(res, e?.message);
          }

          // اگر thumbCover ارسال نشده، از همین تصویر thumbCover بسازیم
          if (!req.files.thumbCover) {
            const thumbImageName = `news_thumb_${timestamp}_${createNews._id}.${
              image.mimetype.split("/")[1]
            }`;
            try {
              const target = sharp(image.data);
              await target
                .resize(thumbCoverNewsWidth, thumbCoverNewsHeight, {
                  fit: "cover",
                })
                .jpeg({
                  quality: thumbCoverQuality,
                })
                .toFile(`./static/uploads/images/news/${thumbImageName}`);

              createNews.thumbCover = thumbImageName;
              hasThumb = true;
            } catch (e) {
              return res500(res, e?.message);
            }
          }
        }

        if (req.files.thumbCover) {
          const image = req.files.thumbCover;
          if (
            !_sr.supportedImageFormats.includes(image.mimetype.split("/")[1])
          ) {
            return res.status(422).json({
              validation: {
                thumbCover: {
                  msg: _sr["fa"].format.image,
                },
              },
            });
          }
          const thumbImageName = `news_thumb_${timestamp}_${createNews._id}.${
            image.mimetype.split("/")[1]
          }`;
          try {
            const target = sharp(image.data);
            await target
              .resize(thumbCoverNewsWidth, thumbCoverNewsHeight, {
                fit: "cover",
              })
              .jpeg({
                quality: thumbCoverQuality,
              })
              .toFile(`./static/uploads/images/news/${thumbImageName}`);

            createNews.thumbCover = thumbImageName;
            hasThumb = true;
          } catch (e) {
            return res500(res, e?.message);
          }

          // اگر cover ارسال نشده، از همین تصویر cover بسازیم
          if (!req.files.cover) {
            const coverImageName = `news_cover_${timestamp}_${createNews._id}.${
              image.mimetype.split("/")[1]
            }`;
            try {
              const target = sharp(image.data);
              await target
                .resize(coverNewsWidth, coverNewsHeight, {
                  fit: "cover",
                })
                .jpeg({
                  quality: coverQuality,
                })
                .toFile(`./static/uploads/images/news/${coverImageName}`);

              createNews.cover = coverImageName;
              hasCover = true;
            } catch (e) {
              return res500(res, e?.message);
            }
          }
        }

        // خبر کامل است اگر حداقل یکی از تصاویر آپلود شده باشد
        createNews.newsStatus = hasCover || hasThumb;
        await createNews.save();
      }

      /**
       * show result
       */
      return res.json(createNews);
    } catch (error) {
      console.log(error);
      /**
       * if we got unkown error show to client
       */
      res500(res, error.message);
    }
  },
];

module.exports.addAllNews = [
  async (req, res) => {
    try {
      // // const parsedData = req.files.file
      // const {rootParent, category, creator, catIdOstan} = req.body
      // const rawFile = await fs.readFileSync(`./server/csvjson.json`)
      // const parsedData = await JSON.parse(rawFile)
      //
      // // console.log(parsedData)
      //
      // const posts = []
      //
      // // dynamic
      // // const rootParent = '60e95a43111ba696ea3d5171' // فرمانداری ها
      // // const category = '60e95c7d111ba696ea3d5301' // فرماندای شهرستان خنداب
      //
      // // static
      // // const creator = '60eaaf8db36930ef88d3d377'
      //
      // const newArray = []
      //
      // for (const item of parsedData) {
      //     if (item.term_taxonomy_id.toString() === catIdOstan) {
      //         // console.log(item.term_taxonomy_id)
      //         newArray.push(item)
      //     }
      // }
      //
      // console.log('-- posts length: ', newArray.length)
      //
      // let index = 0
      // for (const item of newArray) {
      //     const newPost = new News({
      //         title: item.post_title,
      //         shortTitlePanel: item.post_title,
      //         shortTitleFront: item.post_title,
      //         summaryTitle: item.post_title,
      //         leadTitle: '',
      //         shortSummaryTitle: item.post_title,
      //         customDate: item.post_date,
      //         /// ****************************************
      //         catId: category,
      //         /// ****************************************
      //         allCat: [],
      //         newsFileId: null,
      //         /// ****************************************
      //         rootParent: rootParent,
      //         /// ****************************************
      //         priority: false,
      //         allowComment: false,
      //         showInHome: false,
      //         slider: false,
      //         publish: true,
      //         pageContent: item.post_content,
      //         cover: null,
      //         thumbCover: null,
      //         userViews: 200,
      //         special: false,
      //         notifications: false,
      //         _creator: creator,
      //         _updatedBy: creator,
      //         siteMap: true,
      //         keywords: [],
      //         metaTagDesc: item.post_title,
      //         newsStatus: true,
      //         modelType: 'ostandari',
      //         attachments: [],
      //         imported: true
      //     })
      //     await newPost.save()
      //     if (index === newArray.length - 1) console.log('---- data entry finished')
      //     index++
      // }

      const news = await News.find({ catId: "60e931d5111ba696ea3d483b" });
      // const regex = new RegExp('/', 'g')
      let index = 0;
      for await (const item of news) {
        console.log(index);
        // item.title = item.title.replace(regex, ',')
        item.catId = "60e931fc111ba696ea3d485b";
        item.allCat = ["60e931d5111ba696ea3d483b"];
        await item.save();
        if (index === news.length - 1) console.log("update finished");
        index++;
      }

      /**
       * show result
       */
      return res.json(news);
    } catch (error) {
      console.log(error);
      /**
       * if we got unkown error show to client
       */
      return res500(res, error.message);
    }
  },
];

module.exports.updateNews = [
  [
    body("title").notEmpty().withMessage(_sr["fa"].required.title),
    body("leadTitle").notEmpty().withMessage(_sr["fa"].required.field),
    body("catId")
      .notEmpty()
      .withMessage(_sr["fa"].required.field)
      .bail()
      .isMongoId()
      .withMessage("شناسه دسته بندی معتبر نیست")
      .bail()
      .custom((value) => {
        return Category.findById(value).then((category) => {
          if (!category) {
            return Promise.reject(_sr["fa"].not_found.category);
          }
        });
      }),
    body("priority")
      .optional()
      .isBoolean()
      .withMessage(_sr["fa"].format.boolean),
    body("allowComment")
      .optional()
      .isBoolean()
      .withMessage(_sr["fa"].format.boolean),
    body("notifications").isBoolean().withMessage(_sr["fa"].format.boolean),
    body("showInHome").isBoolean().withMessage(_sr["fa"].format.boolean),
    body("special").isBoolean().withMessage(_sr["fa"].format.boolean),
    body("siteMap")
      .optional()
      .isBoolean()
      .withMessage(_sr["fa"].format.boolean),
    body("publish").isBoolean().withMessage(_sr["fa"].format.boolean),
    body("keywords")
      .optional()
      .custom((value) => {
        try {
          const keywords = _.isString(value) ? JSON.parse(value) : value;
          if (!Array.isArray(keywords)) {
            throw new Error("این فیلد باید به صورت آرایه فرستاده شود");
          }
          return true;
        } catch (error) {
          throw new Error("این فیلد باید به صورت آرایه فرستاده شود");
        }
      }),
    body("metaTagDesc").optional(),
    body("modelType").custom((value, { req }) => {
      if (req.user.portals.join() === portal.join()) {
        if (!portal.includes(value)) {
          return Promise.reject(`${_sr["fa"].optional.onlyValid} => ${portal}`);
        }
      }
      return true;
    }),
    body("newsFileId")
      .optional()
      .isMongoId()
      .withMessage("شناسه فایل خبری معتبر نیست"),
    body("customDate")
      .optional()
      .isString()
      .withMessage("لطفا یک تاریخ صحیح وارد نمایید"),
  ],
  async (req, res) => {
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(422).json({ validation: errors.mapped() });
    }

    try {
      const {
        title,
        summaryTitle,
        leadTitle,
        catId,
        priority,
        notifications,
        showInHome,
        special,
        siteMap,
        content,
        publish,
        pageContent,
        allowComment,
        keywords,
        metaTagDesc,
        modelType,
        newsFileId,
        customDate,
      } = req.body;

      let parsedKeywords = keywords;
      if (_.isString(keywords)) {
        parsedKeywords = JSON.parse(keywords);
      }

      const newsId = req.params.id;
      const targetNews = await News.findById(newsId).populate("catId");

      if (!targetNews) {
        return res404(res, "خبر مورد نظر پیدا نشد");
      }

      if (
        req.user.specialPermissions.length &&
        (await _checkSpecPermission(req, targetNews.catId))
      ) {
        return res
          .status(403)
          .json({ message: "شما اجازه بروزرسانی این خبر را ندارید" });
      }

      if (!req.user.portals.includes(targetNews.modelType)) {
        return res500(res, "شما اجازه آپدیت این خبر را ندارید");
      }

      if (targetNews.title !== title) {
        const checkDuppTitle = await News.findOne({ title });
        if (checkDuppTitle) {
          return res.status(422).json({
            validation: { title: { msg: _sr["fa"].duplicated.title } },
          });
        }
      }

      const category = await Category.findById(catId).populate({
        path: "parent",
        populate: {
          path: "parent",
          model: "Category",
        },
      });

      if (catId && targetNews.catId.toString() !== catId.toString()) {
        targetNews.allCat = category.treeCat;
        targetNews.rootParent = category.rootParent || category._id;
      }

      if (priority === "true") {
        await changePriority(category._id, modelType);
      }

      if (newsFileId) {
        const checkNewsFile = await NewsFile.findById(newsFileId);
        if (!checkNewsFile) {
          return res404(res, "پرونده خبری انخاب شده وجود ندارد");
        }
        if (checkNewsFile.modelType !== modelType) {
          return res.status(422).json({
            validation: {
              newsFileId: {
                msg: "نوع خبر مورد نظر با نوع پرونده خبری متفاوت است",
              },
            },
          });
        }
      }

      if (req.files) {
        try {
          await handleFileUploads(req, res, targetNews);
        } catch (error) {
          return res.status(422).json({
            validation: {
              cover: { msg: error.message },
            },
          });
        }
      }

      Object.assign(targetNews, {
        title: title.trim().replace(titleFilterRegex, "/"),
        summaryTitle: summaryTitle?.trim(),
        leadTitle: leadTitle?.trim(),
        catId,
        priority,
        notifications,
        showInHome,
        special,
        siteMap,
        publish,
        allowComment,
        content,
        pageContent,
        keywords: parsedKeywords,
        metaTagDesc: metaTagDesc?.trim() || leadTitle?.trim(),
        newsFileId,
        shortTitleFront: title.slice(0, shortTitleFront),
        shortTitlePanel: title.slice(0, shortTitlePanel),
        shortSummaryTitle: summaryTitle?.trim()?.slice(0, shortSumTitle),
        customDate: customDate || targetNews.created_at,
        _updatedBy: req.user._id,
      });

      if (customDate) {
        targetNews.customDateHistory.push({
          customDate,
          _updatedBy: req.user._id,
        });
      }

      await targetNews.save();
      return res.json(targetNews);
    } catch (error) {
      return res500(res, error.message);
    }
  },
];

module.exports.MostViewdNews = [
  async (req, res) => {
    const thirtyDaysAgo = new Date();
    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
    try {
      const mostViewedNews = await News.find({
        customDate: { $gte: thirtyDaysAgo },
      })
        .sort({ userViews: -1 })
        .limit(10);

      return res.status(200).json({ mostViewedNews });
    } catch (error) {
      res.status(500).send("خطا");
    }
  },
];
module.exports.deletOneNews = [
  async (req, res) => {
    let oldPic;
    try {
      const newsId = req.params.id;

      const targetNews = await News.findOne({
        _id: newsId,
      }).populate("catId");

      /** check news exist or not */
      if (!targetNews) {
        return res404(res, `خبر مورد نظر پیدا نشد`);
      }

      /** check special permission */
      if (
        req.user.specialPermissions.length &&
        (await _checkSpecPermission(req, targetNews.catId))
      ) {
        return res.status(403).json({
          message: `شما مجاز به حذف این خبر نمی باشید`,
        });
      }

      if (
        targetNews?.superNews &&
        req.user._id.toString() !== targetNews._creator.toString()
      ) {
        return res.status(403).json({
          message: `شما مجاز به حذف این خبر نمی باشید`,
        });
      }

      /** check access portal */
      if (!req.user.portals.includes(targetNews.modelType)) {
        return res500(res, `شما اجازه حذف این خبر را ندارید`);
      }

      if (targetNews.cover !== noCover) {
        oldPic = `./static${targetNews.cover}`;

        if (fs.existsSync(oldPic)) {
          fs.unlink(oldPic, (error) => {
            if (error) return res500(res, error?.message);
          });
        }
      }

      if (targetNews.thumbCover !== noCover) {
        oldPic = `./static${targetNews.thumbCover}`;

        if (fs.existsSync(oldPic)) {
          fs.unlink(oldPic, (error) => {
            if (error) return res500(res, error?.message);
          });
        }
      }

      await targetNews.deleteOne();

      await Comment.deleteMany({ modelRef: targetNews._id });
      x;
      return res.json(targetNews);
    } catch (error) {
      return res500(res, error);
    }
  },
];

module.exports.deleteAllNews = [
  async (req, res) => {
    try {
      await News.deleteMany({ imported: true });

      return res.json("ok");
    } catch (error) {
      /**
       * if we got unkown error show to client
       */
      return res500(res, error.message);
    }
  },
];

module.exports.getOneNews = [
  async (req, res) => {
    try {
      const newsId = req.params.id;

      const findQuery = {
        _id: newsId,
      };

      const news = await News.findOne(findQuery).populate("catId");

      if (!news) {
        return res404(res, `خبر مورد نظر پیدا نشد`);
      }

      /** check special permission */
      if (
        req.user.specialPermissions.length &&
        (await _checkSpecPermission(req, news.catId))
      ) {
        return res.status(403).json({
          message: `شما مجاز به دیدن اطلاعات این خبر نمی باشید`,
        });
      }

      /** check access portal */
      if (!req.user.portals.includes(news.modelType)) {
        return res.status(403).json({
          message: `شما اجازه دسترسی به اطلاعات این خبر را ندارید`,
        });
      }

      /**
       * show result
       */
      return res.json(news);
    } catch (error) {
      /**
       * if we got unknown error show to client
       */
      res500(res, error);
    }
  },
];

module.exports.getAll = [
  async (req, res) => {
    try {
      let findQuery = {};

      // @todo can change it
      if (req.user.specialPermissions.length) {
        findQuery.catId = { $in: req.user.specialPermissions };
      }

      if (req.user.portals.length) {
        findQuery.modelType = {
          $in: req.user.portals,
        };
      }

      /** get all news */
      // var allNews = await News.find(findQuery).populate('_creator', {
      //   firstName: 1,
      //   lastName: 1,
      //   profilePic: 1
      // })
      // .populate('catId')
      // .sort({
      //   created_at: -1
      // });

      let allNews = await News.paginate(findQuery, {
        page: req.query.page,
        limit,
        populate: [
          {
            path: "_creator",
            select: {
              firstName: 1,
              lastName: 1,
              profilePic: 1,
            },
          },
          {
            path: "catId",
          },
        ],
        sort: {
          customDate: -1,
        },
      });

      /** if null we have error */
      if (!allNews) {
        return res500(res, `مشکلی در گرفتن اطلاعات پیش آمده است`);
      }

      /** show result to client */
      return res.json(allNews);
    } catch (error) {
      console.log(error);
      /** if we have unknown error show it */
      return res500(res, error?.message);
    }
  },
];

module.exports.search = [
  async (req, res) => {
    try {
      let findQuery = {};
      findQuery["$and"] = [];
      findQuery["$or"] = [];

      let {
        term,
        catId,
        showInHome,
        publish,
        portals,
        status,
        notifications,
        special,
        newsFile,
        date,
      } = req.body;

      /** search by term */
      if (term && !_.isEmpty(term)) {
        findQuery["$or"].push(
          {
            title: {
              $regex: ".*" + term + ".*",
            },
          },
          {
            summaryTitle: {
              $regex: ".*" + term + ".*",
            },
          }
        );
      }
      /** search by catId */
      if (req.user.specialPermissions.length) {
        findQuery.catId = { $in: req.user.specialPermissions };
      } else if (catId && !_.isEmpty(catId)) {
        findQuery["$and"].push({
          catId,
        });
      }
      /** search by showInHome */
      if (!_.isUndefined(showInHome) && _.isBoolean(showInHome)) {
        findQuery["$and"].push({
          showInHome,
        });
      }
      /** search by publish */
      if (!_.isUndefined(publish) && _.isBoolean(publish)) {
        findQuery["$and"].push({
          publish,
        });
      }
      /** search by portals */
      if (req.user.portals.length) {
        findQuery.modelType = {
          $in: req.user.portals,
        };
      } else if (portals && !_.isEmpty(portals)) {
        findQuery["$and"].push({
          modelType: {
            $in: portals,
          },
        });
      }
      /** search by status */
      if (!_.isUndefined(status) && _.isBoolean(status)) {
        findQuery["$and"].push({
          newsStatus: status,
        });
      }
      /** search by notifications */
      if (!_.isUndefined(notifications) && _.isBoolean(notifications)) {
        findQuery["$and"].push({
          notifications,
        });
      }
      /** search by special */
      if (!_.isUndefined(special) && _.isBoolean(special)) {
        findQuery["$and"].push({
          special,
        });
      }

      /** search by special */
      if (newsFile && !_.isEmpty(newsFile)) {
        findQuery["$and"].push({
          newsFileId: newsFile,
        });
      }

      /** search by date */
      if (date && !_.isEmpty(date)) {
        if (date.length === 1) {
          findQuery["$and"].push({
            customDate: {
              $gte: moment(date[0]).startOf("days"),
              $lt: moment(date[0]).endOf("days"),
            },
          });
        } else {
          findQuery["$and"].push({
            customDate: {
              $gte: new Date(date[0]),
              $lt: new Date(date[1]),
            },
          });
        }
      }

      _.isEmpty(findQuery["$and"]) && delete findQuery["$and"];
      _.isEmpty(findQuery["$or"]) && delete findQuery["$or"];

      /** get news */
      const news = await News.paginate(findQuery, {
        page: req.query.page,
        limit,
        populate: [
          {
            path: "_creator",
            select: {
              firstName: 1,
              lastName: 1,
              profilePic: 1,
            },
          },
          {
            path: "catId",
          },
        ],
        sort: {
          customDate: -1,
        },
      });

      /** show result */
      return res.json(news);
    } catch (error) {
      return res500(res, error?.message);
    }
  },
];

module.exports.searchForSlider = [
  async (req, res) => {
    try {
      var findQuery = { publish: true, newsStatus: true };
      findQuery["$and"] = [];
      findQuery["$or"] = [];

      let term = req.params.title;

      /** search by term */
      if (term && !_.isEmpty(term)) {
        findQuery["$or"].push({
          title: {
            $regex: ".*" + term + ".*",
          },
        });
      }

      _.isEmpty(findQuery["$and"]) && delete findQuery["$and"];
      _.isEmpty(findQuery["$or"]) && delete findQuery["$or"];

      /** get news */
      var news = await News.find(findQuery);

      /** show result */
      return res.json(news);
    } catch (error) {
      return res500(res, error?.message);
    }
  },
];

//////////// add attachment file to category
module.exports.addAttachmentToNews = [
  [body("attTitle").notEmpty().withMessage(_sr["fa"].required.title)],
  checkValidations(validationResult),
  (req, res) => {
    if (!req.files?.file)
      return res
        .status(422)
        .json({ validation: { file: { msg: _sr["fa"].required.file } } });
    if (req.files?.file.mimetype.split("/")[1] !== "pdf")
      return res
        .status(422)
        .json({ validation: { file: { msg: "فقط فرمت PDF قابل قبول است" } } });

    const data = { title: req.body.attTitle };
    const file = req.files.file;
    const fileName =
      req.body.attTitle.replace(titleFilterRegex, "-") +
      "_" +
      Date.now() +
      ".pdf";
    file.mv(`./static/uploads/files/newsAttachments/${fileName}`);
    data.file = fileName;

    News.findById(req.params.newsId, (err, news) => {
      if (err || !news) return res404(res, err);
      news.attachments.push(data);
      news.save((err) => {
        if (err) return res500(res, err);
        else return res.json({ message: _sr["fa"].response.success_save });
      });
    });
  },
];

module.exports.removeAttachmentFromNews = [
  (req, res) => {
    News.findOne({ "attachments._id": req.params.fileId }, (err, news) => {
      if (err || !news) return res404(res, err);
      const file = news.attachments.id(req.params.fileId);
      if (!file) return res404(res, "not found");
      file.remove();
      fs.unlink(`./static/${file.file}`, (err) => {
        if (err) console.log(err);
      });
      news.save((err) => {
        if (err) return res500(res, err);
        else return res.json({ message: _sr["fa"].response.success_remove });
      });
    });
  },
];

/////////////////////////////////////////////////////////////////////// public

module.exports.EDITNEWS = [async (req, res) => {}];
module.exports.viewNews = [
  async (req, res) => {
    try {
      var newsTitle = req.params.title;

      var targetNews = await News.findOne({
        _id: newsTitle,
        newsStatus: true,
        publish: true,
      })
        .populate("_creator", {
          firstName: 1,
          lastName: 1,
          profilePic: 1,
        })
        .populate({
          path: "catId",
          select: "title",
        });

      if (!targetNews) {
        return res404(res, `خبر مورد نطر پیدا نشد`);
      }

      ++targetNews.userViews;

      await targetNews.save();

      /** get comments */
      var comments = await Comment.find({
        modelRef: targetNews._id,
        allowShow: true,
      });

      var result = {
        news: targetNews,
        comments,
      };

      return res.json(result);
    } catch (error) {
      return res500(res, error?.message);
    }
  },
];

module.exports.FilterNews = [
  async (req, res) => {
    const length = parseInt(req.params.length);
    const views = parseInt(req.params.userViews);

    try {
      const news = await News.find().sort({ date: -1 }).limit(length);
      const filteredNews = await News.find({
        userViews: { $gte: views },
      }).sort({ date: -1 });

      res.json({ filteredNews, news });
    } catch (error) {
      res.status(500).json({ message: error.message });
    }
  },
];

module.exports.OstandarNews = [
  async (req, res) => {
    try {
      const news = await News.find({ modelType: "ostandari" });
      res.status(200).json(news);
    } catch (e) {
      return res.status(500).json(e.message);
    }
  },
];

module.exports.getNewsByCategory = [
  async (req, res) => {
    try {
      const catTitle = req.params.title;

      const page = req.query.page;

      /** check category */
      const targetCategory = await Category.findOne({
        title: catTitle,
      });

      if (!targetCategory) {
        return res404(res, `دسته بندی مورد نظر پیدا نشد`);
      }

      const requests = [
        // priority news
        News.findOne({
          catId: targetCategory._id,
          publish: true,
          newsStatus: true,
          priority: true,
        }),
        // news
        News.paginate(
          {
            catId: targetCategory._id,
            publish: true,
            newsStatus: true,
            priority: false,
          },
          {
            page: page || 1,
            limit: newsPerPageLimit,
            sort: { customDate: -1 },
          }
        ),
        //news file
        NewsFile.find({ catId: targetCategory._id, publish: true }),
        // special
        News.find({
          catId: targetCategory._id,
          publish: true,
          newsStatus: true,
          special: true,
        }).sort({ customDate: -1 }),
        // events
        News.find({
          catId: targetCategory._id,
          publish: true,
          newsStatus: true,
          notifications: true,
        }).sort({ customDate: -1 }),
        //polls
        Polls.find({
          catId: targetCategory._id,
          publish: true,
          startDate: { $lte: new Date() },
          endDate: { $gte: new Date() },
        }),
        // latestNews
        News.find({
          publish: true,
          newsStatus: true,
        })
          .sort({ _id: -1 })
          .limit(8),
      ];

      const fetch = await Promise.all(requests);

      const [heroNews, news, newsFile, specials, events, polls, latestNews] =
        fetch;

      const result = {
        category: targetCategory,
        heroNews,
        news,
        newsFile,
        specials,
        events,
        polls,
        latestNews,
      };

      return res.json(result);
    } catch (error) {
      return res500(res, error?.message);
    }
  },
];

module.exports.getAllNews = [
  async (req, res) => {
    try {
      let { flag, catId, portal, limit, page } = req.query;

      var findQuery = {};

      var setLimit = parseInt(limit) || 10;
      var setSort = {};

      findQuery.modelType = portal;
      findQuery.newsStatus = true;
      findQuery.publish = true;

      switch (flag) {
        case "category":
          setLimit = 20;
          setSort.customDate = -1;
          findQuery.rootParent = catId;
          break;
        case "all":
          setLimit = 20;
          setSort.customDate = -1;
          break;
        case "new":
          setSort.customDate = -1;
          setLimit = 5;
          break;
        case "slider":
          findQuery.slider = true;
          setSort.customDate = -1;
          setLimit = 3;
          break;
        case "special":
          findQuery.special = true;
          setSort.customDate = -1;
          setLimit = 4;
          break;
        case "random":
          var result = await randomNews(findQuery);
          return res.json(result);
        case "popular":
          setSort.userViews = -1;
          setSort.customDate = -1;
          setLimit = 5;
          break;
        case "events":
          findQuery.notifications = true;
          findQuery.showInHome = true;
          setSort.customDate = -1;
          setLimit = 5;
          break;
        default:
          return res.json([]);
      }

      var getNews = await News.paginate(findQuery, {
        page: page || 1,
        limit: setLimit,
        sort: setSort,
      });

      return res.json(getNews);
    } catch (error) {
      return res500(res, error?.message);
    }
  },
];

module.exports.getSections = [
  async (req, res) => {
    try {
      const portal = req.query.portal;

      let result = {};

      result.sectionOne = [];
      result.sectionTwo = [];
      result.sectionThree = [];

      let getSectionsTitle = await Category.find({
        $or: [
          { showInSectionOne: true },
          { showInSectionTwo: true },
          { showInSectionThree: true },
        ],
        modelType: portal,
      });

      for (const item of getSectionsTitle) {
        let section = {};
        let news = await News.find({
          catId: item._id,
          showInHome: true,
          publish: true,
          modelType: portal,
        })
          .limit(limit)
          .sort({ _id: -1 });

        section.nameTag = item.title;
        section.data = news;

        if (item.showInSectionOne) {
          result.sectionOne = section;
        }

        if (item.showInSectionTwo) {
          result.sectionTwo = section;
        }

        if (item.showInSectionThree) {
          result.sectionThree.push(section);
        }
      }

      // let findQuery = {};

      // let setLimit = parseInt(limit) || 10;
      // let setSort = {};
      // let setSkip = parseInt(skip) || 0;

      // findQuery.modelType = portal;
      // findQuery.newsStatus = true;
      // findQuery.publish = true;

      return res.json(result);
    } catch (error) {
      return res500(res, error?.message);
    }
  },
];

/** @todo mabe change it in future */
module.exports.getRelated = [
  async (req, res) => {
    try {
      const { portal, title } = req.query;

      let getNews = {};

      let findQuery = {};

      findQuery.modelType = portal;
      findQuery._id = {
        $ne: title,
      };
      findQuery.newsStatus = true;
      findQuery.publish = true;

      const targetNews = await News.findById(title);

      if (targetNews) {
        findQuery.catId = targetNews.catId;
        getNews = await randomNews(findQuery);
      }

      return res.json(getNews);
    } catch (error) {
      return res500(res, error?.message);
    }
  },
];