import { randomUUID } from "node:crypto";

import { ChannelType, type TextChannel } from "discord.js";
import { Subcommand } from "@sapphire/plugin-subcommands";
import { ApplyOptions } from "@sapphire/decorators";
import { container, Result } from "@sapphire/framework";

import db, { eq, tickets, upsertUser } from "@stealth-developers/db";
import config from "@stealth-developers/config";
import { getCategory, PublicError } from "@/lib";

@ApplyOptions<Subcommand.Options>({
	description: "ticket-related commands",
})
export class TicketCommand extends Subcommand {
	public constructor(context: Subcommand.LoaderContext, options: Subcommand.Options) {
		super(context, {
			...options,
			name: "ticket",
			subcommands: [
				{ name: "new", chatInputRun: "createTicket" },
				{ name: "for", chatInputRun: "createTicketFor" },
				{
					name: "actions",
					type: "group",
					entries: [
						{ name: "open", chatInputRun: "openTicket" },
						{ name: "close", chatInputRun: "closeTicket" },
						{ name: "add", chatInputRun: "addToTicket" },
						{ name: "claim", chatInputRun: "claimTicket" },
						{ name: "unclaim", chatInputRun: "unclaimTicket" },
						{ name: "delete", chatInputRun: "deleteTicket" },
					],
				},
				{
					name: "view",
					type: "group",
					entries: [
						{ name: "info", chatInputRun: "viewTicketInfo" },
						{ name: "transcript", chatInputRun: "viewTicketTranscript" },
						{ name: "list", chatInputRun: "listTickets" },
						{ name: "export", chatInputRun: "exportTickets" },
					],
				},
			],
		});
	}

	public override registerApplicationCommands(registry: Subcommand.Registry) {
		registry.registerChatInputCommand((builder) =>
			builder
				.setName("ticket")
				.setDescription("root ticket command")
				.addSubcommand((command) => command.setName("new").setDescription("Open a new ticket"))
				.addSubcommandGroup((group) =>
					group
						.setName("action")
						.setDescription("ticket actions")
						.addSubcommand((command) =>
							command.setName("open").setDescription("Reopen the ticket in the current channel"),
						)
						.addSubcommand((command) =>
							command
								.setName("close")
								.setDescription("Close the ticket in the current channel")
								.addStringOption((option) =>
									option
										.setName("reason")
										.setDescription("Public reason for closing the ticket")
										.setRequired(true),
								)
								.addStringOption((option) =>
									option
										.setName("private")
										.setDescription(
											"Private reason for closing the ticket, only visible to moderators",
										)
										.setRequired(false),
								)
								.addBooleanOption((option) =>
									option.setName("delete-channel").setDescription("Delete the channel immediately"),
								),
						),
				),
		);
	}

	public async createTicket(interaction: Subcommand.ChatInputCommandInteraction) {
		const publicId = randomUUID();

		const userResult = await Result.fromAsync(() =>
			upsertUser({
				id: interaction.user.id,
				avatar: interaction.member?.avatar || interaction.user.avatar,
				username: interaction.user.username,
				displayName: interaction.user.displayName,
			}),
		);

		if (userResult.isErr()) {
			const err = userResult.unwrapErr();
			const message = err instanceof Error ? err.message : String(err);
			return interaction.reply({
				content: `Failed to create ticket: ${message}`,
				flags: ["Ephemeral"],
			});
		}

		const user = userResult.unwrap();
		if (!user) {
			return interaction.reply({
				content: "Failed to create ticket: User not found",
				flags: ["Ephemeral"],
			});
		}

		const catResult = await Result.fromAsync(() =>
			getCategory(config.discord.server.ticket_category),
		);
		if (catResult.isErr()) {
			const err = catResult.unwrapErr();
			const message = err instanceof Error ? err.message : String(err);
			return interaction.reply({
				content: `Failed to create ticket: ${message}`,
				flags: ["Ephemeral"],
			});
		}

		const ticketCategory = catResult.unwrap();
		let createdChannel: TextChannel | undefined = undefined;

		const txResult = await Result.fromAsync(async () => {
			return await db.transaction(async (tx) => {
				const [ticket] = await tx
					.insert(tickets)
					.values({
						anonymousId: publicId,
						status: "open",
						openedAt: new Date(),
						openedBy: user.id,
						subject: user.id,
					})
					.returning();

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

				const ticketNumber = ticket.id;
				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) this.container.logger.error(error.message, error.stack);

			return interaction.reply({
				content: message,
				flags: ["Ephemeral"],
			});
		}

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

	public async openTicket(interaction: Subcommand.ChatInputCommandInteraction) {
		interaction.reply({ content: "Ticket opened!" });
	}

	public async closeTicket(interaction: Subcommand.ChatInputCommandInteraction) {
		interaction.reply({ content: "Ticket closed!" });
	}
}

container.stores.loadPiece({
	piece: TicketCommand,
	name: "ticket",
	store: "commands",
});