import { randomUUID } from "node:crypto";
import { TextChannel, ChannelType } from "discord.js";
import { container, Result } from "@sapphire/framework";
import type { Subcommand } from "@sapphire/plugin-subcommands";

import db, { desc, eq, tickets } from "@stealth-developers/db";
import config from "@stealth-developers/config";

export * from "./config";

import { errorMessage, upsertUser, getCategory, PublicError } from "@/lib";

export async function createTicket(interaction: Subcommand.ChatInputCommandInteraction) {
	if (!interaction.guild)
		return errorMessage(interaction, "Failed to create ticket: Guild not found");

	const isOnBehalf = interaction.options.getSubcommand(true) === "for";
	const publicId = randomUUID();

	if (!interaction.member)
		return errorMessage(interaction, "Failed to create ticket: Member not found");

	const creator = await upsertUser(interaction.member, interaction.guild);
	if (!creator) return errorMessage(interaction, "Failed to create ticket: Creator not found");

	const subject = isOnBehalf ? interaction.options.getUser("user") : interaction.user;
	const subjectUser = subject ? await upsertUser(subject, interaction.guild!) : creator;
	if (!subjectUser)
		return errorMessage(interaction, "Failed to create ticket: Subject user not found");

	if (isOnBehalf && !creator.moderator)
		return errorMessage(
			interaction,
			"You don't have permission to create a ticket for another user.",
		);

	const ticketCategory = await getCategory(config.discord.server.ticket_category);
	let createdChannel: TextChannel | undefined = undefined;

	const txResult = await Result.fromAsync(async () => {
		return await db.transaction(async (tx) => {
			const [maxTicket] = await tx
				.select({ localId: tickets.localId })
				.from(tickets)
				.where(eq(tickets.guildId, creator.guildId))
				.orderBy(desc(tickets.localId))
				.limit(1);

			const localId = (maxTicket?.localId ?? 0) + 1;

			const [ticket] = await tx
				.insert(tickets)
				.values({
					id: publicId,
					guildId: creator.guildId,
					localId: localId,
					status: "open",
					openedAt: new Date(),
					openedBy: creator.id,
					subject: subjectUser.id,
				})
				.returning();

			if (!ticket) throw new PublicError("failed to add ticket to database.");

			const ticketNumber = ticket.localId;
			const paddedTicketNumber = String(ticketNumber).padStart(4, "0");

			const channel = await interaction.guild?.channels.create({
				name: `ticket-${paddedTicketNumber}`,
				type: ChannelType.GuildText,
				parent: ticketCategory,
			});

			if (!channel) throw new PublicError("failed to create Discord channel.");
			createdChannel = channel;

			await tx.update(tickets).set({ channelId: channel.id }).where(eq(tickets.id, ticket.id));
			await channel.send({ content: `Hi! Thanks for submitting a report.` });

			return channel.id;
		});
	});

	if (txResult.isErr()) {
		if (createdChannel) await Result.fromAsync(() => createdChannel?.delete());

		const error = txResult.unwrapErr();
		const message =
			error instanceof PublicError
				? `Failed to create ticket: ${error.message}`
				: "There was an error creating the ticket.";

		if (error instanceof Error) container.logger.error(error.message, error.stack);

		return errorMessage(interaction, message);
	}

	const channelId = txResult.unwrap();
	interaction.reply({
		content: `Ticket created! See <#${channelId}>`,
		flags: ["Ephemeral"],
	});
}