import * as mfm from "mfm-js";
import { publishMainStream, publishNotesStream, publishNoteStream } from "../stream.js";
import DeliverManager, { deliverToUser } from "../../remote/activitypub/deliver-manager.js";
import renderNote from "../../remote/activitypub/renderer/note.js";
import renderCreate from "../../remote/activitypub/renderer/create.js";
import renderAnnounce from "../../remote/activitypub/renderer/announce.js";
import { renderActivity } from "../../remote/activitypub/renderer/index.js";
import { resolveUser } from "../../remote/resolve-user.js";
import config from "../../config/index.js";
import { updateHashtags } from "../update-hashtag.js";
import { concat } from "../../prelude/array.js";
import { insertNoteUnread } from "./unread.js";
import { registerOrFetchInstanceDoc } from "../register-or-fetch-instance-doc.js";
import { extractMentions } from "../../misc/extract-mentions.js";
import { extractCustomEmojiNamesFromText, extractCustomEmojisFromMfm } from "../../misc/extract-custom-emojis-from-mfm.js";
import { extractGroupMentionedUsers } from "../../misc/extract-group-mentions.js";
import { extractHashtags } from "../../misc/extract-hashtags.js";
import { Note } from "../../models/entities/note.js";
import { Mutings, Users, DriveFiles, NoteWatchings, Notes, Instances, UserProfiles, Channels, ChannelFollowings, NoteThreadMutings, InteractionStamps } from "../../models/index.js";
import { Not, In } from "typeorm";
import { genId } from "../../misc/gen-id.js";
import { notesChart, perUserNotesChart, activeUsersChart, instanceChart } from "../chart/index.js";
import { Poll } from "../../models/entities/poll.js";
import { createNotification } from "../create-notification.js";
import { isDuplicateKeyValueError } from "../../misc/is-duplicate-key-value-error.js";
import { checkHitAntenna } from "../../misc/check-hit-antenna.js";
import { addNoteToAntenna } from "../add-note-to-antenna.js";
import { countSameRenotes } from "../../misc/count-same-renotes.js";
import { deliverToRelays, getCachedRelays } from "../relay.js";
import { normalizeForSearch } from "../../misc/normalize-for-search.js";
import { getAntennas } from "../../misc/antenna-cache.js";
import { endedPollNotificationQueue } from "../../queue/queues.js";
import { webhookDeliver } from "../../queue/index.js";
import { db } from "../../db/postgre.js";
import { getActiveWebhooks } from "../../misc/webhook-cache.js";
import { shouldSilenceInstance } from "../../misc/should-block-instance.js";
import { redisClient } from "../../db/redis.js";
import { Mutex } from "redis-semaphore";
import { RecursionLimiter } from "../../models/repositories/user-profile.js";
import { NoteConverter } from "../../server/api/mastodon/converters/note.js";
import { defaultJobOpts } from "../../queue/queues/index.js";
import renderQuoteRequest from "../../remote/activitypub/renderer/quote-request.js";
class NotificationManager {
    notifier;
    note;
    queue;
    constructor(notifier, note){
        this.notifier = notifier;
        this.note = note;
        this.queue = [];
    }
    push(notifiee, reason) {
        // 自分自身へは通知しない
        if (this.notifier.id === notifiee) return;
        const exist = this.queue.find((x)=>x.target === notifiee);
        if (exist) {
            // 「メンションされているかつ返信されている」場合は、メンションとしての通知ではなく返信としての通知にする
            if (reason !== "mention") {
                exist.reason = reason;
            }
        } else {
            this.queue.push({
                reason: reason,
                target: notifiee
            });
        }
    }
    async deliver() {
        for (const x of this.queue){
            // ミュート情報を取得
            const mentioneeMutes = await Mutings.findBy({
                muterId: x.target
            });
            const mentioneesMutedUserIds = mentioneeMutes.map((m)=>m.muteeId);
            // 通知される側のユーザーが通知する側のユーザーをミュートしていない限りは通知する
            if (!mentioneesMutedUserIds.includes(this.notifier.id)) {
                createNotification(x.target, x.reason, {
                    notifierId: this.notifier.id,
                    noteId: this.note.id,
                    note: this.note
                });
            }
        }
    }
}
export default (async (user, data, silent = false, limiter = new RecursionLimiter())=>// rome-ignore lint/suspicious/noAsyncPromiseExecutor: FIXME
    new Promise(async (res, rej)=>{
        const dontFederateInitially = data.visibility === "hidden";
        // If you reply outside the channel, match the scope of the target.
        // TODO (I think it's a process that could be done on the client side, but it's server side for now.)
        if (data.reply && data.channel && data.reply.channelId !== data.channel.id) {
            if (data.reply.channelId) {
                data.channel = await Channels.findOneBy({
                    id: data.reply.channelId
                });
            } else {
                data.channel = null;
            }
        }
        // When you reply in a channel, match the scope of the target
        // TODO (I think it's a process that could be done on the client side, but it's server side for now.)
        if (data.reply && data.channel == null && data.reply.channelId) {
            data.channel = await Channels.findOneBy({
                id: data.reply.channelId
            });
        }
        const now = new Date();
        if (!data.createdAt || isNaN(data.createdAt.getTime()) || data.createdAt > now) data.createdAt = now;
        if (data.visibility == null) data.visibility = "public";
        if (data.localOnly == null) data.localOnly = false;
        if (data.channel != null) data.visibility = "public";
        if (data.channel != null) data.visibleUsers = [];
        if (data.channel != null) data.localOnly = true;
        if (data.visibility === "hidden") data.visibility = "public";
        // enforce silent clients on server
        if (user.isSilenced && data.visibility === "public" && data.channel == null) {
            data.visibility = "home";
        }
        // Enforce home visibility if the user is in a silenced instance.
        if (data.visibility === "public" && Users.isRemoteUser(user) && await shouldSilenceInstance(user.host)) {
            data.visibility = "home";
        }
        // Reject if the target of the renote is a public range other than "Home or Entire".
        if (data.renote && data.renote.visibility !== "public" && data.renote.visibility !== "home" && data.renote.userId !== user.id) {
            return rej("Renote target is not public or home");
        }
        // If the target of the renote is not public, make it home.
        if (data.renote && data.renote.visibility !== "public" && data.visibility === "public") {
            data.visibility = "home";
        }
        // If the target of Renote is followers, make it followers.
        if (data.renote && data.renote.visibility === "followers") {
            data.visibility = "followers";
        }
        // If the reply target is not public, make it home.
        if (data.reply && data.reply.visibility !== "public" && data.visibility === "public") {
            data.visibility = "home";
        }
        // Renote local only if you Renote local only.
        if (data.renote?.localOnly && data.channel == null) {
            data.localOnly = true;
        }
        // If you reply to local only, make it local only.
        if (data.reply?.localOnly && data.channel == null) {
            data.localOnly = true;
        }
        if (data.text) {
            data.text = data.text.trim();
        } else {
            data.text = null;
        }
        let tags = data.apHashtags;
        let emojis = data.apEmojis;
        let mentionedUsers = data.apMentions;
        // Parse MFM if needed
        if (!(tags && emojis && mentionedUsers)) {
            const tokens = data.text ? mfm.parse(data.text) : [];
            const cwTokens = data.cw ? mfm.parse(data.cw) : [];
            const choiceTokens = data.poll?.choices ? concat(data.poll.choices.map((choice)=>mfm.parse(choice))) : [];
            const combinedTokens = tokens.concat(cwTokens).concat(choiceTokens);
            tags = data.apHashtags || extractHashtags(combinedTokens);
            emojis = data.apEmojis || [
                ...new Set([
                    ...extractCustomEmojisFromMfm(combinedTokens),
                    ...extractCustomEmojiNamesFromText([
                        data.text,
                        data.cw,
                        ...data.poll?.choices ?? []
                    ])
                ])
            ];
            mentionedUsers = data.apMentions || await extractMentionedUsers(user, combinedTokens, limiter);
            if (!data.apMentions) {
                const groupMentionedUsers = await extractGroupMentionedUsers([
                    data.text,
                    data.cw,
                    ...data.poll?.choices ?? []
                ]);
                for (const u of groupMentionedUsers){
                    if (!mentionedUsers.some((x)=>x.id === u.id)) {
                        mentionedUsers.push(u);
                    }
                }
            }
        }
        tags = tags.filter((tag)=>Array.from(tag || "").length <= 128).splice(0, 32);
        if (data.reply && user.id !== data.reply.userId && !mentionedUsers.some((u)=>u.id === data.reply.userId)) {
            mentionedUsers.push(await Users.findOneByOrFail({
                id: data.reply.userId
            }));
        }
        if (data.visibility === "specified") {
            if (data.visibleUsers == null) throw new Error("invalid param");
            for (const u of data.visibleUsers){
                if (!mentionedUsers.some((x)=>x.id === u.id)) {
                    mentionedUsers.push(u);
                }
            }
            if (data.reply && !data.visibleUsers.some((x)=>x.id === data.reply.userId)) {
                data.visibleUsers.push(await Users.findOneByOrFail({
                    id: data.reply.userId
                }));
            }
        }
        const note = await insertNote(user, data, tags, emojis, mentionedUsers);
        // We need to increment these before resolving the promise
        if (data.reply) {
            await incRepliesCount(data.reply);
        }
        // この投稿を除く指定したユーザーによる指定したノートのリノートが存在しないとき
        if (data.renote && await countSameRenotes(user.id, data.renote.id, note.id, data.group?.id ?? null) === 0) {
            await incRenoteCount(data.renote);
        }
        res(note);
        // Prewarm html cache
        NoteConverter.prewarmCache(note);
        // 統計を更新
        notesChart.update(note, true);
        perUserNotesChart.update(user, note, true);
        // Register host
        if (Users.isRemoteUser(user)) {
            registerOrFetchInstanceDoc(user.host).then((i)=>{
                Instances.increment({
                    id: i.id
                }, "notesCount", 1);
                instanceChart.updateNote(i.host, note, true);
            });
        }
        // ハッシュタグ更新
        if (data.visibility === "public" || data.visibility === "home") {
            updateHashtags(user, tags);
        }
        // Increment notes count (user)
        incNotesCountOfUser(user);
        // Antenna
        for (const antenna of (await getAntennas())){
            checkHitAntenna(antenna, note, user).then((hit)=>{
                if (hit) {
                    addNoteToAntenna(antenna, note, user);
                }
            });
        }
        // Channel
        if (note.channelId) {
            ChannelFollowings.findBy({
                followeeId: note.channelId
            }).then((followings)=>{
                for (const following of followings){
                    insertNoteUnread(following.followerId, note, {
                        isSpecified: false,
                        isMentioned: false
                    });
                }
            });
        }
        if (data.poll?.expiresAt) {
            const delay = data.poll.expiresAt.getTime() - Date.now();
            endedPollNotificationQueue.add("default", {
                noteId: note.id
            }, {
                delay,
                ...defaultJobOpts
            });
        }
        if (!silent) {
            if (Users.isLocalUser(user)) activeUsersChart.write(user);
            // 未読通知を作成
            if (data.visibility === "specified") {
                if (data.visibleUsers == null) throw new Error("invalid param");
                for (const u of data.visibleUsers){
                    // ローカルユーザーのみ
                    if (!Users.isLocalUser(u)) continue;
                    insertNoteUnread(u.id, note, {
                        isSpecified: true,
                        isMentioned: false
                    });
                }
            } else {
                for (const u of mentionedUsers){
                    // ローカルユーザーのみ
                    if (!Users.isLocalUser(u)) continue;
                    insertNoteUnread(u.id, note, {
                        isSpecified: false,
                        isMentioned: true
                    });
                }
            }
            if (!dontFederateInitially) {
                let publishKey;
                let noteToPublish;
                const relays = await getCachedRelays();
                // Some relays (e.g., aode-relay) deliver posts by boosting them as
                // Announce activities. In that case, user is the relay's actor.
                const boostedByRelay = !!user.inbox && relays.map((relay)=>relay.inbox).includes(user.inbox);
                if (boostedByRelay && data.renote && data.renote.userHost) {
                    publishKey = `publishedNote:${data.renote.id}`;
                    noteToPublish = data.renote;
                } else {
                    publishKey = `publishedNote:${note.id}`;
                    noteToPublish = note;
                }
                const lock = new Mutex(redisClient, "publishedNote");
                await lock.acquire();
                try {
                    const published = await redisClient.get(publishKey) !== null;
                    if (!published) {
                        await redisClient.set(publishKey, "done", "EX", 30);
                        if (noteToPublish.renoteId) {
                            // Prevents other threads from publishing the boosting post
                            await redisClient.set(`publishedNote:${noteToPublish.renoteId}`, "done", "EX", 30);
                        }
                        publishNotesStream(noteToPublish);
                    }
                } finally{
                    await lock.release();
                }
            }
            if (note.replyId != null) {
                // Only provide the reply note id here as the recipient may not be authorized to see the note.
                publishNoteStream(note.replyId, "replied", {
                    id: note.id
                });
            }
            const webhooks = await getActiveWebhooks().then((webhooks)=>webhooks.filter((x)=>x.userId === user.id && x.on.includes("note")));
            for (const webhook of webhooks){
                webhookDeliver(webhook, "note", {
                    note: await Notes.pack(note, user)
                });
            }
            const nm = new NotificationManager(user, note);
            const nmRelatedPromises = [];
            await createMentionedEvents(mentionedUsers, note, nm);
            // If has in reply to note
            if (data.reply) {
                // Fetch watchers
                nmRelatedPromises.push(notifyToWatchersOfReplyee(data.reply, user, nm));
                // 通知
                if (data.reply.userHost === null) {
                    const threadMuted = await NoteThreadMutings.findOneBy({
                        userId: data.reply.userId,
                        threadId: data.reply.threadId || data.reply.id
                    });
                    if (!threadMuted) {
                        nm.push(data.reply.userId, "reply");
                        const packedReply = await Notes.pack(note, {
                            id: data.reply.userId
                        });
                        publishMainStream(data.reply.userId, "reply", packedReply);
                        const webhooks = (await getActiveWebhooks()).filter((x)=>x.userId === data.reply.userId && x.on.includes("reply"));
                        for (const webhook of webhooks){
                            webhookDeliver(webhook, "reply", {
                                note: packedReply
                            });
                        }
                    }
                }
            }
            // If it is renote
            if (data.renote) {
                const type = isPlain(note) ? "renote" : "quote";
                // Notify
                if (data.renote.userHost === null) {
                    const threadMuted = await NoteThreadMutings.findOneBy({
                        userId: data.renote.userId,
                        threadId: data.renote.threadId || data.renote.id
                    });
                    if (!threadMuted) {
                        nm.push(data.renote.userId, type);
                    }
                }
                // Fetch watchers
                nmRelatedPromises.push(notifyToWatchersOfRenotee(data.renote, user, nm, type));
                // Publish event
                if (user.id !== data.renote.userId && data.renote.userHost === null) {
                    const packedRenote = await Notes.pack(note, {
                        id: data.renote.userId
                    });
                    publishMainStream(data.renote.userId, "renote", packedRenote);
                    const renote = data.renote;
                    const webhooks = (await getActiveWebhooks()).filter((x)=>x.userId === renote.userId && x.on.includes("renote"));
                    for (const webhook of webhooks){
                        webhookDeliver(webhook, "renote", {
                            note: packedRenote
                        });
                    }
                }
                // Stamp renote if target is a local post
                if (!data.localOnly && data.renote.userHost === null && type === "quote") {
                    console.log("stamping");
                    const stamp = {
                        id: genId(),
                        type: "quote",
                        noteId: note.id,
                        targetNoteId: data.renote.id
                    };
                    await InteractionStamps.insert(stamp);
                    note.quoteAuthorization = `${config.url}/stamp/${stamp.id}`;
                    await Notes.update({
                        id: note.id
                    }, {
                        quoteAuthorization: note.quoteAuthorization
                    });
                }
            }
            Promise.all(nmRelatedPromises).then(()=>{
                nm.deliver();
            });
            //#region AP deliver
            if (Users.isLocalUser(user) && !data.localOnly && !dontFederateInitially) {
                (async ()=>{
                    const noteActivity = await renderNoteOrRenoteActivity(data, note);
                    const dm = new DeliverManager(user, noteActivity);
                    // メンションされたリモートユーザーに配送
                    for (const u of mentionedUsers.filter((u)=>Users.isRemoteUser(u))){
                        dm.addDirectRecipe(u);
                    }
                    // 投稿がリプライかつ投稿者がローカルユーザーかつリプライ先の投稿の投稿者がリモートユーザーなら配送
                    if (data.reply && data.reply.userHost !== null) {
                        const u = await Users.findOneBy({
                            id: data.reply.userId
                        });
                        if (u && Users.isRemoteUser(u)) dm.addDirectRecipe(u);
                    }
                    // 投稿がRenoteかつ投稿者がローカルユーザーかつRenote元の投稿の投稿者がリモートユーザーなら配送
                    if (data.renote && data.renote.userHost !== null) {
                        const u = await Users.findOneBy({
                            id: data.renote.userId
                        });
                        if (u && Users.isRemoteUser(u)) {
                            dm.addDirectRecipe(u);
                            if (data.renote.canQuote && !isPlain(note)) deliverToUser(user, renderActivity(renderQuoteRequest(note, data.renote)), u);
                        }
                    }
                    // フォロワーに配送
                    if ([
                        "public",
                        "home",
                        "followers"
                    ].includes(note.visibility)) {
                        dm.addFollowersRecipe();
                    }
                    if ([
                        "public"
                    ].includes(note.visibility)) {
                        deliverToRelays(user, noteActivity);
                    }
                    dm.execute();
                })();
            }
        //#endregion
        }
        if (data.channel) {
            Channels.increment({
                id: data.channel.id
            }, "notesCount", 1);
            Channels.update(data.channel.id, {
                lastNotedAt: new Date()
            });
            await Notes.countBy({
                userId: user.id,
                channelId: data.channel.id
            }).then((count)=>{
                // この処理が行われるのはノート作成後なので、ノートが一つしかなかったら最初の投稿だと判断できる
                // TODO: とはいえノートを削除して何回も投稿すればその分だけインクリメントされる雑さもあるのでどうにかしたい
                if (count === 1 && data.channel != null) {
                    Channels.increment({
                        id: data.channel.id
                    }, "usersCount", 1);
                }
            });
        }
    }));
async function renderNoteOrRenoteActivity(data, note) {
    if (data.localOnly) return null;
    const content = data.renote && isPlain(note) ? renderAnnounce(data.renote.uri ?? `${config.url}/notes/${data.renote.id}`, note) : renderCreate(await renderNote(note, false), note);
    return renderActivity(content);
}
function isPlain(note) {
    return note.text == null && note.cw == null && !note.hasPoll && note.fileIds.length === 0;
}
async function incRenoteCount(renote) {
    // only await renoteCount increment, as score isn't relevant for returning the correct created note response
    await Notes.increment({
        id: renote.id
    }, "renoteCount", 1);
    Notes.increment({
        id: renote.id
    }, "score", 1);
}
async function insertNote(user, data, tags, emojis, mentionedUsers) {
    if (data.createdAt === null || data.createdAt === undefined) {
        data.createdAt = new Date();
    }
    const insert = new Note({
        id: genId(data.createdAt),
        createdAt: data.createdAt,
        fileIds: data.files ? data.files.map((file)=>file.id) : [],
        replyId: data.reply ? data.reply.id : null,
        renoteId: data.renote ? data.renote.id : null,
        channelId: data.channel ? data.channel.id : null,
        threadId: data.reply ? data.reply.threadId ? data.reply.threadId : data.reply.id : null,
        name: data.name,
        text: data.text,
        hasPoll: data.poll != null,
        cw: data.cw == null ? null : data.cw,
        tags: tags.map((tag)=>normalizeForSearch(tag)),
        emojis,
        userId: user.id,
        groupId: data.group?.id ?? null,
        localOnly: data.localOnly || false,
        visibility: data.visibility,
        visibleUserIds: data.visibility === "specified" ? data.visibleUsers ? data.visibleUsers.map((u)=>u.id) : [] : [],
        attachedFileTypes: data.files ? data.files.map((file)=>file.type) : [],
        canQuote: data.canQuote,
        // 以下非正規化データ
        replyUserId: data.reply ? data.reply.userId : null,
        replyUserHost: data.reply ? data.reply.userHost : null,
        renoteUserId: data.renote ? data.renote.userId : null,
        renoteUserHost: data.renote ? data.renote.userHost : null,
        userHost: user.host
    });
    if (data.uri != null) insert.uri = data.uri;
    if (data.url != null) insert.url = data.url;
    if (insert.fileIds.length > 0 && insert.tags.includes("karaokeservice")) {
        await DriveFiles.update({
            id: In(insert.fileIds)
        }, {
            allowDownload: false
        });
    }
    // Append mentions data
    if (mentionedUsers.length > 0) {
        insert.mentions = mentionedUsers.map((u)=>u.id);
        const profiles = await UserProfiles.findBy({
            userId: In(insert.mentions)
        });
        insert.mentionedRemoteUsers = JSON.stringify(mentionedUsers.filter((u)=>Users.isRemoteUser(u)).map((u)=>{
            const profile = profiles.find((p)=>p.userId === u.id);
            const url = profile != null ? profile.url : null;
            return {
                uri: u.uri,
                url: url == null ? undefined : url,
                username: u.username,
                host: u.host
            };
        }));
    }
    // 投稿を作成
    try {
        if (insert.hasPoll) {
            // Prepare objects
            if (!data.poll) throw new Error("Empty poll data");
            let expiresAt;
            if (!data.poll.expiresAt || isNaN(data.poll.expiresAt.getTime())) {
                expiresAt = null;
            } else {
                expiresAt = data.poll.expiresAt;
            }
            const poll = new Poll({
                noteId: insert.id,
                choices: data.poll.choices,
                expiresAt,
                multiple: data.poll.multiple,
                votes: new Array(data.poll.choices.length).fill(0),
                noteVisibility: insert.visibility,
                userId: user.id,
                userHost: user.host
            });
            // Save the objects atomically using a db transaction, note that we should never run any code in a transaction block directly
            await db.transaction(async (transactionalEntityManager)=>{
                await transactionalEntityManager.insert(Note, insert);
                await transactionalEntityManager.insert(Poll, poll);
            });
        } else {
            await Notes.insert(insert);
        }
        return insert;
    } catch (e) {
        // duplicate key error
        if (isDuplicateKeyValueError(e)) {
            const err = new Error("Duplicated note");
            err.name = "duplicated";
            throw err;
        }
        console.error(e);
        throw e;
    }
}
async function notifyToWatchersOfRenotee(renote, user, nm, type) {
    const watchers = await NoteWatchings.findBy({
        noteId: renote.id,
        userId: Not(user.id)
    });
    for (const watcher of watchers){
        nm.push(watcher.userId, type);
    }
}
async function notifyToWatchersOfReplyee(reply, user, nm) {
    const watchers = await NoteWatchings.findBy({
        noteId: reply.id,
        userId: Not(user.id)
    });
    for (const watcher of watchers){
        nm.push(watcher.userId, "reply");
    }
}
async function createMentionedEvents(mentionedUsers, note, nm) {
    for (const u of mentionedUsers.filter((u)=>Users.isLocalUser(u))){
        const threadMuted = await NoteThreadMutings.findOneBy({
            userId: u.id,
            threadId: note.threadId || note.id
        });
        if (threadMuted) {
            continue;
        }
        // note with "specified" visibility might not be visible to mentioned users
        try {
            const detailPackedNote = await Notes.pack(note, u, {
                detail: true
            });
            publishMainStream(u.id, "mention", detailPackedNote);
            const webhooks = (await getActiveWebhooks()).filter((x)=>x.userId === u.id && x.on.includes("mention"));
            for (const webhook of webhooks){
                webhookDeliver(webhook, "mention", {
                    note: detailPackedNote
                });
            }
        } catch (err) {
            if (err.id === "9725d0ce-ba28-4dde-95a7-2cbb2c15de24") continue;
            throw err;
        }
        // Create notification
        nm.push(u.id, "mention");
    }
}
async function incRepliesCount(reply) {
    await Notes.increment({
        id: reply.id
    }, "repliesCount", 1);
}
function incNotesCountOfUser(user) {
    Users.createQueryBuilder().update().set({
        updatedAt: new Date(),
        notesCount: ()=>'"notesCount" + 1'
    }).where("id = :id", {
        id: user.id
    }).execute();
}
export async function extractMentionedUsers(user, tokens, limiter = new RecursionLimiter()) {
    if (tokens == null) return [];
    const mentions = extractMentions(tokens);
    let mentionedUsers = (await Promise.all(mentions.map((m)=>resolveUser(m.username, m.host || user.host, undefined, limiter).catch(()=>null)))).filter((x)=>x != null);
    // Drop duplicate users
    mentionedUsers = mentionedUsers.filter((u, i, self)=>i === self.findIndex((u2)=>u.id === u2.id));
    return mentionedUsers;
}