/* eslint-disable @typescript-eslint/no-unnecessary-condition */
import isEmpty from "just-is-empty";
import random from "just-random";
import get from "just-safe-get";
import type { Post } from "../../classes/post";
import type { Repost } from "../../classes/repost";
import { TaskType } from "../../enums";
import type { AllContext } from "../../types";
import { isInDev } from "../helpers";

// picks a random queue to publish data to
const getRandomQueue = (env: Env, listName: string): Queue | null => {
  const queueListNames: string[] = get(env.QUEUE_SETTINGS, listName, []);
  if (isEmpty(queueListNames))
    return null;

  const queueName: string = random(queueListNames) ?? "";
  if (queueListNames.length > 1)
    console.log(`Picked ${queueName} from ${listName}`);
  return get(env, queueName, null) as Queue|null;
};

async function pushToQueue(queueConsumer: Queue | null, data: Post | Repost | null, taskType: TaskType, delay: number = -1) {
  if (queueConsumer !== null) {
    const options: QueueSendOptions = { contentType: 'v8' };
    if (delay > -1)
      options.delaySeconds = delay;

    await queueConsumer.send({ type: taskType, data: data }, options);
  } else {
    console.warn(`could not push data to empty queue, was type ${taskType}`);
  }
}

const hasPostQueue = (env: Env) => !isEmpty(env.QUEUE_SETTINGS.post_queues) && !isInDev(env);
const hasRepostQueue = (env: Env) => !isEmpty(env.QUEUE_SETTINGS.repost_queues) && !isInDev(env);
export const isQueueEnabled = (env: Env) => env.QUEUE_SETTINGS.enabled && hasPostQueue(env);
export const isRepostQueueEnabled = (env: Env) => env.QUEUE_SETTINGS.enabled && hasRepostQueue(env);
export const shouldPostNowQueue = (env: Env) => env.QUEUE_SETTINGS.postNowEnabled && isQueueEnabled(env);

export async function enqueuePost(c: AllContext, data: Post, delay: number = -1) {
  if (!isQueueEnabled(c.env))
    return;

  const postType = TaskType.Post,
    postQueue = "post_queues";
  // Pick a random consumer to handle this post
  const queueConsumer: Queue | null = getRandomQueue(c.env, postQueue);
  await pushToQueue(queueConsumer, data, postType, delay);
}

export async function enqueueRepost(c: AllContext, data: Repost, delay: number = -1) {
  if (!isRepostQueueEnabled(c.env))
    return;

  // Pick a random consumer to handle this repost
  const queueConsumer: Queue | null = getRandomQueue(c.env, "repost_queues");
  await pushToQueue(queueConsumer, data, TaskType.Repost, delay);
}

export async function enqueueEmptyWork(c: AllContext, queueType: TaskType, delay: number = -1) {
  const queueConsumer: Queue | null = getRandomQueue(c.env, queueType === TaskType.Post ? "post_queues" : "repost_queues");
  await pushToQueue(queueConsumer, null, TaskType.Blast, delay);
}