import { option } from "@purrkit/router";
import { Result } from "@sapphire/result";
import { ButtonBuilder, ContainerBuilder, TextDisplayBuilder, ActionRowBuilder } from "discord.js";
import {
	addTicketComment,
	getTicketByChannelId,
	getTicketByGuild,
	getTicketByUser,
} from "@stealth-developers/db";

import { errorMessage, getTextChannel, logger, PublicError } from "@/lib";
import { TicketButtonPresets } from "./buttons";
import * as actions from "./actions";
import { manageConfig } from "./config";
import { getBasicData } from "@/middleware";
import { hasAccessToTicket } from "@/lib/tickets";
import { TicketModalPresets } from "./modals";
import { ChannelType } from "discord-api-types/v9";

const ticketCommand = getBasicData.command("ticket", {
	description: "Ticket-related commands",
});

ticketCommand.subcommand("new", {
	description: "Open a new ticket.",
	async run(interaction) {
		if (!interaction.guild)
			return errorMessage(interaction, "You must run this command in a guild");

		const func = actions.createTicket(interaction.member ?? interaction.user, interaction.guild);

		const ticketResult = await Result.fromAsync(async () => func);
		if (ticketResult.isErr()) {
			const error = ticketResult.unwrapErr();

			if (error instanceof PublicError) {
				return errorMessage(interaction, error.message);
			} else {
				console.error(error);
				return errorMessage(interaction, "An unexpected error occurred while creating the ticket.");
			}
		}

		const { channelId } = ticketResult.unwrap();
		return interaction.reply({
			content: `Opened ticket <#${channelId}>.`,
			flags: ["Ephemeral"],
		});
	},
});

ticketCommand.subcommand("for", {
	description: "Open a new ticket on behalf of someone else",
	options: {
		user: option.user("The user to open the ticket for", { required: true }),
		reason: option.string("The reason for opening the ticket"),
	},
	async run(interaction, args) {
		if (!interaction.guild)
			return errorMessage(interaction, "You must run this command in a guild");

		const func = actions.createTicket(interaction.member ?? interaction.user, interaction.guild, {
			for: args.user,
			reason: args.reason,
		});

		const ticketResult = await Result.fromAsync(async () => func);
		if (ticketResult.isErr()) {
			const error = ticketResult.unwrapErr();

			if (error instanceof PublicError) {
				return errorMessage(interaction, error.message);
			} else {
				logger.error(error);
				return errorMessage(interaction, "An unexpected error occurred while creating the ticket.");
			}
		}

		const { channelId } = ticketResult.unwrap();
		return interaction.reply({
			content: `Opened ticket <#${channelId}>.`,
			flags: ["Ephemeral"],
		});
	},
});

ticketCommand.subcommand("view", {
	description: "View a ticket",
	options: {
		id: option.string("The ticket's ID", { required: true }),
	},
	async run(interaction, args, { guild, actor, user }) {
		if (guild && actor) {
			const ticket = await getTicketByGuild(guild.id, Number(args.id));
			if (!ticket) return errorMessage(interaction, `Ticket with ID ${args.id} not found.`);

			if (!hasAccessToTicket(actor, guild, ticket)) return;

			const container = actions.getTicketContainer(ticket, !actor.moderator);
			await interaction.reply({ components: [container], flags: ["Ephemeral", "IsComponentsV2"] });
			return;
		}

		if (user) {
			const ticket = await getTicketByUser(user.id, Number(args.id));
			if (!ticket) return errorMessage(interaction, `Ticket with ID ${args.id} not found.`);

			const container = actions.getTicketContainer(ticket, false);
			await interaction.reply({ components: [container], flags: ["Ephemeral", "IsComponentsV2"] });
			return;
		}

		await errorMessage(interaction, "We couldn't find a ticket with that ID.");
	},
});

ticketCommand.group(
	"actions",
	{
		description: "Perform ticket actions",
	},
	(group) => {
		group.subcommand("close", {
			description: "Close the ticket",
			async run(interaction) {
				if (!interaction.guild)
					return errorMessage(interaction, "This command can only be used in a server.");

				const modal = await actions.triggerCloseTicket(
					interaction.user,
					interaction.guild,
					interaction.channelId,
				);

				await interaction.showModal(modal);
			},
		});

		// TODO)) claim
		// TODO)) unclaim
		// TODO)) reopen

		group.subcommand("comment", {
			description: "Add a comment to the ticket",
			options: {
				id: option.number("The ID of the ticket", { required: false }),
				comment: option.string("The comment to add", { required: false }),
			},
			async run(interaction, { id, comment }, { actor, guild }) {
				if (!interaction.guild || !guild || !actor)
					return errorMessage(interaction, "This command can only be used in a server.");

				if (!actor.moderator)
					return errorMessage(interaction, "You do not have permission to use this command.");

				let ticketId = id;
				if (!id && !interaction.channel)
					errorMessage(interaction, "Either provide an ID or run this in a ticket.");

				if (!id && interaction.channel) {
					if (interaction.channel.type !== ChannelType.GuildText)
						return errorMessage(interaction, "Either provide an ID or run this in a ticket.");

					const name = interaction.channel.name;
					const segments = name.split("-");
					ticketId = parseInt(segments[segments.length - 1]!);
				}

				if (!ticketId) return errorMessage(interaction, "Ticket not found.");

				const ticket = await getTicketByGuild(guild.id, ticketId);
				if (!ticket) return errorMessage(interaction, "Ticket not found.");

				if (comment) {
					await addTicketComment({
						actorId: actor.id,
						content: comment,
						ticketId: ticket.id,
					});

					await interaction.reply({
						content: `Comment added to ticket ${ticket.id}`,
						flags: ["Ephemeral"],
					});
					return;
				}

				await interaction.showModal(TicketModalPresets.comment(ticket.id));
			},
		});

		// TODO)) edit
		// TODO)) clean
	},
);

ticketCommand.group(
	"manage",
	{
		description: "Manage ticket settings",
	},
	(group) => {
		// channels & categories
		group.subcommand("transcript-channel", {
			description: "Set the channel where transcripts will be sent",
			options: {
				channel: option.channel("The channel to send transcripts to", { required: true }),
			},
			async run(interaction, _, { actor }) {
				if (!actor?.moderator)
					return errorMessage(interaction, "You must be a moderator to run this command");
				await manageConfig(interaction);
			},
		});

		group.subcommand("entrypoint-channel", {
			description: "Set the channel where the ticket prompt will be sent",
			options: {
				channel: option.channel("The channel to send the ticket prompt to", { required: true }),
			},
			async run(interaction, _, { actor }) {
				if (!actor?.moderator)
					return errorMessage(interaction, "You must be a moderator to run this command");
				await manageConfig(interaction);
			},
		});

		group.subcommand("category", {
			description: "Sets the category for new tickets",
			options: {
				category: option.channel("The category to create new tickets in", { required: true }),
			},
			async run(interaction, _, { actor }) {
				if (!actor?.moderator)
					return errorMessage(interaction, "You must be a moderator to run this command");
				await manageConfig(interaction);
			},
		});

		// text
		group.subcommand("prompt", {
			description: "Set the message sent in the entry point channel",
			async run(interaction, _, { actor }) {
				if (!actor?.moderator)
					return errorMessage(interaction, "You must be a moderator to run this command");
				await manageConfig(interaction);
			},
		});

		group.subcommand("greeting", {
			description: "Set the message sent in new tickets",
			async run(interaction, _, { actor }) {
				if (!actor?.moderator)
					return errorMessage(interaction, "You must be a moderator to run this command");
				await manageConfig(interaction);
			},
		});

		// actions
		group.subcommand("send-prompt", {
			description: "Send the prompt to the entry point channel",
			async run(interaction, _, { guild, actor }) {
				if (!interaction.guild || !guild)
					return errorMessage(interaction, "You must run this command in a guild");

				if (!actor?.moderator)
					return errorMessage(interaction, "You must be a moderator to run this command");

				const commandString = (sub: string) => `</ticket manage ${sub}:${interaction.commandId}>`;
				const channelId = guild.ticketPromptChannel;
				const promptText = guild.ticketPrompt;

				if (!channelId)
					return errorMessage(
						interaction,
						`Prompt chnanel not configured. Use ${commandString("entrypoint-channel")} to set it up.`,
					);

				if (!promptText)
					return errorMessage(
						interaction,
						`Ticket prompt not configured. Use ${commandString("prompt")} to set it up.`,
					);

				const channelRes = await Result.fromAsync(() => getTextChannel(channelId));
				if (channelRes.isErr()) {
					const err = channelRes.unwrapErr();
					const errorMessageText = err instanceof Error ? err.message : "Unknown error";
					return errorMessage(interaction, `Failed to fetch prompt channel: ${errorMessageText}`);
				}

				const channel = channelRes.unwrap();
				if (!channel.isSendable()) {
					return errorMessage(
						interaction,
						"I don't have permission to send messages in the prompt channel.",
					);
				}

				const container = new ContainerBuilder()
					.addTextDisplayComponents(new TextDisplayBuilder().setContent(promptText))
					.addActionRowComponents(
						new ActionRowBuilder<ButtonBuilder>().addComponents(TicketButtonPresets.create()),
					);

				await channel.send({ flags: ["IsComponentsV2"], components: [container] });
				return interaction.reply({
					content: "Prompt sent!",
					flags: ["Ephemeral"],
				});
			},
		});
	},
);

export default ticketCommand;