import {
	Actor,
	Guild,
	Ticket,
	TicketAttachment,
	TicketComment,
	TicketMessage,
	TicketParticipant,
	TicketWithRelations,
	User,
} from "@stealth-developers/db";

export interface SanitiseOptions {
	isModerator: boolean;
	anonymiseStaff?: boolean;
}

//
export function sanitiseGuild(guild: Guild) {
	return {
		id: guild.id,
		discordId: guild.discordId,

		name: guild.name,
		icon: guild.icon,

		createdAt: guild.createdAt,
		updatedAt: guild.updatedAt,
	};
}

export function sanitiseGuilds(guilds: Guild[]) {
	return guilds.map(sanitiseGuild);
}

//
export function sanitiseUser(user: User) {
	return {
		id: user.id,
		discordId: user.discordId,

		username: user.username,
		displayName: user.displayName,

		createdAt: user.createdAt,
		updatedAt: user.updatedAt,
	};
}

export function sanitiseUsers(users: User[]) {
	return users.map(sanitiseUser);
}

//
export function sanitiseActor(actor: Actor) {
	return {
		actorId: actor.id,
		guildId: actor.guildId,
		userId: actor.userId,
		discordId: actor.discordId,

		username: actor.username,
		displayName: actor.displayName,
		avatar: actor.avatar,

		createdAt: actor.createdAt,
		updatedAt: actor.updatedAt,
	};
}

export function sanitiseActors(actors: Actor[]) {
	return actors.map(sanitiseActor);
}

//
export function sanitiseTicket(ticket: TicketWithRelations, options: SanitiseOptions) {
	const { isModerator, anonymiseStaff = false } = options;
	const shouldAnonymise = !isModerator && anonymiseStaff;

	return {
		id: ticket.id,
		guildId: ticket.guildId,
		localId: ticket.localId,

		status: ticket.status,
		channelId: ticket.channelId,
		threadId: ticket.threadId,

		closeReason: ticket.closeReason,
		privateReason: isModerator ? ticket.privateReason : null,

		openedAt: ticket.openedAt,
		closedAt: ticket.closedAt,
		closedBy: shouldAnonymise ? null : ticket.closedBy,

		lastSubjectActivityAt: ticket.lastSubjectActivityAt,
		lastClaimantActivityAt: isModerator ? ticket.lastClaimantActivityAt : null,

		openedBy: ticket.openedBy,
		openReason: ticket.openReason,
		subject: ticket.subject,

		claimedBy: shouldAnonymise ? null : ticket.claimedBy,
		claimedAt: shouldAnonymise ? null : ticket.claimedAt,

		thankedAt: ticket.thankedAt,
		warnedAt: ticket.warnedAt,
		lastMessageAt: ticket.lastMessageAt,

		hasModeratorMessage: ticket.hasModeratorMessage,
		hasAuthorMessage: ticket.hasAuthorMessage,
	};
}

//
export function sanitiseTicketMessage(message: TicketMessage, options: SanitiseOptions) {
	const { isModerator, anonymiseStaff = false } = options;
	if (message.isPrivate && !isModerator) return null;

	const shouldAnonymise = !isModerator && anonymiseStaff && message.actorRole === "moderator";

	return {
		id: message.id,
		messageId: message.messageId,
		ticketId: message.ticketId,

		actorId: shouldAnonymise ? null : message.actorId,
		actorRole: message.actorRole,

		isPrivate: message.isPrivate,
		content: message.content,

		embeds: message.embeds,
		components: message.components,

		createdAt: message.createdAt,
		editedAt: message.editedAt,
		deletedAt: message.deletedAt,
	};
}

export function sanitiseTicketMessages(messages: TicketMessage[], options: SanitiseOptions) {
	return messages
		.map((msg) => sanitiseTicketMessage(msg, options))
		.filter((msg): msg is NonNullable<ReturnType<typeof sanitiseTicketMessage>> => msg !== null);
}

//
export function sanitiseTicketParticipant(
	participant: TicketParticipant,
	options: SanitiseOptions,
) {
	const { isModerator, anonymiseStaff = false } = options;

	const isStaffParticipant = participant.role === "moderator";
	const shouldAnonymise = !isModerator && anonymiseStaff && isStaffParticipant;

	if (shouldAnonymise) return null;

	return {
		id: participant.id,
		ticketId: participant.ticketId,
		actorId: participant.actorId,
		role: participant.role,

		reason: isModerator ? participant.reason : null,
		createdAt: participant.createdAt,
	};
}

export function sanitiseTicketParticipants(
	participants: TicketParticipant[],
	options: SanitiseOptions,
) {
	return participants
		.map((p) => sanitiseTicketParticipant(p, options))
		.filter((p): p is NonNullable<ReturnType<typeof sanitiseTicketParticipant>> => p !== null);
}

//
export function sanitiseTicketComment(comment: TicketComment, options: SanitiseOptions) {
	const { isModerator } = options;

	if (!isModerator) return null;

	return {
		id: comment.id,
		ticketId: comment.ticketId,
		actorId: comment.actorId,
		content: comment.content,
		createdAt: comment.createdAt,
		updatedAt: comment.updatedAt,
	};
}

export function sanitiseTicketComments(comments: TicketComment[], options: SanitiseOptions) {
	return comments
		.map((c) => sanitiseTicketComment(c, options))
		.filter((c): c is NonNullable<ReturnType<typeof sanitiseTicketComment>> => c !== null);
}

//
export function sanitiseTicketAttachment(attachment: TicketAttachment, options: SanitiseOptions) {
	const { isModerator, anonymiseStaff = false } = options;

	const shouldAnonymise = !isModerator && anonymiseStaff;

	return {
		id: attachment.id,
		messageId: attachment.messageId,
		ticketId: attachment.ticketId,
		actorId: shouldAnonymise ? null : attachment.actorId,

		fileName: attachment.fileName,
		fileType: attachment.fileType,
		fileSize: attachment.fileSize,
	};
}

export function sanitiseTicketAttachments(
	attachments: TicketAttachment[],
	options: SanitiseOptions,
) {
	return attachments.map((a) => sanitiseTicketAttachment(a, options));
}