""" testing models """
from unittest.mock import patch
from io import BytesIO
import pathlib
import re

from django.http import Http404
from django.core.files.base import ContentFile
from django.db import IntegrityError
from django.contrib.auth.models import AnonymousUser
from django.test import TestCase
from django.utils import timezone
from PIL import Image
import responses

from bookwyrm import activitypub, models, settings


# pylint: disable=too-many-public-methods
# pylint: disable=line-too-long
@patch("bookwyrm.models.Status.broadcast")
@patch("bookwyrm.activitystreams.add_status_task.delay")
@patch("bookwyrm.activitystreams.remove_status_task.delay")
class Status(TestCase):
    """lotta types of statuses"""

    def setUp(self):
        """useful things for creating a status"""
        with patch("bookwyrm.suggested_users.rerank_suggestions_task.delay"), patch(
            "bookwyrm.activitystreams.populate_stream_task.delay"
        ):
            self.local_user = models.User.objects.create_user(
                "mouse", "mouse@mouse.mouse", "mouseword", local=True, localname="mouse"
            )
        with patch("bookwyrm.models.user.set_remote_server.delay"):
            self.remote_user = models.User.objects.create_user(
                "rat",
                "rat@rat.com",
                "ratword",
                local=False,
                remote_id="https://example.com/users/rat",
                inbox="https://example.com/users/rat/inbox",
                outbox="https://example.com/users/rat/outbox",
            )
        self.book = models.Edition.objects.create(title="Test Edition")

        image_file = pathlib.Path(__file__).parent.joinpath(
            "../../static/images/default_avi.jpg"
        )
        image = Image.open(image_file)
        output = BytesIO()
        with patch("bookwyrm.models.Status.broadcast"):
            image.save(output, format=image.format)
            self.book.cover.save("test.jpg", ContentFile(output.getvalue()))

        self.anonymous_user = AnonymousUser
        self.anonymous_user.is_authenticated = False

    def test_status_generated_fields(self, *_):
        """setting remote id"""
        status = models.Status.objects.create(content="bleh", user=self.local_user)
        expected_id = f"https://{settings.DOMAIN}/user/mouse/status/{status.id}"
        self.assertEqual(status.remote_id, expected_id)
        self.assertEqual(status.privacy, "public")

    def test_replies(self, *_):
        """get a list of replies"""
        parent = models.Status(content="hi", user=self.local_user)
        parent.save(broadcast=False)
        child = models.Status(
            content="hello", reply_parent=parent, user=self.local_user
        )
        child.save(broadcast=False)
        sibling = models.Review(
            content="hey", reply_parent=parent, user=self.local_user, book=self.book
        )
        sibling.save(broadcast=False)
        grandchild = models.Status(
            content="hi hello", reply_parent=child, user=self.local_user
        )
        grandchild.save(broadcast=False)

        replies = models.Status.replies(parent)
        self.assertEqual(replies.count(), 2)
        self.assertEqual(replies.first(), child)
        # should select subclasses
        self.assertIsInstance(replies.last(), models.Review)

        self.assertEqual(parent.thread_id, parent.id)
        self.assertEqual(child.thread_id, parent.id)
        self.assertEqual(sibling.thread_id, parent.id)
        self.assertEqual(grandchild.thread_id, parent.id)

    def test_status_type(self, *_):
        """class name"""
        self.assertEqual(models.Status().status_type, "Note")
        self.assertEqual(models.Review().status_type, "Review")
        self.assertEqual(models.Quotation().status_type, "Quotation")
        self.assertEqual(models.Comment().status_type, "Comment")
        self.assertEqual(models.Boost().status_type, "Announce")

    def test_boostable(self, *_):
        """can a status be boosted, based on privacy"""
        self.assertTrue(models.Status(privacy="public").boostable)
        self.assertTrue(models.Status(privacy="unlisted").boostable)
        self.assertFalse(models.Status(privacy="followers").boostable)
        self.assertFalse(models.Status(privacy="direct").boostable)

    def test_to_replies(self, *_):
        """activitypub replies collection"""
        parent = models.Status.objects.create(content="hi", user=self.local_user)
        child = models.Status.objects.create(
            content="hello", reply_parent=parent, user=self.local_user
        )
        models.Review.objects.create(
            content="hey", reply_parent=parent, user=self.local_user, book=self.book
        )
        models.Status.objects.create(
            content="hi hello", reply_parent=child, user=self.local_user
        )

        replies = parent.to_replies()
        self.assertEqual(replies["id"], f"{parent.remote_id}/replies")
        self.assertEqual(replies["totalItems"], 2)

    def test_status_to_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Status.objects.create(
            content="test content", user=self.local_user
        )
        activity = status.to_activity()
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Note")
        self.assertEqual(activity["content"], "test content")
        self.assertEqual(activity["sensitive"], False)

    def test_status_to_activity_tombstone(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Status.objects.create(
            content="test content",
            user=self.local_user,
            deleted=True,
            deleted_date=timezone.now(),
        )
        activity = status.to_activity()
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Tombstone")
        self.assertFalse(hasattr(activity, "content"))

    def test_status_to_pure_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Status.objects.create(
            content="test content", user=self.local_user
        )
        activity = status.to_activity(pure=True)
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Note")
        self.assertEqual(activity["content"], "test content")
        self.assertEqual(activity["sensitive"], False)
        self.assertEqual(activity["attachment"], [])

    def test_generated_note_to_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.GeneratedNote.objects.create(
            content="test content", user=self.local_user
        )
        status.mention_books.set([self.book])
        status.mention_users.set([self.local_user])
        activity = status.to_activity()
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "GeneratedNote")
        self.assertEqual(activity["content"], "test content")
        self.assertEqual(activity["sensitive"], False)
        self.assertEqual(len(activity["tag"]), 2)

    def test_generated_note_to_pure_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.GeneratedNote.objects.create(
            content="test content", user=self.local_user
        )
        status.mention_books.set([self.book])
        status.mention_users.set([self.local_user])
        activity = status.to_activity(pure=True)
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(
            activity["content"],
            f'mouse test content <a href="{self.book.remote_id}">"Test Edition"</a>',
        )
        self.assertEqual(len(activity["tag"]), 2)
        self.assertEqual(activity["type"], "Note")
        self.assertEqual(activity["sensitive"], False)
        self.assertIsInstance(activity["attachment"], list)
        self.assertEqual(activity["attachment"][0].type, "Document")
        self.assertTrue(
            re.match(
                r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
                activity["attachment"][0].url,
            )
        )
        self.assertEqual(activity["attachment"][0].name, "Test Edition")

    def test_comment_to_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Comment.objects.create(
            content="test content", user=self.local_user, book=self.book
        )
        activity = status.to_activity()
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Comment")
        self.assertEqual(activity["content"], "test content")
        self.assertEqual(activity["inReplyToBook"], self.book.remote_id)

    def test_comment_to_pure_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Comment.objects.create(
            content="test content", user=self.local_user, book=self.book
        )
        activity = status.to_activity(pure=True)
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Note")
        self.assertEqual(
            activity["content"],
            f'test content<p>(comment on <a href="{self.book.remote_id}">"Test Edition"</a>)</p>',
        )
        self.assertEqual(activity["attachment"][0].type, "Document")
        self.assertTrue(
            re.match(
                r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
                activity["attachment"][0].url,
            )
        )
        self.assertEqual(activity["attachment"][0].name, "Test Edition")

    def test_quotation_to_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Quotation.objects.create(
            quote="a sickening sense",
            content="test content",
            user=self.local_user,
            book=self.book,
        )
        activity = status.to_activity()
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Quotation")
        self.assertEqual(activity["quote"], "a sickening sense")
        self.assertEqual(activity["content"], "test content")
        self.assertEqual(activity["inReplyToBook"], self.book.remote_id)

    def test_quotation_to_pure_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Quotation.objects.create(
            quote="a sickening sense",
            content="test content",
            user=self.local_user,
            book=self.book,
        )
        activity = status.to_activity(pure=True)
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Note")
        self.assertEqual(
            activity["content"],
            f'a sickening sense <p>-- <a href="{self.book.remote_id}">"Test Edition"</a></p>test content',
        )
        self.assertEqual(activity["attachment"][0].type, "Document")
        self.assertTrue(
            re.match(
                r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
                activity["attachment"][0].url,
            )
        )
        self.assertEqual(activity["attachment"][0].name, "Test Edition")

    def test_review_to_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Review.objects.create(
            name="Review name",
            content="test content",
            rating=3.0,
            user=self.local_user,
            book=self.book,
        )
        activity = status.to_activity()
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Review")
        self.assertEqual(activity["rating"], 3)
        self.assertEqual(activity["name"], "Review name")
        self.assertEqual(activity["content"], "test content")
        self.assertEqual(activity["inReplyToBook"], self.book.remote_id)

    def test_review_to_pure_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Review.objects.create(
            name="Review's name",
            content="test content",
            rating=3.0,
            user=self.local_user,
            book=self.book,
        )
        activity = status.to_activity(pure=True)
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Article")
        self.assertEqual(
            activity["name"],
            f'Review of "{self.book.title}" (3 stars): Review\'s name',
        )
        self.assertEqual(activity["content"], "test content")
        self.assertEqual(activity["attachment"][0].type, "Document")
        self.assertTrue(
            re.match(
                r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
                activity["attachment"][0].url,
            )
        )
        self.assertEqual(activity["attachment"][0].name, "Test Edition")

    def test_review_to_pure_activity_no_rating(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.Review.objects.create(
            name="Review name",
            content="test content",
            user=self.local_user,
            book=self.book,
        )
        activity = status.to_activity(pure=True)
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Article")
        self.assertEqual(
            activity["name"], f'Review of "{self.book.title}": Review name'
        )
        self.assertEqual(activity["content"], "test content")
        self.assertEqual(activity["attachment"][0].type, "Document")
        self.assertTrue(
            re.match(
                r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
                activity["attachment"][0].url,
            )
        )
        self.assertEqual(activity["attachment"][0].name, "Test Edition")

    def test_reviewrating_to_pure_activity(self, *_):
        """subclass of the base model version with a "pure" serializer"""
        status = models.ReviewRating.objects.create(
            rating=3.0,
            user=self.local_user,
            book=self.book,
        )
        activity = status.to_activity(pure=True)
        self.assertEqual(activity["id"], status.remote_id)
        self.assertEqual(activity["type"], "Note")
        self.assertEqual(
            activity["content"],
            f'rated <em><a href="{self.book.remote_id}">{self.book.title}</a></em>: 3 stars',
        )
        self.assertEqual(activity["attachment"][0].type, "Document")
        self.assertTrue(
            re.match(
                r"https:\/\/your.domain.here\/images\/covers\/test_[A-z0-9]+.jpg",
                activity["attachment"][0].url,
            )
        )
        self.assertEqual(activity["attachment"][0].name, "Test Edition")

    def test_favorite(self, *_):
        """fav a status"""
        status = models.Status.objects.create(
            content="test content", user=self.local_user
        )

        with patch("bookwyrm.models.Favorite.broadcast") as mock:
            fav = models.Favorite.objects.create(status=status, user=self.local_user)
        args = mock.call_args[0]
        self.assertEqual(args[1].remote_id, self.local_user.remote_id)
        self.assertEqual(args[0]["type"], "Like")

        # can't fav a status twice
        with self.assertRaises(IntegrityError):
            models.Favorite.objects.create(status=status, user=self.local_user)

        activity = fav.to_activity()
        self.assertEqual(activity["type"], "Like")
        self.assertEqual(activity["actor"], self.local_user.remote_id)
        self.assertEqual(activity["object"], status.remote_id)

    def test_boost(self, *_):
        """boosting, this one's a bit fussy"""
        status = models.Status.objects.create(
            content="test content", user=self.local_user
        )
        boost = models.Boost.objects.create(boosted_status=status, user=self.local_user)
        activity = boost.to_activity()
        self.assertEqual(activity["actor"], self.local_user.remote_id)
        self.assertEqual(activity["object"], status.remote_id)
        self.assertEqual(activity["type"], "Announce")
        self.assertEqual(activity, boost.to_activity(pure=True))

    def test_notification(self, *_):
        """a simple model"""
        notification = models.Notification.objects.create(
            user=self.local_user, notification_type="FAVORITE"
        )
        self.assertFalse(notification.read)

        with self.assertRaises(IntegrityError):
            models.Notification.objects.create(
                user=self.local_user, notification_type="GLORB"
            )

    # pylint: disable=unused-argument
    def test_create_broadcast(self, one, two, broadcast_mock, *_):
        """should send out two verions of a status on create"""
        models.Comment.objects.create(
            content="hi", user=self.local_user, book=self.book
        )
        self.assertEqual(broadcast_mock.call_count, 2)
        pure_call = broadcast_mock.call_args_list[0]
        bw_call = broadcast_mock.call_args_list[1]

        self.assertEqual(pure_call[1]["software"], "other")
        args = pure_call[0][0]
        self.assertEqual(args["type"], "Create")
        self.assertEqual(args["object"]["type"], "Note")
        self.assertTrue("content" in args["object"])

        self.assertEqual(bw_call[1]["software"], "bookwyrm")
        args = bw_call[0][0]
        self.assertEqual(args["type"], "Create")
        self.assertEqual(args["object"]["type"], "Comment")

    def test_recipients_with_mentions(self, *_):
        """get recipients to broadcast a status"""
        status = models.GeneratedNote.objects.create(
            content="test content", user=self.local_user
        )
        status.mention_users.add(self.remote_user)

        self.assertEqual(status.recipients, [self.remote_user])

    def test_recipients_with_reply_parent(self, *_):
        """get recipients to broadcast a status"""
        parent_status = models.GeneratedNote.objects.create(
            content="test content", user=self.remote_user
        )
        status = models.GeneratedNote.objects.create(
            content="test content", user=self.local_user, reply_parent=parent_status
        )

        self.assertEqual(status.recipients, [self.remote_user])

    def test_recipients_with_reply_parent_and_mentions(self, *_):
        """get recipients to broadcast a status"""
        parent_status = models.GeneratedNote.objects.create(
            content="test content", user=self.remote_user
        )
        status = models.GeneratedNote.objects.create(
            content="test content", user=self.local_user, reply_parent=parent_status
        )
        status.mention_users.set([self.remote_user])

        self.assertEqual(status.recipients, [self.remote_user])

    @responses.activate
    def test_ignore_activity_boost(self, *_):
        """don't bother with most remote statuses"""
        activity = activitypub.Announce(
            id="http://www.faraway.com/boost/12",
            actor=self.remote_user.remote_id,
            object="http://fish.com/nothing",
            published="2021-03-24T18:59:41.841208+00:00",
            cc="",
            to="",
        )

        responses.add(responses.GET, "http://fish.com/nothing", status=404)

        self.assertTrue(models.Status.ignore_activity(activity))

    def test_raise_visible_to_user_public(self, *_):
        """privacy settings"""
        status = models.Status.objects.create(
            content="bleh", user=self.local_user, privacy="public"
        )
        self.assertIsNone(status.raise_visible_to_user(self.remote_user))
        self.assertIsNone(status.raise_visible_to_user(self.local_user))
        self.assertIsNone(status.raise_visible_to_user(self.anonymous_user))

    def test_raise_visible_to_user_unlisted(self, *_):
        """privacy settings"""
        status = models.Status.objects.create(
            content="bleh", user=self.local_user, privacy="unlisted"
        )
        self.assertIsNone(status.raise_visible_to_user(self.remote_user))
        self.assertIsNone(status.raise_visible_to_user(self.local_user))
        self.assertIsNone(status.raise_visible_to_user(self.anonymous_user))

    @patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
    def test_raise_visible_to_user_followers(self, *_):
        """privacy settings"""
        status = models.Status.objects.create(
            content="bleh", user=self.local_user, privacy="followers"
        )
        status.raise_visible_to_user(self.local_user)
        with self.assertRaises(Http404):
            status.raise_visible_to_user(self.remote_user)
        with self.assertRaises(Http404):
            status.raise_visible_to_user(self.anonymous_user)

        self.local_user.followers.add(self.remote_user)
        self.assertIsNone(status.raise_visible_to_user(self.remote_user))

    def test_raise_visible_to_user_followers_mentioned(self, *_):
        """privacy settings"""
        status = models.Status.objects.create(
            content="bleh", user=self.local_user, privacy="followers"
        )
        status.mention_users.set([self.remote_user])
        self.assertIsNone(status.raise_visible_to_user(self.remote_user))

    @patch("bookwyrm.suggested_users.rerank_suggestions_task.delay")
    def test_raise_visible_to_user_direct(self, *_):
        """privacy settings"""
        status = models.Status.objects.create(
            content="bleh", user=self.local_user, privacy="direct"
        )
        status.raise_visible_to_user(self.local_user)
        with self.assertRaises(Http404):
            status.raise_visible_to_user(self.remote_user)
        with self.assertRaises(Http404):
            status.raise_visible_to_user(self.anonymous_user)

        # mentioned user
        status.mention_users.set([self.remote_user])
        self.assertIsNone(status.raise_visible_to_user(self.remote_user))