microblog.pub/app/boxes.py

"""Actions related to the AP inbox/outbox."""
import uuid
from collections import defaultdict
from dataclasses import dataclass
from datetime import timedelta
from urllib.parse import urlparse

import fastapi
import httpx
from loguru import logger
from sqlalchemy import delete
from sqlalchemy import func
from sqlalchemy import select
from sqlalchemy import update
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import joinedload

from app import activitypub as ap
from app import config
from app import ldsig
from app import models
from app.actor import LOCAL_ACTOR
from app.actor import Actor
from app.actor import RemoteActor
from app.actor import fetch_actor
from app.actor import save_actor
from app.ap_object import RemoteObject
from app.config import BASE_URL
from app.config import ID
from app.database import AsyncSession
from app.outgoing_activities import new_outgoing_activity
from app.source import markdownify
from app.uploads import upload_to_attachment
from app.utils import opengraph
from app.utils import webmentions
from app.utils.datetime import as_utc
from app.utils.datetime import now
from app.utils.datetime import parse_isoformat

AnyboxObject = models.InboxObject | models.OutboxObject


def allocate_outbox_id() -> str:
    return uuid.uuid4().hex


def outbox_object_id(outbox_id) -> str:
    return f"{BASE_URL}/o/{outbox_id}"


async def save_outbox_object(
    db_session: AsyncSession,
    public_id: str,
    raw_object: ap.RawObject,
    relates_to_inbox_object_id: int | None = None,
    relates_to_outbox_object_id: int | None = None,
    relates_to_actor_id: int | None = None,
    source: str | None = None,
    is_transient: bool = False,
) -> models.OutboxObject:
    ra = await RemoteObject.from_raw_object(raw_object)

    outbox_object = models.OutboxObject(
        public_id=public_id,
        ap_type=ra.ap_type,
        ap_id=ra.ap_id,
        ap_context=ra.ap_context,
        ap_object=ra.ap_object,
        visibility=ra.visibility,
        og_meta=await opengraph.og_meta_from_note(ra.ap_object),
        relates_to_inbox_object_id=relates_to_inbox_object_id,
        relates_to_outbox_object_id=relates_to_outbox_object_id,
        relates_to_actor_id=relates_to_actor_id,
        activity_object_ap_id=ra.activity_object_ap_id,
        is_hidden_from_homepage=True if ra.in_reply_to else False,
        source=source,
        is_transient=is_transient,
    )
    db_session.add(outbox_object)
    await db_session.flush()
    await db_session.refresh(outbox_object)

    return outbox_object


async def send_delete(db_session: AsyncSession, ap_object_id: str) -> None:
    outbox_object_to_delete = await get_outbox_object_by_ap_id(db_session, ap_object_id)
    if not outbox_object_to_delete:
        raise ValueError(f"{ap_object_id} not found in the outbox")

    delete_id = allocate_outbox_id()
    delete = {
        "@context": ap.AS_EXTENDED_CTX,
        "id": outbox_object_id(delete_id),
        "type": "Delete",
        "actor": ID,
        "object": {
            "type": "Tombstone",
            "id": ap_object_id,
        },
    }
    outbox_object = await save_outbox_object(
        db_session,
        delete_id,
        delete,
        relates_to_outbox_object_id=outbox_object_to_delete.id,
    )
    if not outbox_object.id:
        raise ValueError("Should never happen")

    outbox_object_to_delete.is_deleted = True
    await db_session.commit()

    # Compute the original recipients
    recipients = await _compute_recipients(
        db_session, outbox_object_to_delete.ap_object
    )
    for rcp in recipients:
        await new_outgoing_activity(db_session, rcp, outbox_object.id)

    await db_session.commit()


async def send_like(db_session: AsyncSession, ap_object_id: str) -> None:
    inbox_object = await get_inbox_object_by_ap_id(db_session, ap_object_id)
    if not inbox_object:
        raise ValueError(f"{ap_object_id} not found in the inbox")

    like_id = allocate_outbox_id()
    like = {
        "@context": ap.AS_CTX,
        "id": outbox_object_id(like_id),
        "type": "Like",
        "actor": ID,
        "object": ap_object_id,
    }
    outbox_object = await save_outbox_object(
        db_session, like_id, like, relates_to_inbox_object_id=inbox_object.id
    )
    if not outbox_object.id:
        raise ValueError("Should never happen")

    inbox_object.liked_via_outbox_object_ap_id = outbox_object.ap_id

    await new_outgoing_activity(
        db_session, inbox_object.actor.inbox_url, outbox_object.id
    )
    await db_session.commit()


async def send_announce(db_session: AsyncSession, ap_object_id: str) -> None:
    inbox_object = await get_inbox_object_by_ap_id(db_session, ap_object_id)
    if not inbox_object:
        raise ValueError(f"{ap_object_id} not found in the inbox")

    announce_id = allocate_outbox_id()
    announce = {
        "@context": ap.AS_CTX,
        "id": outbox_object_id(announce_id),
        "type": "Announce",
        "actor": ID,
        "object": ap_object_id,
        "to": [ap.AS_PUBLIC],
        "cc": [
            f"{BASE_URL}/followers",
            inbox_object.ap_actor_id,
        ],
    }
    outbox_object = await save_outbox_object(
        db_session, announce_id, announce, relates_to_inbox_object_id=inbox_object.id
    )
    if not outbox_object.id:
        raise ValueError("Should never happen")

    inbox_object.announced_via_outbox_object_ap_id = outbox_object.ap_id
    await db_session.commit()

    recipients = await _compute_recipients(db_session, announce)
    for rcp in recipients:
        await new_outgoing_activity(db_session, rcp, outbox_object.id)


async def send_follow(db_session: AsyncSession, ap_actor_id: str) -> None:
    actor = await fetch_actor(db_session, ap_actor_id)

    follow_id = allocate_outbox_id()
    follow = {
        "@context": ap.AS_CTX,
        "id": outbox_object_id(follow_id),
        "type": "Follow",
        "actor": ID,
        "object": ap_actor_id,
    }

    outbox_object = await save_outbox_object(
        db_session, follow_id, follow, relates_to_actor_id=actor.id
    )
    if not outbox_object.id:
        raise ValueError("Should never happen")

    await new_outgoing_activity(db_session, actor.inbox_url, outbox_object.id)
    await db_session.commit()


async def send_undo(db_session: AsyncSession, ap_object_id: str) -> None:
    outbox_object_to_undo = await get_outbox_object_by_ap_id(db_session, ap_object_id)
    if not outbox_object_to_undo:
        raise ValueError(f"{ap_object_id} not found in the outbox")

    if outbox_object_to_undo.ap_type not in ["Follow", "Like", "Announce"]:
        raise ValueError(
            f"Cannot build Undo for {outbox_object_to_undo.ap_type} activity"
        )

    undo_id = allocate_outbox_id()
    undo = {
        "@context": ap.AS_CTX,
        "id": outbox_object_id(undo_id),
        "type": "Undo",
        "actor": ID,
        "object": ap.remove_context(outbox_object_to_undo.ap_object),
    }

    outbox_object = await save_outbox_object(
        db_session,
        undo_id,
        undo,
        relates_to_outbox_object_id=outbox_object_to_undo.id,
    )
    if not outbox_object.id:
        raise ValueError("Should never happen")

    outbox_object_to_undo.undone_by_outbox_object_id = outbox_object.id

    if outbox_object_to_undo.ap_type == "Follow":
        if not outbox_object_to_undo.activity_object_ap_id:
            raise ValueError("Should never happen")
        followed_actor = await fetch_actor(
            db_session, outbox_object_to_undo.activity_object_ap_id
        )
        await new_outgoing_activity(
            db_session,
            followed_actor.inbox_url,
            outbox_object.id,
        )
        # Also remove the follow from the following collection
        await db_session.execute(
            delete(models.Following).where(
                models.Following.ap_actor_id == followed_actor.ap_id
            )
        )
    elif outbox_object_to_undo.ap_type == "Like":
        liked_object_ap_id = outbox_object_to_undo.activity_object_ap_id
        if not liked_object_ap_id:
            raise ValueError("Should never happen")
        liked_object = await get_inbox_object_by_ap_id(db_session, liked_object_ap_id)
        if not liked_object:
            raise ValueError(f"Cannot find liked object {liked_object_ap_id}")
        liked_object.liked_via_outbox_object_ap_id = None

        # Send the Undo to the liked object's actor
        await new_outgoing_activity(
            db_session,
            liked_object.actor.inbox_url,  # type: ignore
            outbox_object.id,
        )
    elif outbox_object_to_undo.ap_type == "Announce":
        announced_object_ap_id = outbox_object_to_undo.activity_object_ap_id
        if not announced_object_ap_id:
            raise ValueError("Should never happen")
        announced_object = await get_inbox_object_by_ap_id(
            db_session, announced_object_ap_id
        )
        if not announced_object:
            raise ValueError(f"Cannot find announced object {announced_object_ap_id}")
        announced_object.announced_via_outbox_object_ap_id = None

        # Send the Undo to the original recipients
        recipients = await _compute_recipients(db_session, outbox_object.ap_object)
        for rcp in recipients:
            await new_outgoing_activity(db_session, rcp, outbox_object.id)
    else:
        raise ValueError("Should never happen")

    await db_session.commit()


async def send_create(
    db_session: AsyncSession,
    ap_type: str,
    source: str,
    uploads: list[tuple[models.Upload, str, str | None]],
    in_reply_to: str | None,
    visibility: ap.VisibilityEnum,
    content_warning: str | None = None,
    is_sensitive: bool = False,
    poll_type: str | None = None,
    poll_answers: list[str] | None = None,
    poll_duration_in_minutes: int | None = None,
    name: str | None = None,
) -> str:
    note_id = allocate_outbox_id()
    published = now().replace(microsecond=0).isoformat().replace("+00:00", "Z")
    context = f"{ID}/contexts/" + uuid.uuid4().hex
    content, tags, mentioned_actors = await markdownify(db_session, source)
    attachments = []

    if in_reply_to:
        in_reply_to_object = await get_anybox_object_by_ap_id(db_session, in_reply_to)
        if not in_reply_to_object:
            raise ValueError(f"Invalid in reply to {in_reply_to=}")
        if not in_reply_to_object.ap_context:
            raise ValueError("Object has no context")
        context = in_reply_to_object.ap_context

        if in_reply_to_object.is_from_outbox:
            await db_session.execute(
                update(models.OutboxObject)
                .where(
                    models.OutboxObject.ap_id == in_reply_to,
                )
                .values(replies_count=models.OutboxObject.replies_count + 1)
            )

    for (upload, filename, alt_text) in uploads:
        attachments.append(upload_to_attachment(upload, filename, alt_text))

    to = []
    cc = []
    mentioned_actor_ap_ids = [actor.ap_id for actor in mentioned_actors]
    if visibility == ap.VisibilityEnum.PUBLIC:
        to = [ap.AS_PUBLIC]
        cc = [f"{BASE_URL}/followers"] + mentioned_actor_ap_ids
    elif visibility == ap.VisibilityEnum.UNLISTED:
        to = [f"{BASE_URL}/followers"]
        cc = [ap.AS_PUBLIC] + mentioned_actor_ap_ids
    elif visibility == ap.VisibilityEnum.FOLLOWERS_ONLY:
        to = [f"{BASE_URL}/followers"]
        cc = mentioned_actor_ap_ids
    elif visibility == ap.VisibilityEnum.DIRECT:
        to = mentioned_actor_ap_ids
        cc = []
    else:
        raise ValueError(f"Unhandled visibility {visibility}")

    extra_obj_attrs = {}
    if ap_type == "Question":
        if not poll_answers or len(poll_answers) < 2:
            raise ValueError("Question must have at least 2 possible answers")

        if not poll_type:
            raise ValueError("Mising poll_type")

        if not poll_duration_in_minutes:
            raise ValueError("Missing poll_duration_in_minutes")

        extra_obj_attrs = {
            "votersCount": 0,
            "endTime": (now() + timedelta(minutes=poll_duration_in_minutes))
            .isoformat()
            .replace("+00:00", "Z"),
            poll_type: [
                {
                    "type": "Note",
                    "name": answer,
                    "replies": {"type": "Collection", "totalItems": 0},
                }
                for answer in poll_answers
            ],
        }
    elif ap_type == "Article":
        if not name:
            raise ValueError("Article must have a name")

        extra_obj_attrs = {"name": name}

    obj = {
        "@context": ap.AS_EXTENDED_CTX,
        "type": ap_type,
        "id": outbox_object_id(note_id),
        "attributedTo": ID,
        "content": content,
        "to": to,
        "cc": cc,
        "published": published,
        "context": context,
        "conversation": context,
        "url": outbox_object_id(note_id),
        "tag": tags,
        "summary": content_warning,
        "inReplyTo": in_reply_to,
        "sensitive": is_sensitive,
        "attachment": attachments,
        **extra_obj_attrs,  # type: ignore
    }
    outbox_object = await save_outbox_object(db_session, note_id, obj, source=source)
    if not outbox_object.id:
        raise ValueError("Should never happen")

    for tag in tags:
        if tag["type"] == "Hashtag":
            tagged_object = models.TaggedOutboxObject(
                tag=tag["name"][1:],
                outbox_object_id=outbox_object.id,
            )
            db_session.add(tagged_object)

    for (upload, filename, alt) in uploads:
        outbox_object_attachment = models.OutboxObjectAttachment(
            filename=filename,
            alt=alt,
            outbox_object_id=outbox_object.id,
            upload_id=upload.id,
        )
        db_session.add(outbox_object_attachment)

    recipients = await _compute_recipients(db_session, obj)
    for rcp in recipients:
        await new_outgoing_activity(db_session, rcp, outbox_object.id)

    # If the note is public, check if we need to send any webmentions
    if visibility == ap.VisibilityEnum.PUBLIC:
        possible_targets = opengraph._urls_from_note(obj)
        logger.info(f"webmentions possible targert {possible_targets}")
        for target in possible_targets:
            webmention_endpoint = await webmentions.discover_webmention_endpoint(target)
            logger.info(f"{target=} {webmention_endpoint=}")
            if webmention_endpoint:
                await new_outgoing_activity(
                    db_session,
                    webmention_endpoint,
                    outbox_object_id=outbox_object.id,
                    webmention_target=target,
                )

    await db_session.commit()
    return note_id


async def send_vote(
    db_session: AsyncSession,
    in_reply_to: str,
    names: list[str],
) -> str:
    logger.info(f"Send vote {names}")
    published = now().replace(microsecond=0).isoformat().replace("+00:00", "Z")

    in_reply_to_object = await get_inbox_object_by_ap_id(db_session, in_reply_to)
    if not in_reply_to_object:
        raise ValueError(f"Invalid in reply to {in_reply_to=}")
    if not in_reply_to_object.ap_context:
        raise ValueError("Object has no context")
    context = in_reply_to_object.ap_context

    # TODO: ensure the name are valid?

    # Save the answers
    in_reply_to_object.voted_for_answers = names

    to = [in_reply_to_object.actor.ap_id]

    for name in names:
        vote_id = allocate_outbox_id()
        note = {
            "@context": ap.AS_EXTENDED_CTX,
            "type": "Note",
            "id": outbox_object_id(vote_id),
            "attributedTo": ID,
            "name": name,
            "to": to,
            "cc": [],
            "published": published,
            "context": context,
            "conversation": context,
            "url": outbox_object_id(vote_id),
            "inReplyTo": in_reply_to,
        }
        outbox_object = await save_outbox_object(
            db_session, vote_id, note, is_transient=True
        )
        if not outbox_object.id:
            raise ValueError("Should never happen")

        recipients = await _compute_recipients(db_session, note)
        for rcp in recipients:
            await new_outgoing_activity(db_session, rcp, outbox_object.id)

    await db_session.commit()
    return vote_id


async def send_update(
    db_session: AsyncSession,
    ap_id: str,
    source: str,
) -> str:
    outbox_object = await get_outbox_object_by_ap_id(db_session, ap_id)
    if not outbox_object:
        raise ValueError(f"{ap_id} not found")

    revisions = outbox_object.revisions or []
    revisions.append(
        {
            "ap_object": outbox_object.ap_object,
            "source": outbox_object.source,
            "updated": (
                outbox_object.ap_object.get("updated")
                or outbox_object.ap_object.get("published")
            ),
        }
    )

    updated = now().replace(microsecond=0).isoformat().replace("+00:00", "Z")
    content, tags, mentioned_actors = await markdownify(db_session, source)

    note = {
        "@context": ap.AS_EXTENDED_CTX,
        "type": outbox_object.ap_type,
        "id": outbox_object.ap_id,
        "attributedTo": ID,
        "content": content,
        "to": outbox_object.ap_object["to"],
        "cc": outbox_object.ap_object["cc"],
        "published": outbox_object.ap_object["published"],
        "context": outbox_object.ap_context,
        "conversation": outbox_object.ap_context,
        "url": outbox_object.url,
        "tag": tags,
        "summary": outbox_object.summary,
        "inReplyTo": outbox_object.in_reply_to,
        "sensitive": outbox_object.sensitive,
        "attachment": outbox_object.ap_object["attachment"],
        "updated": updated,
    }

    outbox_object.ap_object = note
    outbox_object.source = source
    outbox_object.revisions = revisions

    recipients = await _compute_recipients(db_session, note)
    for rcp in recipients:
        await new_outgoing_activity(db_session, rcp, outbox_object.id)

    # If the note is public, check if we need to send any webmentions
    if outbox_object.visibility == ap.VisibilityEnum.PUBLIC:
        possible_targets = opengraph._urls_from_note(note)
        logger.info(f"webmentions possible targert {possible_targets}")
        for target in possible_targets:
            webmention_endpoint = await webmentions.discover_webmention_endpoint(target)
            logger.info(f"{target=} {webmention_endpoint=}")
            if webmention_endpoint:
                await new_outgoing_activity(
                    db_session,
                    webmention_endpoint,
                    outbox_object_id=outbox_object.id,
                    webmention_target=target,
                )

    await db_session.commit()
    return outbox_object.public_id  # type: ignore


async def _compute_recipients(
    db_session: AsyncSession, ap_object: ap.RawObject
) -> set[str]:
    _recipients = []
    for field in ["to", "cc", "bto", "bcc"]:
        if field in ap_object:
            _recipients.extend(ap.as_list(ap_object[field]))

    recipients = set()
    logger.info(f"{_recipients}")
    for r in _recipients:
        if r in [ap.AS_PUBLIC, ID]:
            continue

        # If we got a local collection, assume it's a collection of actors
        if r.startswith(BASE_URL):
            for actor in await fetch_actor_collection(db_session, r):
                recipients.add(actor.shared_inbox_url or actor.inbox_url)

            continue

        # Is it a known actor?
        known_actor = (
            await db_session.execute(
                select(models.Actor).where(models.Actor.ap_id == r)
            )
        ).scalar_one_or_none()  # type: ignore
        if known_actor:
            recipients.add(known_actor.shared_inbox_url or known_actor.inbox_url)
            continue

        # Fetch the object
        raw_object = await ap.fetch(r)
        if raw_object.get("type") in ap.ACTOR_TYPES:
            saved_actor = await save_actor(db_session, raw_object)
            recipients.add(saved_actor.shared_inbox_url or saved_actor.inbox_url)
        else:
            # Assume it's a collection of actors
            for raw_actor in await ap.parse_collection(payload=raw_object):
                actor = RemoteActor(raw_actor)
                recipients.add(actor.shared_inbox_url or actor.inbox_url)

    return recipients


async def _get_following(db_session: AsyncSession) -> list[models.Follower]:
    return (
        (
            await db_session.scalars(
                select(models.Following).options(joinedload(models.Following.actor))
            )
        )
        .unique()
        .all()
    )


async def _get_followers(db_session: AsyncSession) -> list[models.Follower]:
    return (
        (
            await db_session.scalars(
                select(models.Follower).options(joinedload(models.Follower.actor))
            )
        )
        .unique()
        .all()
    )


async def _get_followers_recipients(
    db_session: AsyncSession,
    skip_actors: list[models.Actor] | None = None,
) -> set[str]:
    """Returns all the recipients from the local follower collection."""
    actor_ap_ids_to_skip = []
    if skip_actors:
        actor_ap_ids_to_skip = [actor.ap_id for actor in skip_actors]

    followers = await _get_followers(db_session)
    return {
        follower.actor.shared_inbox_url or follower.actor.inbox_url  # type: ignore
        for follower in followers
        if follower.actor.ap_id not in actor_ap_ids_to_skip
    }


async def get_inbox_object_by_ap_id(
    db_session: AsyncSession, ap_id: str
) -> models.InboxObject | None:
    return (
        await db_session.execute(
            select(models.InboxObject)
            .where(models.InboxObject.ap_id == ap_id)
            .options(
                joinedload(models.InboxObject.actor),
                joinedload(models.InboxObject.relates_to_inbox_object),
                joinedload(models.InboxObject.relates_to_outbox_object),
            )
        )
    ).scalar_one_or_none()  # type: ignore


async def get_inbox_delete_for_activity_object_ap_id(
    db_session: AsyncSession, activity_object_ap_id: str
) -> models.InboxObject | None:
    return (
        await db_session.execute(
            select(models.InboxObject)
            .where(
                models.InboxObject.ap_type == "Delete",
                models.InboxObject.activity_object_ap_id == activity_object_ap_id,
            )
            .options(
                joinedload(models.InboxObject.actor),
                joinedload(models.InboxObject.relates_to_inbox_object),
                joinedload(models.InboxObject.relates_to_outbox_object),
            )
        )
    ).scalar_one_or_none()  # type: ignore


async def get_outbox_object_by_ap_id(
    db_session: AsyncSession, ap_id: str
) -> models.OutboxObject | None:
    return (
        (
            await db_session.execute(
                select(models.OutboxObject)
                .where(models.OutboxObject.ap_id == ap_id)
                .options(
                    joinedload(models.OutboxObject.outbox_object_attachments).options(
                        joinedload(models.OutboxObjectAttachment.upload)
                    ),
                    joinedload(models.OutboxObject.relates_to_inbox_object).options(
                        joinedload(models.InboxObject.actor),
                    ),
                    joinedload(models.OutboxObject.relates_to_outbox_object).options(
                        joinedload(
                            models.OutboxObject.outbox_object_attachments
                        ).options(joinedload(models.OutboxObjectAttachment.upload)),
                    ),
                )
            )
        )
        .unique()
        .scalar_one_or_none()
    )  # type: ignore


async def get_anybox_object_by_ap_id(
    db_session: AsyncSession, ap_id: str
) -> AnyboxObject | None:
    if ap_id.startswith(BASE_URL):
        return await get_outbox_object_by_ap_id(db_session, ap_id)
    else:
        return await get_inbox_object_by_ap_id(db_session, ap_id)


async def _handle_delete_activity(
    db_session: AsyncSession,
    from_actor: models.Actor,
    delete_activity: models.InboxObject,
    ap_object_to_delete: models.InboxObject | None,
    forwarded_by_actor: models.Actor | None,
) -> None:
    if ap_object_to_delete is None:
        logger.info(
            "Received Delete for an unknown object "
            f"{delete_activity.activity_object_ap_id}"
        )
        # TODO(tsileo): support deleting actor
        return

    if from_actor.ap_id != ap_object_to_delete.actor.ap_id:
        logger.warning(
            "Actor mismatch between the activity and the object: "
            f"{from_actor.ap_id}/{ap_object_to_delete.actor.ap_id}"
        )
        return

    logger.info(f"Deleting {ap_object_to_delete.ap_type}/{ap_object_to_delete.ap_id}")
    await _revert_side_effect_for_deleted_object(
        db_session,
        delete_activity,
        ap_object_to_delete,
        forwarded_by_actor,
    )
    ap_object_to_delete.is_deleted = True

    await db_session.flush()


async def _revert_side_effect_for_deleted_object(
    db_session: AsyncSession,
    delete_activity: models.InboxObject,
    deleted_ap_object: models.InboxObject,
    forwarded_by_actor: models.Actor | None,
) -> None:
    is_delete_needs_to_be_forwarded = False

    # Decrement the replies counter if needed
    if deleted_ap_object.in_reply_to:
        replied_object = await get_anybox_object_by_ap_id(
            db_session,
            deleted_ap_object.in_reply_to,
        )
        if replied_object:
            if replied_object.is_from_outbox:
                # It's a local reply that was likely forwarded, the Delete
                # also needs to be forwarded
                is_delete_needs_to_be_forwarded = True

                await db_session.execute(
                    update(models.OutboxObject)
                    .where(
                        models.OutboxObject.id == replied_object.id,
                    )
                    .values(replies_count=models.OutboxObject.replies_count - 1)
                )
            else:
                await db_session.execute(
                    update(models.InboxObject)
                    .where(
                        models.InboxObject.id == replied_object.id,
                    )
                    .values(replies_count=models.InboxObject.replies_count - 1)
                )

    # Delete any Like/Announce
    await db_session.execute(
        update(models.OutboxObject)
        .where(
            models.OutboxObject.activity_object_ap_id == deleted_ap_object.ap_id,
        )
        .values(is_deleted=True)
    )

    # If it's a local replies, it was forwarded, so we also need to forward
    # the Delete activity if possible
    if delete_activity.has_ld_signature and is_delete_needs_to_be_forwarded:
        logger.info("Forwarding Delete activity as it's a local reply")

        # Don't forward to the forwarding actor and the original Delete actor
        skip_actors = [delete_activity.actor]
        if forwarded_by_actor:
            skip_actors.append(forwarded_by_actor)
        recipients = await _get_followers_recipients(
            db_session,
            skip_actors=skip_actors,
        )
        for rcp in recipients:
            await new_outgoing_activity(
                db_session,
                rcp,
                outbox_object_id=None,
                inbox_object_id=delete_activity.id,
            )


async def _handle_follow_follow_activity(
    db_session: AsyncSession,
    from_actor: models.Actor,
    inbox_object: models.InboxObject,
) -> None:
    follower = models.Follower(
        actor_id=from_actor.id,
        inbox_object_id=inbox_object.id,
        ap_actor_id=from_actor.ap_id,
    )
    try:
        db_session.add(follower)
        await db_session.flush()
    except IntegrityError:
        pass  # TODO update the existing followe

    # Reply with an Accept
    reply_id = allocate_outbox_id()
    reply = {
        "@context": ap.AS_CTX,
        "id": outbox_object_id(reply_id),
        "type": "Accept",
        "actor": ID,
        "object": inbox_object.ap_id,
    }
    outbox_activity = await save_outbox_object(db_session, reply_id, reply)
    if not outbox_activity.id:
        raise ValueError("Should never happen")
    await new_outgoing_activity(db_session, from_actor.inbox_url, outbox_activity.id)

    notif = models.Notification(
        notification_type=models.NotificationType.NEW_FOLLOWER,
        actor_id=from_actor.id,
    )
    db_session.add(notif)


async def _handle_undo_activity(
    db_session: AsyncSession,
    from_actor: models.Actor,
    undo_activity: models.InboxObject,
    ap_activity_to_undo: models.InboxObject,
) -> None:
    if from_actor.ap_id != ap_activity_to_undo.actor.ap_id:
        logger.warning(
            "Actor mismatch between the activity and the object: "
            f"{from_actor.ap_id}/{ap_activity_to_undo.actor.ap_id}"
        )
        return

    ap_activity_to_undo.undone_by_inbox_object_id = undo_activity.id
    ap_activity_to_undo.is_deleted = True

    if ap_activity_to_undo.ap_type == "Follow":
        logger.info(f"Undo follow from {from_actor.ap_id}")
        await db_session.execute(
            delete(models.Follower).where(
                models.Follower.inbox_object_id == ap_activity_to_undo.id
            )
        )
        notif = models.Notification(
            notification_type=models.NotificationType.UNFOLLOW,
            actor_id=from_actor.id,
        )
        db_session.add(notif)

    elif ap_activity_to_undo.ap_type == "Like":
        if not ap_activity_to_undo.activity_object_ap_id:
            raise ValueError("Like without object")
        liked_obj = await get_outbox_object_by_ap_id(
            db_session,
            ap_activity_to_undo.activity_object_ap_id,
        )
        if not liked_obj:
            logger.warning(
                "Cannot find liked object: "
                f"{ap_activity_to_undo.activity_object_ap_id}"
            )
            return

        liked_obj.likes_count = models.OutboxObject.likes_count - 1
        notif = models.Notification(
            notification_type=models.NotificationType.UNDO_LIKE,
            actor_id=from_actor.id,
            outbox_object_id=liked_obj.id,
            inbox_object_id=ap_activity_to_undo.id,
        )
        db_session.add(notif)

    elif ap_activity_to_undo.ap_type == "Announce":
        if not ap_activity_to_undo.activity_object_ap_id:
            raise ValueError("Announce witout object")
        announced_obj_ap_id = ap_activity_to_undo.activity_object_ap_id
        logger.info(
            f"Undo for announce {ap_activity_to_undo.ap_id}/{announced_obj_ap_id}"
        )
        if announced_obj_ap_id.startswith(BASE_URL):
            announced_obj_from_outbox = await get_outbox_object_by_ap_id(
                db_session, announced_obj_ap_id
            )
            if announced_obj_from_outbox:
                logger.info("Found in the oubox")
                announced_obj_from_outbox.announces_count = (
                    models.OutboxObject.announces_count - 1
                )
                notif = models.Notification(
                    notification_type=models.NotificationType.UNDO_ANNOUNCE,
                    actor_id=from_actor.id,
                    outbox_object_id=announced_obj_from_outbox.id,
                    inbox_object_id=ap_activity_to_undo.id,
                )
                db_session.add(notif)
    else:
        logger.warning(f"Don't know how to undo {ap_activity_to_undo.ap_type} activity")

    # commit will be perfomed in save_to_inbox


async def _handle_update_activity(
    db_session: AsyncSession,
    from_actor: models.Actor,
    update_activity: models.InboxObject,
) -> None:
    logger.info("Processing Update activity")
    wrapped_object = await ap.get_object(update_activity.ap_object)
    if wrapped_object["type"] in ap.ACTOR_TYPES:
        logger.info("Updating actor")

        updated_actor = RemoteActor(wrapped_object)
        if (
            from_actor.ap_id != updated_actor.ap_id
            or from_actor.ap_type != updated_actor.ap_type
            or from_actor.handle != updated_actor.handle
        ):
            raise ValueError(
                f"Invalid Update activity {from_actor.ap_actor}/"
                f"{updated_actor.ap_actor}"
            )

        # Update the actor
        from_actor.ap_actor = updated_actor.ap_actor
    elif (ap_type := wrapped_object["type"]) in [
        "Question",
        "Note",
        "Article",
        "Page",
        "Video",
    ]:
        logger.info(f"Updating {ap_type}")
        existing_object = await get_inbox_object_by_ap_id(
            db_session, wrapped_object["id"]
        )
        if not existing_object:
            logger.info(f"{ap_type} not found in the inbox")
        elif existing_object.actor.ap_id != from_actor.ap_id:
            logger.warning(
                f"Update actor does not match the {ap_type} actor {from_actor.ap_id}"
                f"/{existing_object.actor.ap_id}"
            )
        else:
            # Everything looks correct, update the object in the inbox
            logger.info(f"Updating {existing_object.ap_id}")
            existing_object.ap_object = wrapped_object
    else:
        # TODO(ts): support updating objects
        logger.info(f'Cannot update {wrapped_object["type"]}')


async def _handle_create_activity(
    db_session: AsyncSession,
    from_actor: models.Actor,
    create_activity: models.InboxObject,
) -> None:
    logger.info("Processing Create activity")
    wrapped_object = ap.unwrap_activity(create_activity.ap_object)
    if create_activity.actor.ap_id != ap.get_actor_id(wrapped_object):
        raise ValueError("Object actor does not match activity")

    ro = RemoteObject(wrapped_object, actor=from_actor)

    # Check if we already received a delete for this object (happens often
    # with forwarded replies)
    delete_object = await get_inbox_delete_for_activity_object_ap_id(
        db_session,
        ro.ap_id,
    )
    if delete_object:
        if delete_object.actor.ap_id != from_actor.ap_id:
            logger.warning(
                f"Got a Delete for {ro.ap_id} from {delete_object.actor.ap_id}??"
            )
        else:
            logger.info("Got a Delete for this object, deleting activity")
            create_activity.is_deleted = True
            await db_session.flush()
            return None

    await _process_note_object(db_session, create_activity, from_actor, ro)


async def _handle_read_activity(
    db_session: AsyncSession,
    from_actor: models.Actor,
    read_activity: models.InboxObject,
) -> None:
    logger.info("Processing Read activity")

    # Honk uses Read activity to propagate replies, fetch the read object
    # from the remote server
    wrapped_object = await ap.fetch(ap.get_id(read_activity.ap_object["object"]))

    wrapped_object_actor = await fetch_actor(
        db_session, ap.get_actor_id(wrapped_object)
    )
    ro = RemoteObject(wrapped_object, actor=wrapped_object_actor)

    # Then process it likes it's coming from a forwarded activity
    await _process_note_object(db_session, read_activity, wrapped_object_actor, ro)


async def _process_note_object(
    db_session: AsyncSession,
    parent_activity: models.InboxObject,
    from_actor: models.Actor,
    ro: RemoteObject,
) -> None:
    if parent_activity.ap_type not in ["Create", "Read"]:
        raise ValueError(f"Unexpected parent activity {parent_activity.ap_id}")

    ap_published_at = now()
    if "published" in ro.ap_object:
        ap_published_at = parse_isoformat(ro.ap_object["published"])

    following = await _get_following(db_session)

    is_from_following = ro.actor.ap_id in {f.ap_actor_id for f in following}
    is_reply = bool(ro.in_reply_to)
    is_local_reply = (
        ro.in_reply_to
        and ro.in_reply_to.startswith(BASE_URL)
        and ro.content  # Hide votes from Question
    )
    is_mention = False
    tags = ro.ap_object.get("tag", [])
    for tag in ap.as_list(tags):
        if tag.get("name") == LOCAL_ACTOR.handle or tag.get("href") == LOCAL_ACTOR.url:
            is_mention = True

    inbox_object = models.InboxObject(
        server=urlparse(ro.ap_id).netloc,
        actor_id=from_actor.id,
        ap_actor_id=from_actor.ap_id,
        ap_type=ro.ap_type,
        ap_id=ro.ap_id,
        ap_context=ro.ap_context,
        ap_published_at=ap_published_at,
        ap_object=ro.ap_object,
        visibility=ro.visibility,
        relates_to_inbox_object_id=parent_activity.id,
        relates_to_outbox_object_id=None,
        activity_object_ap_id=ro.activity_object_ap_id,
        # Hide replies from the stream
        is_hidden_from_stream=not (
            (not is_reply and is_from_following) or is_mention or is_local_reply
        ),
    )

    db_session.add(inbox_object)
    await db_session.flush()
    await db_session.refresh(inbox_object)

    parent_activity.relates_to_inbox_object_id = inbox_object.id

    if inbox_object.in_reply_to:
        replied_object = await get_anybox_object_by_ap_id(
            db_session, inbox_object.in_reply_to
        )
        if replied_object:
            if replied_object.is_from_outbox:
                if replied_object.ap_type == "Question" and inbox_object.ap_object.get(
                    "name"
                ):
                    await _handle_vote_answer(
                        db_session,
                        inbox_object,
                        replied_object,  # type: ignore  # outbox check below
                    )
                else:
                    await db_session.execute(
                        update(models.OutboxObject)
                        .where(
                            models.OutboxObject.id == replied_object.id,
                        )
                        .values(replies_count=models.OutboxObject.replies_count + 1)
                    )
            else:
                await db_session.execute(
                    update(models.InboxObject)
                    .where(
                        models.InboxObject.id == replied_object.id,
                    )
                    .values(replies_count=models.InboxObject.replies_count + 1)
                )

        # This object is a reply of a local object, we may need to forward it
        # to our followers (we can only forward JSON-LD signed activities)
        if (
            parent_activity.ap_type == "Create"
            and replied_object
            and replied_object.is_from_outbox
            and replied_object.ap_type != "Question"
            and parent_activity.has_ld_signature
        ):
            logger.info("Forwarding Create activity as it's a local reply")
            recipients = await _get_followers_recipients(db_session)
            for rcp in recipients:
                await new_outgoing_activity(
                    db_session,
                    rcp,
                    outbox_object_id=None,
                    inbox_object_id=parent_activity.id,
                )

    if is_mention:
        notif = models.Notification(
            notification_type=models.NotificationType.MENTION,
            actor_id=from_actor.id,
            inbox_object_id=inbox_object.id,
        )
        db_session.add(notif)


async def _handle_vote_answer(
    db_session: AsyncSession,
    answer: models.InboxObject,
    question: models.OutboxObject,
) -> None:
    logger.info(f"Processing poll answer for {question.ap_id}: {answer.ap_id}")

    if question.is_poll_ended:
        logger.warning("Poll is ended, discarding answer")
        return

    if not question.poll_items:
        raise ValueError("Should never happen")

    answer_name = answer.ap_object["name"]
    if answer_name not in {pi["name"] for pi in question.poll_items}:
        logger.warning(f"Invalid answer {answer_name=}")
        return

    answer.is_transient = True
    poll_answer = models.PollAnswer(
        outbox_object_id=question.id,
        poll_type="oneOf" if question.is_one_of_poll else "anyOf",
        inbox_object_id=answer.id,
        actor_id=answer.actor.id,
        name=answer_name,
    )
    db_session.add(poll_answer)
    await db_session.flush()

    voters_count = await db_session.scalar(
        select(func.count(func.distinct(models.PollAnswer.actor_id))).where(
            models.PollAnswer.outbox_object_id == question.id
        )
    )

    all_answers = await db_session.execute(
        select(
            func.count(models.PollAnswer.name).label("answer_count"),
            models.PollAnswer.name,
        )
        .where(models.PollAnswer.outbox_object_id == question.id)
        .group_by(models.PollAnswer.name)
    )
    all_answers_count = {a["name"]: a["answer_count"] for a in all_answers}

    logger.info(f"{voters_count=}")
    logger.info(f"{all_answers_count=}")

    question_ap_object = dict(question.ap_object)
    question_ap_object["votersCount"] = voters_count
    items_key = "oneOf" if question.is_one_of_poll else "anyOf"
    question_ap_object[items_key] = [
        {
            "type": "Note",
            "name": item["name"],
            "replies": {
                "type": "Collection",
                "totalItems": all_answers_count.get(item["name"], 0),
            },
        }
        for item in question.poll_items
    ]
    updated = now().replace(microsecond=0).isoformat().replace("+00:00", "Z")
    question_ap_object["updated"] = updated
    question.ap_object = question_ap_object

    logger.info(f"Updated question: {question.ap_object}")

    await db_session.flush()

    # Finally send an update
    recipients = await _compute_recipients(db_session, question.ap_object)
    for rcp in recipients:
        await new_outgoing_activity(db_session, rcp, question.id)


async def _process_transient_object(
    db_session: AsyncSession,
    raw_object: ap.RawObject,
    from_actor: models.Actor,
) -> None:
    ap_type = raw_object["type"]
    if ap_type in ["Add", "Remove"]:
        logger.info(f"Dropping unsupported {ap_type} object")
    else:
        logger.warning(f"Received unknown {ap_type} object")

    return None


async def save_to_inbox(
    db_session: AsyncSession,
    raw_object: ap.RawObject,
    sent_by_ap_actor_id: str,
) -> None:
    try:
        actor = await fetch_actor(db_session, ap.get_id(raw_object["actor"]))
    except httpx.HTTPStatusError:
        logger.exception("Failed to fetch actor")
        return

    if "id" not in raw_object:
        await _process_transient_object(db_session, raw_object, actor)
        return None

    raw_object_id = ap.get_id(raw_object)
    forwarded_by_actor = None

    # Ensure forwarded activities have a valid LD sig
    if sent_by_ap_actor_id != actor.ap_id:
        logger.info(
            f"Processing a forwarded activity {sent_by_ap_actor_id=}/{actor.ap_id}"
        )
        forwarded_by_actor = await fetch_actor(db_session, sent_by_ap_actor_id)

        if not (await ldsig.verify_signature(db_session, raw_object)):
            logger.warning(
                f"Failed to verify LD sig, fetching remote object {raw_object_id}"
            )

            # Try to fetch the remote object since we failed to verify the LD sig
            try:
                raw_object = await ap.fetch(raw_object_id)
            except Exception:
                raise fastapi.HTTPException(status_code=401, detail="Invalid LD sig")

            # Transient activities from Mastodon like Like are not fetchable and
            # will return the actor instead
            if raw_object["id"] != raw_object_id:
                logger.info(f"Unable to fetch {raw_object_id}")
                return None

    if (
        await db_session.scalar(
            select(func.count(models.InboxObject.id)).where(
                models.InboxObject.ap_id == raw_object_id
            )
        )
        > 0
    ):
        logger.info(
            f'Received duplicate {raw_object["type"]} activity: {raw_object_id}'
        )
        return

    ap_published_at = now()
    if "published" in raw_object:
        ap_published_at = parse_isoformat(raw_object["published"])

    activity_ro = RemoteObject(raw_object, actor=actor)

    relates_to_inbox_object: models.InboxObject | None = None
    relates_to_outbox_object: models.OutboxObject | None = None
    if activity_ro.activity_object_ap_id:
        if activity_ro.activity_object_ap_id.startswith(BASE_URL):
            relates_to_outbox_object = await get_outbox_object_by_ap_id(
                db_session,
                activity_ro.activity_object_ap_id,
            )
        else:
            relates_to_inbox_object = await get_inbox_object_by_ap_id(
                db_session,
                activity_ro.activity_object_ap_id,
            )

    inbox_object = models.InboxObject(
        server=urlparse(activity_ro.ap_id).netloc,
        actor_id=actor.id,
        ap_actor_id=actor.ap_id,
        ap_type=activity_ro.ap_type,
        ap_id=activity_ro.ap_id,
        ap_context=activity_ro.ap_context,
        ap_published_at=ap_published_at,
        ap_object=activity_ro.ap_object,
        visibility=activity_ro.visibility,
        relates_to_inbox_object_id=relates_to_inbox_object.id
        if relates_to_inbox_object
        else None,
        relates_to_outbox_object_id=relates_to_outbox_object.id
        if relates_to_outbox_object
        else None,
        activity_object_ap_id=activity_ro.activity_object_ap_id,
        is_hidden_from_stream=True,
    )

    db_session.add(inbox_object)
    await db_session.flush()
    await db_session.refresh(inbox_object)

    if activity_ro.ap_type == "Create":
        await _handle_create_activity(db_session, actor, inbox_object)
    elif activity_ro.ap_type == "Read":
        await _handle_read_activity(db_session, actor, inbox_object)
    elif activity_ro.ap_type == "Update":
        await _handle_update_activity(db_session, actor, inbox_object)
    elif activity_ro.ap_type == "Delete":
        await _handle_delete_activity(
            db_session,
            actor,
            inbox_object,
            relates_to_inbox_object,
            forwarded_by_actor=forwarded_by_actor,
        )
    elif activity_ro.ap_type == "Follow":
        await _handle_follow_follow_activity(db_session, actor, inbox_object)
    elif activity_ro.ap_type == "Undo":
        if relates_to_inbox_object:
            await _handle_undo_activity(
                db_session, actor, inbox_object, relates_to_inbox_object
            )
        else:
            logger.info("Received Undo for an unknown activity")
    elif activity_ro.ap_type in ["Accept", "Reject"]:
        if not relates_to_outbox_object:
            logger.info(
                f"Received {raw_object['type']} for an unknown activity: "
                f"{activity_ro.activity_object_ap_id}"
            )
        else:
            if relates_to_outbox_object.ap_type == "Follow":
                following = models.Following(
                    actor_id=actor.id,
                    outbox_object_id=relates_to_outbox_object.id,
                    ap_actor_id=actor.ap_id,
                )
                db_session.add(following)

                notif_type = (
                    models.NotificationType.FOLLOW_REQUEST_ACCEPTED
                    if activity_ro.ap_type == "Accept"
                    else models.NotificationType.FOLLOW_REQUEST_REJECTED
                )
                notif = models.Notification(
                    notification_type=notif_type,
                    actor_id=actor.id,
                    inbox_object_id=inbox_object.id,
                )
                db_session.add(notif)
            else:
                logger.info(
                    "Received an Accept for an unsupported activity: "
                    f"{relates_to_outbox_object.ap_type}"
                )
    elif activity_ro.ap_type == "EmojiReact":
        if not relates_to_outbox_object:
            logger.info(
                "Received a reaction for an unknown activity: "
                f"{activity_ro.activity_object_ap_id}"
            )
        else:
            # TODO(ts): support reactions
            pass
    elif activity_ro.ap_type == "Like":
        if not relates_to_outbox_object:
            logger.info(
                "Received a like for an unknown activity: "
                f"{activity_ro.activity_object_ap_id}, deleting the activity"
            )
            await db_session.delete(inbox_object)
        else:
            relates_to_outbox_object.likes_count = models.OutboxObject.likes_count + 1

            notif = models.Notification(
                notification_type=models.NotificationType.LIKE,
                actor_id=actor.id,
                outbox_object_id=relates_to_outbox_object.id,
                inbox_object_id=inbox_object.id,
            )
            db_session.add(notif)
    elif activity_ro.ap_type == "Announce":
        if relates_to_outbox_object:
            # This is an announce for a local object
            relates_to_outbox_object.announces_count = (
                models.OutboxObject.announces_count + 1
            )

            notif = models.Notification(
                notification_type=models.NotificationType.ANNOUNCE,
                actor_id=actor.id,
                outbox_object_id=relates_to_outbox_object.id,
                inbox_object_id=inbox_object.id,
            )
            db_session.add(notif)
        else:
            # Only show the announce in the stream if it comes from an actor
            # in the following collection
            followings = await _get_following(db_session)
            is_from_following = inbox_object.actor.ap_id in {
                f.ap_actor_id for f in followings
            }

            # This is announce for a maybe unknown object
            if relates_to_inbox_object:
                # We already know about this object, show the announce in the
                # stream if it's not already there, from an followed actor
                # and if we haven't seen it recently
                if (
                    now()
                    - as_utc(relates_to_inbox_object.ap_published_at)  # type: ignore
                ) > timedelta(hours=1):
                    inbox_object.is_hidden_from_stream = not is_from_following
            else:
                # Save it as an inbox object
                if not activity_ro.activity_object_ap_id:
                    raise ValueError("Should never happen")
                announced_raw_object = await ap.fetch(activity_ro.activity_object_ap_id)
                announced_actor = await fetch_actor(
                    db_session, ap.get_actor_id(announced_raw_object)
                )
                announced_object = RemoteObject(announced_raw_object, announced_actor)
                announced_inbox_object = models.InboxObject(
                    server=urlparse(announced_object.ap_id).netloc,
                    actor_id=announced_actor.id,
                    ap_actor_id=announced_actor.ap_id,
                    ap_type=announced_object.ap_type,
                    ap_id=announced_object.ap_id,
                    ap_context=announced_object.ap_context,
                    ap_published_at=announced_object.ap_published_at,
                    ap_object=announced_object.ap_object,
                    visibility=announced_object.visibility,
                    is_hidden_from_stream=True,
                )
                db_session.add(announced_inbox_object)
                await db_session.flush()
                inbox_object.relates_to_inbox_object_id = announced_inbox_object.id
                inbox_object.is_hidden_from_stream = not is_from_following

    elif activity_ro.ap_type in ["Like", "Announce"]:
        if not relates_to_outbox_object:
            logger.info(
                f"Received {activity_ro.ap_type} for an unknown activity: "
                f"{activity_ro.activity_object_ap_id}"
            )
        else:
            if activity_ro.ap_type == "Like":
                relates_to_outbox_object.likes_count = (
                    models.OutboxObject.likes_count + 1
                )

                notif = models.Notification(
                    notification_type=models.NotificationType.LIKE,
                    actor_id=actor.id,
                    outbox_object_id=relates_to_outbox_object.id,
                    inbox_object_id=inbox_object.id,
                )
                db_session.add(notif)
            elif activity_ro.ap_type == "Announce":
                relates_to_outbox_object.announces_count = (
                    models.OutboxObject.announces_count + 1
                )

                notif = models.Notification(
                    notification_type=models.NotificationType.ANNOUNCE,
                    actor_id=actor.id,
                    outbox_object_id=relates_to_outbox_object.id,
                    inbox_object_id=inbox_object.id,
                )
                db_session.add(notif)
            else:
                raise ValueError("Should never happen")

    else:
        logger.warning(f"Received an unknown {inbox_object.ap_type} object")

    await db_session.commit()


async def public_outbox_objects_count(db_session: AsyncSession) -> int:
    return await db_session.scalar(
        select(func.count(models.OutboxObject.id)).where(
            models.OutboxObject.visibility == ap.VisibilityEnum.PUBLIC,
            models.OutboxObject.is_deleted.is_(False),
        )
    )


async def fetch_actor_collection(db_session: AsyncSession, url: str) -> list[Actor]:
    if url.startswith(config.BASE_URL):
        if url == config.BASE_URL + "/followers":
            followers = (
                (
                    await db_session.scalars(
                        select(models.Follower).options(
                            joinedload(models.Follower.actor)
                        )
                    )
                )
                .unique()
                .all()
            )
            return [follower.actor for follower in followers]
        else:
            raise ValueError(f"internal collection for {url}) not supported")

    return [RemoteActor(actor) for actor in await ap.parse_collection(url)]


@dataclass
class ReplyTreeNode:
    ap_object: AnyboxObject
    children: list["ReplyTreeNode"]
    is_requested: bool = False
    is_root: bool = False


async def get_replies_tree(
    db_session: AsyncSession,
    requested_object: AnyboxObject,
) -> ReplyTreeNode:
    # XXX: PeerTube video don't use context
    tree_nodes: list[AnyboxObject] = []
    if requested_object.ap_context is None:
        tree_nodes = [requested_object]
    else:
        # TODO: handle visibility
        tree_nodes.extend(
            (
                await db_session.scalars(
                    select(models.InboxObject)
                    .where(
                        models.InboxObject.ap_context == requested_object.ap_context,
                        models.InboxObject.ap_type.not_in(["Announce"]),
                        models.InboxObject.is_deleted.is_(False),
                    )
                    .options(joinedload(models.InboxObject.actor))
                )
            )
            .unique()
            .all()
        )
        tree_nodes.extend(
            (
                await db_session.scalars(
                    select(models.OutboxObject)
                    .where(
                        models.OutboxObject.ap_context == requested_object.ap_context,
                        models.OutboxObject.is_deleted.is_(False),
                    )
                    .options(
                        joinedload(
                            models.OutboxObject.outbox_object_attachments
                        ).options(joinedload(models.OutboxObjectAttachment.upload))
                    )
                )
            )
            .unique()
            .all()
        )
    nodes_by_in_reply_to = defaultdict(list)
    for node in tree_nodes:
        nodes_by_in_reply_to[node.in_reply_to].append(node)
    logger.info(nodes_by_in_reply_to)

    if len(nodes_by_in_reply_to.get(None, [])) > 1:
        raise ValueError(f"Invalid replies tree: {[n.ap_object for n in tree_nodes]}")

    def _get_reply_node_children(
        node: ReplyTreeNode,
        index: defaultdict[str | None, list[AnyboxObject]],
    ) -> list[ReplyTreeNode]:
        children = []
        for child in index.get(node.ap_object.ap_id, []):  # type: ignore
            child_node = ReplyTreeNode(
                ap_object=child,
                is_requested=child.ap_id == requested_object.ap_id,  # type: ignore
                children=[],
            )
            child_node.children = _get_reply_node_children(child_node, index)
            children.append(child_node)

        return sorted(
            children,
            key=lambda node: node.ap_object.ap_published_at,  # type: ignore
        )

    if None in nodes_by_in_reply_to:
        root_ap_object = nodes_by_in_reply_to[None][0]
    else:
        root_ap_object = sorted(
            tree_nodes,
            key=lambda ap_obj: ap_obj.ap_published_at,  # type: ignore
        )[0]

    root_node = ReplyTreeNode(
        ap_object=root_ap_object,
        is_root=True,
        is_requested=root_ap_object.ap_id == requested_object.ap_id,
        children=[],
    )
    root_node.children = _get_reply_node_children(root_node, nodes_by_in_reply_to)
    return root_node