#!/usr/bin/env python3
from typing import Any
import uuid

from sqlalchemy.orm import session

from app import models
from app.database import AsyncSession
from app.models import InboxObject, OutboxObject, now
from app.activitypub import ME
from app.activitypub import handle_visibility
from app.config import MANUALLY_APPROVES_FOLLOWERS
from app.config import BASE_URL
from app.models import Actor
from app.actor import fetch_actor

import app.activitypub as ap

from urllib.parse import urlparse
from sqlalchemy import select
from sqlalchemy import delete
from sqlalchemy.orm import joinedload
from sqlalchemy.exc import  IntegrityError
from loguru import logger
from uuid import uuid4



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


def build_object_id(id) -> str:
    return f"{BASE_URL}/tail/{id}"


async def save_incoming(
        db_session: AsyncSession,
        payload: dict,
) -> models.IncomingActivity | None:
    ap_id: str
    if "@context" not in payload:
        logger.warning(f"invalid object: {payload}")
        return None

    if "id" in payload:
        ap_id = payload["id"]
    else:
        ap_id = str(uuid4())

    incoming_activity = models.IncomingActivity(
        ap_id=ap_id,
        ap_object=payload,
    )

    if await process_incoming(db_session, payload):
        await db_session.commit()
        await db_session.flush()
        return incoming_activity

    db_session.add(incoming_activity)
    await db_session.commit()
    await db_session.refresh(incoming_activity)
    return incoming_activity


async def process_incoming(
        db_session: AsyncSession,
        ap_object: dict,
) -> bool:
    actor = await fetch_actor(db_session, ap_object["actor"])

    def build_object(
            object,
            relates_to_inbox_object_id = None,
            relates_to_outbox_object_id = None,
    ) -> InboxObject:
        inbox_object = models.InboxObject(
            actor_id=actor.id,
            server=urlparse(object["id"]).hostname,
            is_hidden_from_stream=True,
            ap_actor_id=actor.ap_id,
            ap_type=object["type"],
            ap_id=object["id"],
            ap_published_at=now(),
            ap_object=object,
            visibility=handle_visibility(object),
            activity_object_ap_id=object["actor"],
            relates_to_inbox_object_id=relates_to_inbox_object_id,
            relates_to_outbox_object_id=relates_to_outbox_object_id,
        )
        return inbox_object

    if "Follow" == ap_object["type"]:
        inbox_object = build_object(ap_object)
        db_session.add(inbox_object)
        await db_session.flush()
        await db_session.refresh(inbox_object)

        if await _handle_follow(db_session, actor, inbox_object):
            return True
        return False
    elif "Undo" == ap_object["type"]:
        #inbox_object = build_object(ap_object)
        #db_session.add(inbox_object)
        if await _handle_undo(db_session, ap_object):
            return True
    elif ap_object["type"] in ["Accept", "Rejact"]:
        relate_following_object = (await db_session.execute(
            select(models.OutboxObject)
            .where(models.OutboxObject.ap_id == ap_object["object"])
            .options(
               joinedload(models.OutboxObject.relates_to_inbox_object).options(
                   joinedload(models.InboxObject.actor)
               )
            )
        )
        ).unique().scalar_one_or_none()

        if "Accept" == ap_object["type"]:
            inbox_object = build_object(ap_object)
            db_session.add(inbox_object)
            await db_session.flush()
            await db_session.refresh(inbox_object)

            following = models.Following(
                actor_id=relate_following_object.relates_to_actor.id, #type: ignore
                outbox_object_id=relate_following_object.id, #type: ignore
                ap_actor_id=ap_object["actor"], #type: ignore
            )

            db_session.add(following)
            await db_session.flush()
            await db_session.refresh(following)
            return True

    return False


async def _handle_follow(
        db_session : AsyncSession,
        actor : Actor,
        inbox_object : InboxObject,
) -> bool:
    if ME["id"] != inbox_object.ap_object["object"]: #type: ignore
        # await db_session.delete(ap_object)
        logger.warning("no match follow object!" + inbox_object.ap_object["id"]) #type: ignore
        return False

    if MANUALLY_APPROVES_FOLLOWERS:
        # TODO
        return False

    await _send_accept(db_session, actor, inbox_object)
    return True


async def _send_accept(
        db_session: AsyncSession,
        actor : Actor,
        inbox_object : InboxObject,
) -> None :
    follower = models.Follower(
        actor_id=inbox_object.actor_id,
        inbox_object_id=inbox_object.id,
        ap_actor_id=inbox_object.ap_object["actor"], #type: ignore
    )

    try:
        db_session.add(follower)
        await db_session.flush()
    except IntegrityError:
        await db_session.rollback()
        logger.warning("existing follower in db!")

    reply_id = allocate_outbox_id()

    url = actor.inbox_url # type: ignore
    out = {
        "@context": ap.AS_CTX,
        "id": build_object_id(reply_id),
        "type": "Accept",
        "actor": ME["id"],
        "object": inbox_object.ap_object["id"], #type: ignore
    }
    #TODO outcoming
    await ap.post(url, out) # type: ignore


async def _handle_undo(
        db_session : AsyncSession,
        inbox_object : dict
) -> bool:
    if inbox_object["object"]["object"] != ME["id"]:
        logger.warning("Wrong undo object! "
                       + inbox_object["object"]["actor"])
        return False

    if "Follow" == inbox_object["object"]["type"]:
        relate_object = (await db_session.execute(
            select(models.InboxObject)
            .where(models.InboxObject.ap_id == inbox_object["object"]["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

        if relate_object:
            relate_object.undo_id=inbox_object["object"]["id"]
            relate_object.is_deleted=True

        await db_session.execute(
            delete(models.Follower).where(
                models.Follower.ap_actor_id == inbox_object["actor"]
            )
        )
        logger.info("undo follow " + inbox_object["actor"])
        return True

    return False


async def send_follow(
        db_session : AsyncSession,
        acct : str
):
    await _send_follow(db_session, acct)
    await db_session.commit()
    await db_session.flush()


async def _send_follow(
        db_session : AsyncSession,
        actor_url : str,
):
    actor = await fetch_actor(db_session, actor_url)

    follow_id = build_object_id(allocate_outbox_id())
    out = {
        "@context": ap.AS_CTX,
        "id": follow_id,
        "type": "Follow",
        "actor": ME["id"],
        "object": actor.ap_id,
    }

    await save_to_outbox(
        db_session,
        follow_id,
        out,
        relates_to_actor_id=actor.id, # type: ignore
    )

    await ap.post(
        actor.inbox_url,
        out,
    )


async def save_to_inbox(
        db_session : AsyncSession,
        inbox_id : str,
        ap_object : dict,
        relates_to_inbox_object_id: int | None = None,
        relates_to_outbox_object_id: int | None = None,
        relates_to_actor_id: int | None = None,
) -> InboxObject:

    ap_type = ap_object["type"]
    ap_id = ap_object["id"]
    visibility = handle_visibility(ap_object)

    inbox_object = OutboxObject(
        public_id=inbox_id,
        ap_object=ap_object,
        ap_id=ap_id,
        ap_type=ap_type,
        visibility =visibility,
        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,
    )

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

    return inbox_object


async def save_to_outbox(
        db_session : AsyncSession,
        outbox_id : str,
        ap_object : dict,
        relates_to_inbox_object_id: int | None = None,
        relates_to_outbox_object_id: int | None = None,
        relates_to_actor_id: int | None = None,
) -> OutboxObject:
    ap_type = ap_object["type"]
    ap_id = ap_object["id"]
    visibility = handle_visibility(ap_object)

    outbox_object = OutboxObject(
        public_id=outbox_id,
        ap_object=ap_object,
        ap_id=ap_id,
        ap_type=ap_type,
        visibility =visibility,
        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,
    )

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

    return outbox_object