"""
E2E Tests for ReceptionistAI Voice Widget.

Tests the widget UI, interactions, and voice connectivity based on:
- /mnt/e/genesis-system/RECEPTIONISTAI/QUICK_START.md
- /mnt/e/genesis-system/RECEPTIONISTAI/widget/demo.html
"""
import pytest
import time
from playwright.sync_api import expect


class TestWidgetBasics:
    """Basic widget rendering and UI tests."""

    def test_widget_page_loads(self, page, widget_url):
        """Verify demo page loads successfully."""
        response = page.goto(f"{widget_url}/demo.html")
        assert response.status == 200, "Demo page failed to load"

        # Check page title
        expect(page).to_have_title("ReceptionistAI Widget Demo")

    def test_widget_ui_renders(self, page, widget_url):
        """Verify widget UI elements are present."""
        page.goto(f"{widget_url}/demo.html")

        # Widget container should be visible
        widget = page.locator('#receptionist-widget')
        expect(widget).to_be_visible()

        # Microphone button should exist
        mic_button = page.locator('button[aria-label*="microphone"], button[aria-label*="call"], .widget-trigger')
        expect(mic_button).to_be_visible()

    def test_widget_button_clickable(self, page, widget_url):
        """Verify widget trigger button is clickable."""
        page.goto(f"{widget_url}/demo.html")

        # Find and click the widget button
        trigger = page.locator('button.widget-trigger, button[aria-label*="call"]').first
        expect(trigger).to_be_enabled()

        trigger.click()

        # Chat interface should appear
        chat_interface = page.locator('.chat-interface, .chat-window, .message-container')
        expect(chat_interface).to_be_visible(timeout=3000)

    def test_text_input_visible(self, page, widget_url):
        """Verify text input field is present."""
        page.goto(f"{widget_url}/demo.html")

        # Open widget
        page.locator('button.widget-trigger, button[aria-label*="call"]').first.click()

        # Text input should be visible
        text_input = page.locator('input[type="text"], textarea, input[placeholder*="message"]')
        expect(text_input).to_be_visible(timeout=3000)

    def test_send_button_present(self, page, widget_url):
        """Verify send button exists."""
        page.goto(f"{widget_url}/demo.html")

        # Open widget
        page.locator('button.widget-trigger, button[aria-label*="call"]').first.click()

        # Send button should exist
        send_button = page.locator('button[aria-label*="send"], button:has-text("Send"), button[type="submit"]')
        expect(send_button).to_be_visible(timeout=3000)


class TestWidgetInteraction:
    """Test user interactions with the widget."""

    def test_text_message_flow(self, page, widget_url):
        """Test sending a text message through the widget."""
        page.goto(f"{widget_url}/demo.html")

        # Open widget
        page.locator('button.widget-trigger, button[aria-label*="call"]').first.click()
        page.wait_for_timeout(1000)

        # Type message
        text_input = page.locator('input[type="text"], textarea, input[placeholder*="message"]').first
        text_input.fill("What are your hours?")

        # Click send
        send_button = page.locator('button[aria-label*="send"], button:has-text("Send"), button[type="submit"]').first
        send_button.click()

        # Wait for response (timeout 10s for API call)
        page.wait_for_timeout(2000)

        # Check for message in chat
        messages = page.locator('.message, .chat-message, [class*="message"]')
        assert messages.count() > 0, "No messages found after sending"

    def test_multiple_messages(self, page, widget_url):
        """Test sending multiple messages in sequence."""
        page.goto(f"{widget_url}/demo.html")

        # Open widget
        page.locator('button.widget-trigger, button[aria-label*="call"]').first.click()
        page.wait_for_timeout(1000)

        test_messages = [
            "What are your hours?",
            "How much does a leak repair cost?",
            "Do you service Bondi?"
        ]

        for msg in test_messages:
            text_input = page.locator('input[type="text"], textarea, input[placeholder*="message"]').first
            text_input.fill(msg)

            send_button = page.locator('button[aria-label*="send"], button:has-text("Send"), button[type="submit"]').first
            send_button.click()

            page.wait_for_timeout(1500)

        # Should have multiple messages
        messages = page.locator('.message, .chat-message, [class*="message"]')
        assert messages.count() >= len(test_messages), "Not all messages appeared"

    def test_lead_capture_message(self, page, widget_url):
        """Test message with phone number (lead capture scenario)."""
        page.goto(f"{widget_url}/demo.html")

        # Open widget
        page.locator('button.widget-trigger, button[aria-label*="call"]').first.click()
        page.wait_for_timeout(1000)

        # Send message with phone number
        text_input = page.locator('input[type="text"], textarea, input[placeholder*="message"]').first
        text_input.fill("My name is Sarah, call me on 0412345678")

        send_button = page.locator('button[aria-label*="send"], button:has-text("Send"), button[type="submit"]').first
        send_button.click()

        page.wait_for_timeout(2000)

        # Message should be sent successfully
        messages = page.locator('.message, .chat-message, [class*="message"]')
        assert messages.count() > 0


class TestWidgetResponsive:
    """Test widget on different screen sizes."""

    def test_mobile_rendering(self, mobile_page, widget_url):
        """Test widget on mobile viewport."""
        mobile_page.goto(f"{widget_url}/demo.html")

        # Widget should be visible on mobile
        widget = mobile_page.locator('#receptionist-widget, .widget-container')
        expect(widget).to_be_visible()

        # Button should be accessible
        trigger = mobile_page.locator('button.widget-trigger, button[aria-label*="call"]').first
        expect(trigger).to_be_visible()

    def test_tablet_rendering(self, tablet_page, widget_url):
        """Test widget on tablet viewport."""
        tablet_page.goto(f"{widget_url}/demo.html")

        # Widget should be visible on tablet
        widget = tablet_page.locator('#receptionist-widget, .widget-container')
        expect(widget).to_be_visible()

        # Button should be accessible
        trigger = tablet_page.locator('button.widget-trigger, button[aria-label*="call"]').first
        expect(trigger).to_be_visible()

    def test_mobile_interaction(self, mobile_page, widget_url):
        """Test full interaction flow on mobile."""
        mobile_page.goto(f"{widget_url}/demo.html")

        # Open widget
        mobile_page.locator('button.widget-trigger, button[aria-label*="call"]').first.click()
        mobile_page.wait_for_timeout(1000)

        # Send message
        text_input = mobile_page.locator('input[type="text"], textarea, input[placeholder*="message"]').first
        text_input.fill("Test mobile message")

        send_button = mobile_page.locator('button[aria-label*="send"], button:has-text("Send")').first
        send_button.click()

        mobile_page.wait_for_timeout(2000)

        # Verify message sent
        messages = mobile_page.locator('.message, .chat-message, [class*="message"]')
        assert messages.count() > 0


class TestWidgetPerformance:
    """Performance and loading tests."""

    def test_page_load_time(self, page, widget_url):
        """Verify page loads in under 3 seconds."""
        start_time = time.time()
        page.goto(f"{widget_url}/demo.html")
        load_time = time.time() - start_time

        assert load_time < 3.0, f"Page load took {load_time:.2f}s (target: <3s)"

    def test_no_console_errors(self, page, widget_url):
        """Verify no JavaScript console errors on load."""
        errors = []

        page.on("console", lambda msg: errors.append(msg) if msg.type == "error" else None)
        page.goto(f"{widget_url}/demo.html")
        page.wait_for_timeout(2000)

        # Filter out known benign errors (e.g., favicon 404)
        critical_errors = [e for e in errors if "favicon" not in e.text.lower()]

        assert len(critical_errors) == 0, f"Console errors found: {[e.text for e in critical_errors]}"

    def test_widget_initialization_speed(self, page, widget_url):
        """Test how quickly widget becomes interactive."""
        start_time = time.time()
        page.goto(f"{widget_url}/demo.html")

        # Wait for widget to be clickable
        trigger = page.locator('button.widget-trigger, button[aria-label*="call"]').first
        trigger.wait_for(state="visible", timeout=5000)

        init_time = time.time() - start_time
        assert init_time < 2.0, f"Widget initialization took {init_time:.2f}s (target: <2s)"


class TestWidgetAccessibility:
    """Accessibility and ARIA compliance tests."""

    def test_keyboard_navigation(self, page, widget_url):
        """Test widget can be opened with keyboard."""
        page.goto(f"{widget_url}/demo.html")

        # Tab to widget button
        page.keyboard.press("Tab")

        # Enter to activate
        page.keyboard.press("Enter")

        # Chat interface should open
        chat_interface = page.locator('.chat-interface, .chat-window, .message-container')
        expect(chat_interface).to_be_visible(timeout=3000)

    def test_aria_labels_present(self, page, widget_url):
        """Verify ARIA labels for screen readers."""
        page.goto(f"{widget_url}/demo.html")

        # Widget button should have aria-label
        trigger = page.locator('button.widget-trigger, button[aria-label]').first
        aria_label = trigger.get_attribute("aria-label")

        assert aria_label is not None, "Widget trigger missing aria-label"
        assert len(aria_label) > 0, "aria-label is empty"


@pytest.mark.skip(reason="Requires microphone permissions and Telnyx WebRTC setup")
class TestVoiceIntegration:
    """Voice call integration tests (requires microphone)."""

    def test_audio_permissions_prompt(self, page, widget_url):
        """Verify audio permissions are requested."""
        page.goto(f"{widget_url}/demo.html")

        # This would trigger permission prompt in real browser
        # Headless mode may not support this
        pass

    def test_telnyx_webrtc_connection(self, page, widget_url):
        """Test connection to Telnyx WebRTC endpoint."""
        # Would require actual Telnyx credentials and WebRTC setup
        pass