import {
  getAllFeeds,
  deleteFeedByLink,
  createPost,
  getPostByPostId,
} from "../modules/mongo-wrappers/mongoFeedsWrappers.mjs";
import crypto from "crypto";
import { sendPost } from "../discordBot/modules/rssWrappers.mjs";
import { DebugBuilder } from "../modules/debugger.mjs";
import { removeSource } from "./sourceManager.mjs";
import UserAgent from "user-agents";
import Parser from "rss-parser";

import dotenv from "dotenv";
dotenv.config();

// Initialize the User-Agent string
process.env.USER_AGENT_STRING = new UserAgent({ platform: "Win32" }).toString();

const parser = new Parser({
  headers: {
    "User-Agent": process.env.USER_AGENT_STRING,
    Accept: "application/rss+xml,application/xhtml+xml,application/xml",
  },
});

const log = new DebugBuilder("server", "feedHandler");

export const returnHash = (...stringsIncluded) => {
  return crypto
    .createHash("sha1")
    .update(stringsIncluded.join("-<<??//\\\\??>>-"))
    .digest("base64");
};

/**
 * Update the active RSS feeds and send any new posts to their discord channels
 * @param {any} client The discord client to send posts with
 * @returns {any}
 */
export const updateFeeds = async (client) => {
  if (!client) throw new Error("Client object not passed");

  try {
    const records = await getAllFeeds();

    const sourcePromiseArray = records.map(async (source) => {
      log.DEBUG("Processing source:", source.title);

      try {
        const parsedFeed = await parser.parseURL(source.link);

        if (parsedFeed?.items) {
          await Promise.all(
            parsedFeed.items.reverse().map(async (post) => {
              log.DEBUG("Processing post:", post.title);

              if (!post.title || !post.link)
                throw new Error("Missing title or link in the post");
              if (!post.content && !post["content:encoded"])
                log.WARN("No content for post:", post.title);

              post.postId =
                post.postId ??
                post.guid ??
                post.id ??
                returnHash(post.title, post.link, post.pubDate ?? Date.now());

              const existingRecord = await getPostByPostId(post.postId);
              if (!existingRecord) {
                const channel = client.channels.cache.get(source.channel_id);
                const sendResults = await sendPost(post, source, channel);
                if (!sendResults) throw new Error("Failed to send post");

                log.DEBUG(
                  "Saving post to database:",
                  post.title,
                  source.channel_id,
                );

                const postToSave = {
                  title: post.title,
                  link: post.link,
                  pubDate: post.pubDate,
                  author: post.author,
                  contentSnippet: post.contentSnippet,
                  id: post.id,
                  isoDate: post.isoDate,
                  postId: post.postId,
                };

                await createPost(postToSave);
                log.DEBUG("Post saved:", postToSave);
              }
            }),
          );
        } else {
          await deleteFeedByLink(source.link);
        }
      } catch (err) {
        log.ERROR("Error processing source:", source.title, err);
        await removeSource(source.link);
        throw err;
      }
    });

    await Promise.all(sourcePromiseArray);
    log.DEBUG("All sources processed");
  } catch (error) {
    log.ERROR("Error updating feeds:", error);
    throw error;
  }
};