import { In } from "typeorm";
import * as mfm from "mfm-js";
import { Note } from "@/models/entities/note.js";
import type { User } from "@/models/entities/user.js";
import {
	Users,
	PollVotes,
	DriveFiles,
	NoteReactions,
	Followings,
	Polls,
	Channels,
	Notes, UserProfiles,
} from "../index.js";
import type { Packed } from "@/misc/schema.js";
import { nyaize } from "@/misc/nyaize.js";
import { awaitAll } from "@/prelude/await-all.js";
import {
	convertLegacyReaction,
	convertLegacyReactions,
	decodeReaction,
} from "@/misc/reaction-lib.js";
import type { NoteReaction } from "@/models/entities/note-reaction.js";
import {
	aggregateNoteEmojis,
	populateEmojis,
	prefetchEmojis,
} from "@/misc/populate-emojis.js";
import { db } from "@/db/postgre.js";
import { IdentifiableError } from "@/misc/identifiable-error.js";
import { PackedUserCache } from "@/models/repositories/user.js";
import { isFiltered } from "@/misc/is-filtered.js";

export async function populatePoll(note: Note, meId: User["id"] | null) {
	const poll = await Polls.findOneByOrFail({ noteId: note.id });
	const choices = poll.choices.map((c) => ({
		text: c,
		votes: poll.votes[poll.choices.indexOf(c)],
		isVoted: false,
	}));

	if (meId) {
		if (poll.multiple) {
			const votes = await PollVotes.findBy({
				userId: meId,
				noteId: note.id,
			});

			const myChoices = votes.map((v) => v.choice);
			for (const myChoice of myChoices) {
				choices[myChoice].isVoted = true;
			}
		} else {
			const vote = await PollVotes.findOneBy({
				userId: meId,
				noteId: note.id,
			});

			if (vote) {
				choices[vote.choice].isVoted = true;
			}
		}
	}

	return {
		multiple: poll.multiple,
		expiresAt: poll.expiresAt,
		choices,
	};
}

async function populateMyReaction(
	note: Note,
	meId: User["id"],
	_hint_?: {
		myReactions: Map<Note["id"], NoteReaction | null>;
	},
) {
	if (_hint_?.myReactions) {
		const reaction = _hint_.myReactions.get(note.id);
		if (reaction) {
			return convertLegacyReaction(reaction.reaction);
		} else if (reaction === null) {
			return undefined;
		}
		// 実装上抜けがあるだけかもしれないので、「ヒントに含まれてなかったら(=undefinedなら)return」のようにはしない
	}

	const reaction = await NoteReactions.findOneBy({
		userId: meId,
		noteId: note.id,
	});

	if (reaction) {
		return convertLegacyReaction(reaction.reaction);
	}

	return undefined;
}

async function populateIsRenoted(
	note: Note,
	meId: User["id"],
	_hint_?: {
		myRenotes: Map<Note["id"], boolean>;
	},
) {
	return _hint_?.myRenotes
		? _hint_.myRenotes.get(note.id) ? true : undefined
		: Notes.exist({ where: { renoteId: note.id, userId: meId } })
			.then(res => res ? true : undefined);
}

export const NoteRepository = db.getRepository(Note).extend({
	async isVisibleForMe(note: Note, meId: User["id"] | null): Promise<boolean> {
		// This code must always be synchronized with the checks in generateVisibilityQuery.
		// visibility が specified かつ自分が指定されていなかったら非表示
		if (note.visibility === "specified") {
			if (meId == null) {
				return false;
			} else if (meId === note.userId) {
				return true;
			} else {
				// 指定されているかどうか
				return note.visibleUserIds.some((id: any) => meId === id);
			}
		}

		// visibility が followers かつ自分が投稿者のフォロワーでなかったら非表示
		if (note.visibility === "followers") {
			if (meId == null) {
				return false;
			} else if (meId === note.userId) {
				return true;
			} else if (note.reply && meId === note.reply.userId) {
				// 自分の投稿に対するリプライ
				return true;
			} else if (note.mentions?.some((id) => meId === id)) {
				// 自分へのメンション
				return true;
			} else {
				// フォロワーかどうか
				const [following, user] = await Promise.all([
					Followings.count({
						where: {
							followeeId: note.userId,
							followerId: meId,
						},
						take: 1,
					}),
					Users.findOneByOrFail({ id: meId }),
				]);

				/* If we know the following, everyhting is fine.

				But if we do not know the following, it might be that both the
				author of the note and the author of the like are remote users,
				in which case we can never know the following. Instead we have
				to assume that the users are following each other.
				*/
				return following > 0 || (note.userHost != null && user.host != null);
			}
		}

		return true;
	},

	async pack(
		src: Note["id"] | Note,
		me?: { id: User["id"] } | null | undefined,
		options?: {
			detail?: boolean;
			_hint_?: {
				myReactions: Map<Note["id"], NoteReaction | null>;
				myRenotes: Map<Note["id"], boolean>;
			};
		},
		userCache: PackedUserCache = Users.getFreshPackedUserCache(),
	): Promise<Packed<"Note">> {
		const opts = Object.assign(
			{
				detail: true,
			},
			options,
		);

		const meId = me ? me.id : null;
		const note =
			typeof src === "object" ? src : await this.findOneByOrFail({ id: src });
		const host = note.userHost;

		if (!(await this.isVisibleForMe(note, meId))) {
			throw new IdentifiableError(
				"9725d0ce-ba28-4dde-95a7-2cbb2c15de24",
				"No such note.",
			);
		}

		let text = note.text;

		if (note.name && (note.url ?? note.uri)) {
			text = `【${note.name}】\n${(note.text || "").trim()}\n\n${
				note.url ?? note.uri
			}`;
		}

		const channel = note.channelId
			? note.channel
				? note.channel
				: await Channels.findOneBy({ id: note.channelId })
			: null;

		const reactionEmojiNames = Object.keys(note.reactions)
			.filter((x) => x?.startsWith(":"))
			.map((x) => decodeReaction(x).reaction)
			.map((x) => x.replace(/:/g, ""));

		const noteEmoji = await populateEmojis(
			note.emojis.concat(reactionEmojiNames),
			host,
		);
		const reactionEmoji = await populateEmojis(reactionEmojiNames, host);
		const packed: Packed<"Note"> = await awaitAll({
			id: note.id,
			createdAt: note.createdAt.toISOString(),
			userId: note.userId,
			user: Users.packCached(note.user ?? note.userId, userCache, me, {
				detail: false,
			}),
			text: text,
			cw: note.cw,
			visibility: note.visibility,
			localOnly: note.localOnly || undefined,
			visibleUserIds:
				note.visibility === "specified" ? note.visibleUserIds : undefined,
			renoteCount: note.renoteCount,
			repliesCount: note.repliesCount,
			reactions: convertLegacyReactions(note.reactions),
			reactionEmojis: reactionEmoji,
			emojis: noteEmoji,
			tags: note.tags.length > 0 ? note.tags : undefined,
			fileIds: note.fileIds,
			files: DriveFiles.packMany(note.fileIds),
			replyId: note.replyId,
			renoteId: note.renoteId,
			channelId: note.channelId || undefined,
			channel: channel
				? {
						id: channel.id,
						name: channel.name,
				  }
				: undefined,
			mentions: note.mentions.length > 0 ? note.mentions : undefined,
			uri: note.uri || undefined,
			url: note.url || undefined,
			updatedAt: note.updatedAt?.toISOString() || undefined,
			poll: note.hasPoll ? populatePoll(note, meId) : undefined,
			...(meId
				? {
						myReaction: populateMyReaction(note, meId, options?._hint_),
						isRenoted: populateIsRenoted(note, meId, options?._hint_),
						isFiltered: isFiltered(note, me),
				  }
				: {}),

			...(opts.detail
				? {
						reply: note.replyId
							? this.tryPack(note.reply || note.replyId, me, {
									detail: false,
									_hint_: options?._hint_,
							  }, userCache)
							: undefined,

						renote: note.renoteId
							? this.pack(note.renote || note.renoteId, me, {
									detail: true,
									_hint_: options?._hint_,
							  }, userCache)
							: undefined,
				  }
				: {}),
		});

		if (packed.user.isCat && packed.user.speakAsCat && packed.text) {
			const tokens = packed.text ? mfm.parse(packed.text) : [];
			function nyaizeNode(node: mfm.MfmNode) {
				if (node.type === "quote") return;
				if (node.type === "text") node.props.text = nyaize(node.props.text);

				if (node.children) {
					for (const child of node.children) {
						nyaizeNode(child);
					}
				}
			}

			for (const node of tokens) nyaizeNode(node);

			packed.text = mfm.toString(tokens);
		}

		return packed;
	},

	async tryPack(
		src: Note["id"] | Note,
		me?: { id: User["id"] } | null | undefined,
		options?: {
			detail?: boolean;
			_hint_?: {
				myReactions: Map<Note["id"], NoteReaction | null>;
				myRenotes: Map<Note["id"], boolean>;
			};
		},
		userCache: PackedUserCache = Users.getFreshPackedUserCache(),
	): Promise<Packed<"Note"> | undefined> {
		try {
			return await this.pack(src, me, options, userCache);
		} catch {
			return undefined;
		}
	},

	async packMany(
		notes: Note[],
		me?: { id: User["id"] } | null | undefined,
		options?: {
			detail?: boolean;
		},
		userCache: PackedUserCache = Users.getFreshPackedUserCache(),
	) {
		if (notes.length === 0) return [];

		const meId = me ? me.id : null;
		const myReactionsMap = new Map<Note["id"], NoteReaction | null>();
		const myRenotesMap = new Map<Note["id"], boolean>();
		if (meId) {
			const renoteIds = notes
				.filter((n) => n.renoteId != null)
				.map((n) => n.renoteId!);
			const targets = [...notes.map((n) => n.id), ...renoteIds];
			const myReactions = await NoteReactions.findBy({
				userId: meId,
				noteId: In(targets),
			});
			const myRenotes = await Notes.createQueryBuilder('note')
				.select('note.renoteId')
				.where('note.userId = :meId', { meId })
				.andWhere('note.renoteId IN (:...targets)', { targets })
				.andWhere('note.text IS NULL')
				.andWhere('note.hasPoll = FALSE')
				.andWhere(`note.fileIds = '{}'`)
				.getMany();

			for (const target of targets) {
				myReactionsMap.set(
					target,
					myReactions.find((reaction) => reaction.noteId === target) || null,
				);

				myRenotesMap.set(
					target,
					!!myRenotes.find(p => p.renoteId == target),
				);
			}
		}

		await prefetchEmojis(aggregateNoteEmojis(notes));

		const promises = await Promise.allSettled(
			notes.map((n) =>
				this.pack(n, me, {
					...options,
					_hint_: {
						myReactions: myReactionsMap,
						myRenotes: myRenotesMap
					},
				}, userCache),
			),
		);

		// filter out rejected promises, only keep fulfilled values
		return promises.flatMap((result) =>
			result.status === "fulfilled" ? [result.value] : [],
		);
	},
});
