"""Integration tests for Mastodon RSS Bot"""
import unittest
from unittest.mock import Mock, patch
import tempfile
import os
import time
from bot import MastodonRSSBot
import responses
import feedparser


class TestRSSFeedIntegration(unittest.TestCase):
    """Integration tests for RSS feed parsing"""

    def setUp(self):
        """Set up test fixtures"""
        self.test_config = {
            'client_id': 'test_client_id',
            'client_secret': 'test_client_secret',
            'access_token': 'test_access_token',
            'instance_url': 'https://mastodon.test',
            'feed_url': 'https://example.com/feed.xml',
            'toot_visibility': 'public',
            'check_interval': 1,
            'state_file': tempfile.mktemp()
        }

    def tearDown(self):
        """Clean up test files"""
        if os.path.exists(self.test_config['state_file']):
            os.remove(self.test_config['state_file'])

    @responses.activate
    @patch('bot.Mastodon')
    def test_end_to_end_rss_to_mastodon(self, mock_mastodon):
        """Test complete flow from RSS feed to Mastodon post"""
        # Mock RSS feed response
        rss_feed = """<?xml version="1.0" encoding="UTF-8"?>
        <rss version="2.0">
            <channel>
                <title>Test Feed</title>
                <link>https://example.com</link>
                <description>Test RSS Feed</description>
                <item>
                    <title>First Article</title>
                    <link>https://example.com/article1</link>
                    <description>This is the first article</description>
                </item>
                <item>
                    <title>Second Article</title>
                    <link>https://example.com/article2</link>
                    <description>This is the second article</description>
                </item>
            </channel>
        </rss>"""

        responses.add(
            responses.GET,
            'https://example.com/feed.xml',
            body=rss_feed,
            status=200,
            content_type='application/xml'
        )

        # Mock Mastodon instance
        mock_instance = Mock()
        mock_mastodon.return_value = mock_instance

        # Create bot and process entries
        bot = MastodonRSSBot(**self.test_config)
        count = bot.process_new_entries()

        # Verify results
        self.assertEqual(count, 2)
        self.assertEqual(mock_instance.status_post.call_count, 2)

        # Verify the content of posts
        calls = mock_instance.status_post.call_args_list
        self.assertIn('First Article', calls[0][0][0])
        self.assertIn('https://example.com/article1', calls[0][0][0])
        self.assertIn('Second Article', calls[1][0][0])
        self.assertIn('https://example.com/article2', calls[1][0][0])

    @responses.activate
    @patch('bot.Mastodon')
    def test_atom_feed_parsing(self, mock_mastodon):
        """Test parsing Atom feeds"""
        atom_feed = """<?xml version="1.0" encoding="UTF-8"?>
        <feed xmlns="http://www.w3.org/2005/Atom">
            <title>Test Atom Feed</title>
            <link href="https://example.com"/>
            <updated>2024-01-01T00:00:00Z</updated>
            <entry>
                <title>Atom Article</title>
                <link href="https://example.com/atom1"/>
                <id>https://example.com/atom1</id>
                <updated>2024-01-01T00:00:00Z</updated>
                <summary>This is an atom article</summary>
            </entry>
        </feed>"""

        responses.add(
            responses.GET,
            'https://example.com/feed.xml',
            body=atom_feed,
            status=200,
            content_type='application/atom+xml'
        )

        mock_instance = Mock()
        mock_mastodon.return_value = mock_instance

        bot = MastodonRSSBot(**self.test_config)
        count = bot.process_new_entries()

        self.assertEqual(count, 1)
        calls = mock_instance.status_post.call_args_list
        self.assertIn('Atom Article', calls[0][0][0])

    @responses.activate
    @patch('bot.Mastodon')
    def test_persistence_across_runs(self, mock_mastodon):
        """Test that processed entries persist across multiple bot runs"""
        rss_feed = """<?xml version="1.0" encoding="UTF-8"?>
        <rss version="2.0">
            <channel>
                <title>Test Feed</title>
                <item>
                    <title>Article 1</title>
                    <link>https://example.com/1</link>
                </item>
            </channel>
        </rss>"""

        responses.add(
            responses.GET,
            'https://example.com/feed.xml',
            body=rss_feed,
            status=200,
            content_type='application/xml'
        )

        mock_instance = Mock()
        mock_mastodon.return_value = mock_instance

        # First run - should post the article
        bot1 = MastodonRSSBot(**self.test_config)
        count1 = bot1.process_new_entries()
        self.assertEqual(count1, 1)

        # Second run - should NOT post again (already processed)
        bot2 = MastodonRSSBot(**self.test_config)
        count2 = bot2.process_new_entries()
        self.assertEqual(count2, 0)

        # Total posts should be 1
        self.assertEqual(mock_instance.status_post.call_count, 1)

    @responses.activate
    @patch('bot.Mastodon')
    def test_incremental_feed_updates(self, mock_mastodon):
        """Test handling of new entries added to feed over time"""
        # Initial feed with 2 articles
        initial_feed = """<?xml version="1.0" encoding="UTF-8"?>
        <rss version="2.0">
            <channel>
                <title>Test Feed</title>
                <item>
                    <title>Article 1</title>
                    <link>https://example.com/1</link>
                </item>
                <item>
                    <title>Article 2</title>
                    <link>https://example.com/2</link>
                </item>
            </channel>
        </rss>"""

        responses.add(
            responses.GET,
            'https://example.com/feed.xml',
            body=initial_feed,
            status=200,
            content_type='application/xml'
        )

        mock_instance = Mock()
        mock_mastodon.return_value = mock_instance

        # First run
        bot = MastodonRSSBot(**self.test_config)
        count1 = bot.process_new_entries()
        self.assertEqual(count1, 2)

        # Update feed with 1 new article
        responses.reset()
        updated_feed = """<?xml version="1.0" encoding="UTF-8"?>
        <rss version="2.0">
            <channel>
                <title>Test Feed</title>
                <item>
                    <title>Article 3</title>
                    <link>https://example.com/3</link>
                </item>
                <item>
                    <title>Article 2</title>
                    <link>https://example.com/2</link>
                </item>
                <item>
                    <title>Article 1</title>
                    <link>https://example.com/1</link>
                </item>
            </channel>
        </rss>"""

        responses.add(
            responses.GET,
            'https://example.com/feed.xml',
            body=updated_feed,
            status=200,
            content_type='application/xml'
        )

        # Second run - should only post the new article
        count2 = bot.process_new_entries()
        self.assertEqual(count2, 1)

        # Verify only 3 total posts
        self.assertEqual(mock_instance.status_post.call_count, 3)

    @responses.activate
    @patch('bot.Mastodon')
    def test_network_error_handling(self, mock_mastodon):
        """Test handling of network errors when fetching feed"""
        responses.add(
            responses.GET,
            'https://example.com/feed.xml',
            body="Network error",
            status=500
        )

        mock_instance = Mock()
        mock_mastodon.return_value = mock_instance

        bot = MastodonRSSBot(**self.test_config)
        count = bot.process_new_entries()

        # Should handle error gracefully
        self.assertEqual(count, 0)
        self.assertEqual(mock_instance.status_post.call_count, 0)

    @responses.activate
    @patch('bot.Mastodon')
    def test_malformed_xml_handling(self, mock_mastodon):
        """Test handling of malformed XML feeds"""
        malformed_feed = """<?xml version="1.0" encoding="UTF-8"?>
        <rss version="2.0">
            <channel>
                <title>Broken Feed
                <item>
                    <title>Article</title>
        """  # Intentionally malformed

        responses.add(
            responses.GET,
            'https://example.com/feed.xml',
            body=malformed_feed,
            status=200,
            content_type='application/xml'
        )

        mock_instance = Mock()
        mock_mastodon.return_value = mock_instance

        bot = MastodonRSSBot(**self.test_config)
        # Should handle malformed feed gracefully
        count = bot.process_new_entries()

        # feedparser is lenient and may parse some entries
        # The important thing is it doesn't crash
        self.assertIsInstance(count, int)


class TestMastodonAPIIntegration(unittest.TestCase):
    """Integration tests for Mastodon API interaction"""

    def setUp(self):
        """Set up test fixtures"""
        self.test_config = {
            'client_id': 'test_client_id',
            'client_secret': 'test_client_secret',
            'access_token': 'test_access_token',
            'instance_url': 'https://mastodon.test',
            'feed_url': 'https://example.com/feed.xml',
            'toot_visibility': 'public',
            'check_interval': 1,
            'state_file': tempfile.mktemp()
        }

    def tearDown(self):
        """Clean up test files"""
        if os.path.exists(self.test_config['state_file']):
            os.remove(self.test_config['state_file'])

    @patch('bot.Mastodon')
    def test_different_visibility_levels(self, mock_mastodon):
        """Test posting with different visibility levels"""
        mock_instance = Mock()
        mock_mastodon.return_value = mock_instance

        visibility_levels = ['public', 'unlisted', 'private', 'direct']

        for visibility in visibility_levels:
            self.test_config['toot_visibility'] = visibility
            bot = MastodonRSSBot(**self.test_config)
            bot.post_to_mastodon("Test status")

        # Verify all visibility levels were used
        calls = mock_instance.status_post.call_args_list
        for idx, visibility in enumerate(visibility_levels):
            self.assertEqual(calls[idx][1]['visibility'], visibility)

    @patch('bot.Mastodon')
    def test_retry_on_rate_limit(self, mock_mastodon):
        """Test that rate limit errors are handled appropriately"""
        from mastodon import MastodonRatelimitError

        mock_instance = Mock()
        # First call raises rate limit error, second succeeds
        mock_instance.status_post.side_effect = [
            MastodonRatelimitError("Rate limited"),
            None
        ]
        mock_mastodon.return_value = mock_instance

        bot = MastodonRSSBot(**self.test_config)

        # First attempt should fail
        result1 = bot.post_to_mastodon("Test status")
        self.assertFalse(result1)

        # Second attempt should succeed
        result2 = bot.post_to_mastodon("Test status")
        self.assertTrue(result2)


if __name__ == '__main__':
    unittest.main()