import config from "@/config";
import { bugs, db } from "@/database";
import { getGuild } from "@/utils/queries";
import type { ButtonInteraction, Client, GuildMember } from "discord.js";
import { eq } from "drizzle-orm";
import { buildReportModal, updateBugEmbed } from "./_shared";
import { hasManagerPermissions } from "@/utils/permissions";

async function fetchBugById(id: string) {
	const parsedId = Number(id);
	if (Number.isNaN(parsedId)) return null;
	const results = await db.select().from(bugs).where(eq(bugs.id, parsedId));
	return results[0] ?? null;
}

export async function handleCloseButton(
	client: Client,
	interaction: ButtonInteraction,
) {
	if (!interaction.guildId) return;

	const [, , id] = interaction.customId.split(":");
	const bug = await fetchBugById(id);
	if (!bug) {
		await interaction.reply({
			content: "❌ Bug not found.",
			flags: ["Ephemeral"],
		});
		return;
	}

	await db
		.update(bugs)
		.set({ status: "closed", closedAt: new Date(), updatedAt: new Date() })
		.where(eq(bugs.id, bug.id));
	const { data, exists } = await getGuild(interaction.guildId);

	if (!exists) {
		await interaction.reply({
			content: "❌ Guild configuration not found.",
			flags: ["Ephemeral"],
		});
		return;
	}

	const channelId = data.bug_channel_id;
	if (!channelId) {
		await interaction.reply({
			content: "❌ Bug channel not configured.",
			flags: ["Ephemeral"],
		});
		return;
	}

	if (bug.messageId) {
		await updateBugEmbed(
			client,
			{ ...bug, status: "closed" },
			bug.messageId,
			channelId,
		);
	}

	await interaction.reply({
		content: `✅ Bug #${bug.bugNumber.toString().padStart(4, "0")} closed.`,
		flags: ["Ephemeral"],
	});
}

export async function handleOpenButton(
	client: Client,
	interaction: ButtonInteraction,
) {
	if (!interaction.guildId) return;

	const [, , id] = interaction.customId.split(":");
	const bug = await fetchBugById(id);

	if (!bug) {
		await interaction.reply({
			content: "❌ Bug not found.",
			flags: ["Ephemeral"],
		});
		return;
	}

	await db
		.update(bugs)
		.set({ status: "open", closedAt: null, updatedAt: new Date() })
		.where(eq(bugs.id, bug.id));
	const { data, exists } = await getGuild(interaction.guildId);

	if (!exists) {
		await interaction.reply({
			content: "❌ Guild configuration not found.",
			flags: ["Ephemeral"],
		});
		return;
	}

	const channelId = data.bug_channel_id;
	if (!channelId) {
		await interaction.reply({
			content: "❌ Bug channel not configured.",
			flags: ["Ephemeral"],
		});
		return;
	}

	if (bug.messageId) {
		await updateBugEmbed(
			client,
			{ ...bug, status: "open" },
			bug.messageId,
			channelId,
		);
	}

	await interaction.reply({
		content: `✅ Bug #${bug.bugNumber.toString().padStart(4, "0")} reopened.`,
		flags: ["Ephemeral"],
	});
}

export async function handleEditButton(
	_client: Client,
	interaction: ButtonInteraction,
) {
	const [, , id] = interaction.customId.split(":");
	const bug = await fetchBugById(id);

	if (!bug) {
		await interaction.reply({
			content: "❌ Bug not found.",
			flags: ["Ephemeral"],
		});
		return;
	}

	const modal = buildReportModal(String(bug.id), bug);
	await interaction.showModal(modal);
}

export async function handleDeleteButton(
	_client: Client,
	interaction: ButtonInteraction,
) {
	if (!interaction.guildId) return;

	const [, , id] = interaction.customId.split(":");
	const bug = await fetchBugById(id);
	if (!bug) {
		await interaction.reply({
			content: "❌ Bug not found.",
			flags: ["Ephemeral"],
		});
		return;
  }

  const isManager = await hasManagerPermissions(interaction.member as GuildMember)
  const isBugReporter = bug.authorId === interaction.user.id

  if (!isManager && !isBugReporter) {
    await interaction.reply({
      content: "❌ You don't have permission to delete this bug.",
      flags: ["Ephemeral"],
    });
    return;
  }

	await db.delete(bugs).where(eq(bugs.id, bug.id));
	const { data, exists } = await getGuild(interaction.guildId);
	if (!exists) {
		await interaction.reply({
			content: "❌ Guild configuration not found, bug removed from database.",
			flags: ["Ephemeral"],
		});
		return;
	}
	const channelId = data.bug_channel_id;
	if (!channelId) {
		await interaction.reply({
			content:
				"✅ Bug removed from database. (No bug channel configured to remove message/thread)",
			flags: ["Ephemeral"],
		});
		return;
	}

	try {
		const channel = await interaction.guild?.channels.fetch(channelId);
		if (channel?.isTextBased() && bug.messageId) {
			const { message } = interaction;
			const { thread } = message;

			if (message) {
				if (thread)
					await thread
						.delete(`bug ${bug.bugNumber} deleted by <@${interaction.user.id}>`)
						.catch(() => {});

				await message.delete().catch(() => {});
			}
		}
	} catch (err) {}

	await interaction.reply({
		content: `✅ Bug #${bug.bugNumber.toString().padStart(4, "0")} deleted.`,
		flags: ["Ephemeral"],
	});
}

export async function handleTrelloButton(
	_client: Client,
	interaction: ButtonInteraction,
) {
	const [, , id] = interaction.customId.split(":");
	const bug = await fetchBugById(id);
	if (!bug) {
		await interaction.reply({
			content: "❌ Bug not found.",
			flags: ["Ephemeral"],
		});
		return;
	}

	const params = new URLSearchParams({
		name: bug.title,
		url: interaction.message.url,
		idBoard: config.trelloBoardId || "",
	});

	const url = new URL("https://trello.com/addCard");
	url.search = params.toString();

	await interaction.reply({
		content: url.toString(),
		flags: ["Ephemeral"],
	});
}