import unittest
from datetime import datetime

from sia.web_io_buffer import WebIOBuffer
from sia.write_entry import WriteEntry

class WriteEntryTest(unittest.TestCase):
    def setUp(self):
        """Set up test cases with fixed id, timestamp, and IO buffer"""
        self.test_id = "test-id-1234"
        self.test_timestamp = datetime(2024, 10, 31, 12, 0, 0)
        self.io_buffer = WebIOBuffer()
        
    def test_initialization(self):
        """Test entry initialization"""
        content = "test message"
        entry = WriteEntry(content, self.io_buffer, self.test_id, self.test_timestamp)
        
        self.assertEqual(entry.content, content)
        self.assertEqual(entry.id, self.test_id)
        self.assertEqual(entry.timestamp, self.test_timestamp)
        self.assertFalse(entry._written)
        self.assertEqual(self.io_buffer.get_stdout(), "")
        
    def test_single_write(self):
        """Test writing content once"""
        content = "test message"
        entry = WriteEntry(content, self.io_buffer, self.test_id, self.test_timestamp)
        
        # Perform update and verify content was written
        entry.update()
        self.assertEqual(self.io_buffer.get_stdout(), content)
        self.assertTrue(entry._written)
        
    def test_multiple_updates(self):
        """Test that content is only written once even with multiple updates"""
        content = "test message"
        entry = WriteEntry(content, self.io_buffer, self.test_id, self.test_timestamp)
        
        # Perform multiple updates
        entry.update()
        initial_output = self.io_buffer.get_stdout()
        self.io_buffer.clear_stdout()
        
        entry.update()
        entry.update()
        
        # Verify no additional content was written
        self.assertEqual(self.io_buffer.get_stdout(), "")
        self.assertTrue(entry._written)
        self.assertEqual(initial_output, content)
        
    def test_empty_content(self):
        """Test writing empty content"""
        entry = WriteEntry("", self.io_buffer, self.test_id, self.test_timestamp)
        entry.update()
        
        self.assertEqual(self.io_buffer.get_stdout(), "")
        self.assertTrue(entry._written)
        
    def test_special_characters(self):
        """Test writing content with special characters"""
        content = "Special chars: \n\t\r\'\"\\"
        entry = WriteEntry(content, self.io_buffer, self.test_id, self.test_timestamp)
        entry.update()
        
        self.assertEqual(self.io_buffer.get_stdout(), content)
        
    def test_large_content(self):
        """Test writing large content"""
        content = "x" * 10000
        entry = WriteEntry(content, self.io_buffer, self.test_id, self.test_timestamp)
        entry.update()
        
        self.assertEqual(self.io_buffer.get_stdout(), content)
        
    def test_generate_context(self):
        """Test XML context generation"""
        content = "test message"
        entry = WriteEntry(content, self.io_buffer, self.test_id, self.test_timestamp)
        
        # Generate context before writing
        element = entry.generate_context()
        
        # Verify XML structure
        self.assertEqual(element.tag, "write_stdout")
        self.assertEqual(element.get("id"), self.test_id)
        self.assertEqual(element.text, f"{content}")
        
        # Write content and verify context remains the same
        entry.update()
        element_after = entry.generate_context()
        self.assertEqual(element_after.tag, "write_stdout")
        self.assertEqual(element_after.get("id"), self.test_id)
        self.assertEqual(element_after.text, f"{content}")
        
    def test_unicode_content(self):
        """Test writing Unicode content"""
        content = "Hello 世界 😊"
        entry = WriteEntry(content, self.io_buffer, self.test_id, self.test_timestamp)
        entry.update()
        
        self.assertEqual(self.io_buffer.get_stdout(), content)
        
    def test_multiline_content(self):
        """Test writing multiline content"""
        content = """Line 1
        Line 2
        Line 3"""
        entry = WriteEntry(content, self.io_buffer, self.test_id, self.test_timestamp)
        entry.update()
        
        self.assertEqual(self.io_buffer.get_stdout(), content)
        
        # Verify XML escaping for multiline content
        element = entry.generate_context()
        self.assertEqual(element.text, f"{content}")