"""
Copyright 2024-2026 ReplyPier

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""

import pytest
from unittest.mock import Mock, MagicMock, patch, AsyncMock
from app.models.agent import Agent, AgentType
from app.models.chat_history import ChatHistory
from app.models.workflow import Workflow, WorkflowStatus
from app.models.workflow_node import WorkflowNode, NodeType
from app.models.organization import Organization
from app.models.user import User
from uuid import UUID, uuid4
from app.services.conversation_token import VERIFIED_SCOPE


@pytest.fixture
def test_organization(db):
    """Create a test organization"""
    organization = Organization(
        id=uuid4(),
        name="Test Organization",
        domain="test.com"
    )
    db.add(organization)
    db.commit()
    db.refresh(organization)
    return organization


@pytest.fixture
def test_user(db, test_organization):
    """Create a test user"""
    user = User(
        id=uuid4(),
        email="test@example.com",
        hashed_password="hashed_password",
        is_active=True,
        organization_id=test_organization.id,
        full_name="Test User"
    )
    db.add(user)
    db.commit()
    db.refresh(user)
    return user


@pytest.fixture
def test_agent(db, test_organization):
    """Create a test agent with workflow enabled"""
    agent = Agent(
        id=uuid4(),
        name="Test Agent",
        display_name="Test Agent",
        description="Test agent with workflow",
        agent_type=AgentType.CUSTOMER_SUPPORT,
        instructions=["Test instruction"],
        is_active=True,
        organization_id=test_organization.id,
        use_workflow=True
    )
    db.add(agent)
    db.commit()
    db.refresh(agent)
    return agent


@pytest.fixture
def test_workflow(db, test_organization, test_agent, test_user):
    """Create a test workflow"""
    workflow = Workflow(
        id=uuid4(),
        name="Test Workflow",
        description="Test workflow",
        status=WorkflowStatus.PUBLISHED,
        version=1,
        is_template=False,
        default_language="en",
        canvas_data={
            "nodes": [
                {
                    "id": "start",
                    "type": "start",
                    "data": {"label": "Start"}
                }
            ]
        },
        settings={},
        organization_id=test_organization.id,
        agent_id=test_agent.id,
        created_by=test_user.id
    )
    db.add(workflow)
    db.commit()
    db.refresh(workflow)
    
    # Update agent to use this workflow
    test_agent.active_workflow_id = workflow.id
    db.commit()
    
    return workflow


class TestWidgetChatWorkflow:
    
    def test_agent_has_workflow_enabled(self, test_agent, test_workflow):
        """Test that the agent has workflow properly configured"""
        assert test_agent.use_workflow is True
        assert test_agent.active_workflow_id == test_workflow.id
    
    def test_workflow_is_published(self, test_workflow):
        """Test that the workflow is in published status"""
        assert test_workflow.status == WorkflowStatus.PUBLISHED
        assert test_workflow.canvas_data is not None
        assert "nodes" in test_workflow.canvas_data
    
    @pytest.mark.asyncio
    async def test_workflow_execution_service_mock(self, test_agent, test_workflow):
        """Test that WorkflowExecutionService can be mocked properly"""
        from app.services.workflow_execution import WorkflowExecutionService
        
        with patch.object(WorkflowExecutionService, '__init__', return_value=None), \
             patch.object(WorkflowExecutionService, 'execute_workflow', new_callable=AsyncMock) as mock_execute:
            
            mock_execute.return_value = {
                "success": True,
                "message": "Workflow executed",
                "next_node": None
            }
            
            # Create service instance
            service = WorkflowExecutionService(None)
            
            # Call execute_workflow
            result = await service.execute_workflow(
                session_id="test_session",
                message="Hello",
                agent_id=test_agent.id,
                workflow_id=test_workflow.id
            )
            
            # Verify the mock was called and returned expected result
            mock_execute.assert_called_once()
            assert result["success"] is True
            assert result["message"] == "Workflow executed"
    
    def test_workflow_data_structure(self, test_workflow):
        """Test that workflow has proper data structure"""
        assert isinstance(test_workflow.canvas_data, dict)
        assert "nodes" in test_workflow.canvas_data
        assert len(test_workflow.canvas_data["nodes"]) >= 1
        
        # Check first node structure
        first_node = test_workflow.canvas_data["nodes"][0]
        assert "id" in first_node
        assert "type" in first_node
        assert "data" in first_node
    
    def test_agent_workflow_relationship(self, test_agent, test_workflow):
        """Test the relationship between agent and workflow"""
        assert test_agent.active_workflow_id == test_workflow.id
        assert test_workflow.agent_id == test_agent.id
        assert test_agent.organization_id == test_workflow.organization_id


@pytest.fixture
def one_message_session(db, test_workflow, test_agent, test_customer, test_ai_config, monkeypatch):
    """A widget session on a workflow that is a single MESSAGE node."""
    from app.api import widget_chat
    from app.services import message_delivery
    from app.repositories.session_to_agent import SessionToAgentRepository

    db.add(WorkflowNode(
        id=uuid4(),
        workflow_id=test_workflow.id,
        node_type=NodeType.MESSAGE,
        name="Greeting",
        config={"message_text": "Hello from the workflow"},
    ))
    db.commit()

    session_id = uuid4()
    active_session = SessionToAgentRepository(db).create_session(
        session_id=session_id,
        agent_id=test_agent.id,
        customer_id=test_customer.id,
        organization_id=test_agent.organization_id,
    )
    assert active_session.workflow_id == test_workflow.id

    sio = MagicMock()
    sio.emit = AsyncMock()
    sio.get_session = AsyncMock(return_value={
        "widget_id": str(uuid4()),
        "org_id": str(test_agent.organization_id),
        "agent_id": str(test_agent.id),
        "customer_id": str(test_customer.id),
        "session_id": str(session_id),
        "ai_config": test_ai_config,
        # A keyless session is resumed by a token the embedding app vouched for.
        "conversation_scope": VERIFIED_SCOPE,
    })
    monkeypatch.setattr(widget_chat, "sio", sio)
    monkeypatch.setattr(message_delivery, "sio", sio)
    monkeypatch.setattr(widget_chat, "get_db", lambda: iter([db]))
    monkeypatch.setattr(widget_chat, "notify_new_chat", AsyncMock())
    return sio, str(session_id)


def _chat_responses(sio):
    return [c.args[1]["message"] for c in sio.emit.call_args_list if c.args[0] == "chat_response"]


def _stored_bot_messages(db, session_id):
    return [m.message for m in db.query(ChatHistory).filter(
        ChatHistory.session_id == UUID(session_id), ChatHistory.message_type == "bot").all()]


class TestOneMessageWorkflowIsSentOnce:
    """A workflow ending on a MESSAGE node used to send and store that message
    twice: once as an intermediate message and once as the final reply."""

    @pytest.mark.asyncio
    async def test_on_load(self, db, one_message_session):
        from app.api import widget_chat
        sio, session_id = one_message_session

        await widget_chat.handle_get_workflow_state("test_sid")

        assert _chat_responses(sio) == ["Hello from the workflow"]
        states = [c.args[1] for c in sio.emit.call_args_list if c.args[0] == "workflow_state"]
        assert [(s["type"], s["message"]) for s in states] == [("message", "Hello from the workflow")]
        assert _stored_bot_messages(db, session_id) == ["Hello from the workflow"]

    @pytest.mark.asyncio
    async def test_on_first_message(self, db, one_message_session):
        from app.api import widget_chat
        sio, session_id = one_message_session

        await widget_chat.handle_widget_chat("test_sid", {"message": "hi"})

        assert _chat_responses(sio) == ["Hello from the workflow"]
        assert _stored_bot_messages(db, session_id) == ["Hello from the workflow"]

# Synthetic values are deliberately recognizable in a rendered log message.
_SYNTHETIC_KEY = "sk-f01-synthetic-key-do-not-log"
_SYNTHETIC_NOTE = "f01-private-form-answer"
_SYNTHETIC_EMAIL = "f01-private@example.test"
_SYNTHETIC_STATE = "f01-private-previous-state"


def _rendered_log(caplog):
    import logging

    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
    return "\n".join(formatter.format(record) for record in caplog.records)


@pytest.fixture
def form_logging_session(db, test_workflow, test_agent, test_customer, test_ai_config, monkeypatch):
    """A real SQLite session: FORM -> CONDITION -> GUARDRAILS -> MESSAGE -> LLM."""
    from app.api import widget_chat
    from app.core.security import encrypt_api_key
    from app.models.session_to_agent import SessionToAgent, SessionStatus
    from app.models.workflow_connection import WorkflowConnection
    from app.services import socket_rate_limit

    form = WorkflowNode(id=uuid4(), workflow_id=test_workflow.id, node_type=NodeType.FORM,
                        name="Contact Form", config={"form_fields": [
                            {"name": "email", "type": "email", "label": "Email"},
                            {"name": "note", "type": "text", "label": "Note"},
                        ]})
    condition = WorkflowNode(id=uuid4(), workflow_id=test_workflow.id, node_type=NodeType.CONDITION,
                             name="Condition", config={"condition_expression": "{{contact_form_note}} > 1"})
    guard = WorkflowNode(id=uuid4(), workflow_id=test_workflow.id, node_type=NodeType.GUARDRAILS,
                         name="Guard", config={"enabled_guardrails": ["pii"], "pii_action": "redact",
                                               "text_source": "contact_form_note"})
    message = WorkflowNode(id=uuid4(), workflow_id=test_workflow.id, node_type=NodeType.MESSAGE,
                           name="Message", config={"message_text": "Noted {{contact_form_note}}"})
    model = WorkflowNode(id=uuid4(), workflow_id=test_workflow.id, node_type=NodeType.LLM,
                         name="Model", config={"system_prompt": "Use {{contact_form_email}}",
                                               "exit_condition": "continuous_execution"})
    db.add_all([form, condition, guard, message, model])
    for source, target, label in [(form, condition, None), (condition, guard, "false"),
                                  (guard, message, "pass"), (message, model, None)]:
        db.add(WorkflowConnection(id=uuid4(), workflow_id=test_workflow.id,
                                  source_node_id=source.id, target_node_id=target.id, label=label))
    test_customer.email = "anonymous@noemail.com"
    test_ai_config.encrypted_api_key = encrypt_api_key(_SYNTHETIC_KEY)
    test_ai_config.settings = {"base_url": "https://model.example.test/v1"}
    active = SessionToAgent(session_id=uuid4(), organization_id=test_agent.organization_id,
                            customer_id=test_customer.id, agent_id=test_agent.id,
                            workflow_id=test_workflow.id, current_node_id=form.id,
                            workflow_state={"form_state": "waiting", "variables": {
                                "earlier": {"private": _SYNTHETIC_STATE}}},
                            workflow_history=[], status=SessionStatus.OPEN)
    db.add(active)
    db.commit()
    sio = MagicMock()
    sio.emit = AsyncMock()
    sio.get_session = AsyncMock(return_value={
        "widget_id": str(uuid4()), "org_id": str(test_agent.organization_id),
        "agent_id": str(test_agent.id), "customer_id": str(test_customer.id),
        "session_id": str(active.session_id), "ai_config": test_ai_config,
        "conversation_scope": VERIFIED_SCOPE, "source": "widget",
    })
    monkeypatch.setattr(widget_chat, "sio", sio)
    monkeypatch.setattr(socket_rate_limit, "sio", sio)
    monkeypatch.setattr(widget_chat, "get_db", lambda: iter([db]))
    return active, form, model, sio


@pytest.mark.asyncio
@pytest.mark.parametrize("duplicate_email", [False, True])
async def test_form_submission_keeps_secrets_out_of_rendered_logs(
    db, test_organization, test_customer, test_ai_config, form_logging_session, duplicate_email,
    caplog, monkeypatch,
):
    import logging
    from app.api import widget_chat
    from app.models.customer import Customer
    from app.models.schemas.chat import ChatResponse
    from app.services import workflow_execution

    active, form, model, sio = form_logging_session
    if duplicate_email:
        db.add(Customer(id=uuid4(), organization_id=test_organization.id,
                        email=_SYNTHETIC_EMAIL, full_name="Other"))
        db.commit()
    agent = MagicMock()
    agent._get_llm_response_only = AsyncMock(return_value=ChatResponse(
        message=f"Reply {_SYNTHETIC_NOTE}", transfer_to_human=False, end_chat=False,
        request_rating=False, create_ticket=False,
    ))
    agent.safe_cleanup_mcp_tools = AsyncMock()
    create_agent = AsyncMock(return_value=agent)
    monkeypatch.setattr(workflow_execution.ChatAgent, "create_async", create_agent)
    session_id = str(active.session_id)
    caplog.set_level(logging.DEBUG)
    caplog.clear()

    await widget_chat.handle_form_submission("sid-f01", {"form_data": {
        "email": _SYNTHETIC_EMAIL, "note": _SYNTHETIC_NOTE,
    }})

    assert _chat_responses(sio) == [f"Noted {_SYNTHETIC_NOTE}", f"Reply {_SYNTHETIC_NOTE}"]
    assert sorted(_stored_bot_messages(db, session_id)) == sorted(_chat_responses(sio))
    assert any(c.args[0] == "form_submitted" and c.args[1]["success"] for c in sio.emit.call_args_list)
    db.refresh(active)
    db.refresh(test_customer)
    assert test_customer.email == ("anonymous@noemail.com" if duplicate_email else _SYNTHETIC_EMAIL)
    assert active.current_node_id == model.id
    assert active.workflow_state["variables"][str(form.id)] == {
        "contact_form_email": _SYNTHETIC_EMAIL, "contact_form_note": _SYNTHETIC_NOTE,
    }
    assert active.workflow_history[-1]["data"] == {"email": _SYNTHETIC_EMAIL, "note": _SYNTHETIC_NOTE}
    kwargs = create_agent.await_args.kwargs
    assert kwargs["api_key"] == _SYNTHETIC_KEY
    assert kwargs["model_name"] == test_ai_config.model_name
    assert kwargs["model_type"] == test_ai_config.model_type
    assert kwargs["custom_system_prompt"] == f"Use {_SYNTHETIC_EMAIL}"
    assert kwargs["session_id"] == session_id
    assert kwargs["base_url"] == "https://model.example.test/v1"
    assert kwargs["org_id"] == str(test_organization.id)
    assert kwargs["customer_id"] == str(test_customer.id)
    assert kwargs["agent_id"] == str(active.agent_id)
    assert kwargs["source"] == "widget"
    assert _SYNTHETIC_NOTE in agent._get_llm_response_only.await_args.kwargs["message"]
    agent.safe_cleanup_mcp_tools.assert_awaited_once()

    logs = _rendered_log(caplog)
    for secret in (_SYNTHETIC_KEY, _SYNTHETIC_NOTE, _SYNTHETIC_EMAIL, _SYNTHETIC_STATE):
        assert secret not in logs
    assert session_id in logs and str(form.id) in logs and str(model.id) in logs
    assert "form" in logs.lower()


@pytest.mark.asyncio
@pytest.mark.parametrize("case", ["missing", "unexpected", "exception"])
async def test_form_submission_failure_logs_identifiers_not_sensitive_inputs(case, caplog):
    import logging
    from app.services.workflow_execution import WorkflowExecutionService

    service = WorkflowExecutionService(Mock())
    node_id = uuid4()
    session_id = "f01-failure-session"
    workflow_id = uuid4()
    error = f"database failed while handling {_SYNTHETIC_NOTE} and {_SYNTHETIC_KEY}"
    service.session_repo.get_session = Mock(
        side_effect=RuntimeError(error) if case == "exception" else None,
        return_value=Mock(workflow_state={"form_state": "not-waiting", "private": _SYNTHETIC_STATE},
                          current_node_id=node_id) if case == "unexpected" else None,
    )
    service.execute_workflow = AsyncMock()
    caplog.set_level(logging.DEBUG)
    caplog.clear()
    result = await service.submit_form(session_id, {"note": _SYNTHETIC_NOTE}, workflow_id,
                                       api_key=_SYNTHETIC_KEY)
    expected = {"missing": "Session not found", "unexpected": "No form submission expected",
                "exception": error}[case]
    assert result.success is False and result.error == expected
    service.execute_workflow.assert_not_awaited()
    logs = _rendered_log(caplog)
    for secret in (_SYNTHETIC_KEY, _SYNTHETIC_NOTE, _SYNTHETIC_STATE):
        assert secret not in logs
    assert session_id in logs and str(workflow_id) in logs
    assert any(record.levelno >= logging.WARNING for record in caplog.records)
    if case == "unexpected":
        assert str(node_id) in logs
    if case == "exception":
        assert "RuntimeError" in logs


def test_landing_page_interpolation_does_not_log_submitted_values(caplog):
    import logging
    from app.services.workflow_execution import WorkflowExecutionService

    service = WorkflowExecutionService(Mock())
    node = Mock(spec=WorkflowNode)
    node.id = uuid4()
    node.config = {"landing_page_heading": "Hello", "landing_page_content": "Saved {{note}}"}
    state = {"variables": {"form": {"note": _SYNTHETIC_NOTE}}}
    caplog.set_level(logging.DEBUG)
    caplog.clear()
    result = service._execute_landing_page_node(node, state)
    assert result.landing_page_data == {"heading": "Hello", "content": f"Saved {_SYNTHETIC_NOTE}"}
    logs = _rendered_log(caplog)
    assert _SYNTHETIC_NOTE not in logs
    assert str(node.id) in logs


@pytest.mark.parametrize("operation", ["update", "history"])
def test_form_state_persistence_failure_logs_no_database_parameters(
    db, form_logging_session, caplog, monkeypatch, operation,
):
    import logging
    from app.repositories.session_to_agent import SessionToAgentRepository

    active, form, _, _ = form_logging_session
    session_id = str(active.session_id)
    repository = SessionToAgentRepository(db)
    monkeypatch.setattr(db, "commit", Mock(side_effect=RuntimeError(f"database error: {_SYNTHETIC_NOTE}")))
    caplog.set_level(logging.DEBUG)
    caplog.clear()
    if operation == "update":
        result = repository.update_workflow_state(session_id, form.id, {"secret": _SYNTHETIC_NOTE})
    else:
        result = repository.add_workflow_history_entry(session_id, form.id, "form_submission", {"note": _SYNTHETIC_NOTE})
    assert result is False
    logs = _rendered_log(caplog)
    assert _SYNTHETIC_NOTE not in logs
    assert session_id in logs and "RuntimeError" in logs


@pytest.mark.asyncio
async def test_model_failure_does_not_log_form_data_or_api_key(
    db, form_logging_session, caplog, monkeypatch,
):
    import logging
    from app.api import widget_chat
    from app.services import workflow_execution

    active, form, model, sio = form_logging_session
    error = f"model refused {_SYNTHETIC_NOTE} with {_SYNTHETIC_KEY}"
    monkeypatch.setattr(workflow_execution.ChatAgent, "create_async", AsyncMock(side_effect=RuntimeError(error)))
    session_id = str(active.session_id)
    caplog.set_level(logging.DEBUG)
    caplog.clear()
    await widget_chat.handle_form_submission("sid-f01", {"form_data": {
        "email": _SYNTHETIC_EMAIL, "note": _SYNTHETIC_NOTE,
    }})
    errors = [c.args[1] for c in sio.emit.call_args_list if c.args[0] == "error"]
    assert errors == [{"error": error, "type": "form_error"}]
    assert not any(c.args[0] == "form_submitted" for c in sio.emit.call_args_list)
    logs = _rendered_log(caplog)
    for secret in (_SYNTHETIC_KEY, _SYNTHETIC_NOTE, _SYNTHETIC_EMAIL, _SYNTHETIC_STATE):
        assert secret not in logs
    assert session_id in logs and str(form.id) in logs and str(model.id) in logs
    assert "RuntimeError" in logs


def test_form_email_lookup_database_failure_does_not_log_parameters(caplog):
    import logging
    from app.repositories.customer import CustomerRepository

    db = Mock()
    db.query.side_effect = RuntimeError(f"database lookup failed: {_SYNTHETIC_EMAIL}")
    caplog.set_level(logging.DEBUG)
    caplog.clear()
    assert CustomerRepository(db).get_customer_by_email(_SYNTHETIC_EMAIL, uuid4()) is None
    logs = _rendered_log(caplog)
    assert _SYNTHETIC_EMAIL not in logs and "RuntimeError" in logs


@pytest.mark.asyncio
@pytest.mark.parametrize("error_type", [ValueError, RuntimeError])
async def test_widget_form_exception_logs_type_without_exception_contents(
    form_logging_session, caplog, monkeypatch, error_type,
):
    import logging
    from app.api import widget_chat

    _, _, _, sio = form_logging_session
    detail = f"failed with {_SYNTHETIC_KEY} and {_SYNTHETIC_NOTE}"
    monkeypatch.setattr(widget_chat, "_own_session", Mock(side_effect=error_type(detail)))
    caplog.set_level(logging.DEBUG)
    caplog.clear()
    await widget_chat.handle_form_submission("sid-f01", {"form_data": {"note": _SYNTHETIC_NOTE}})

    emitted = [call.args[1] for call in sio.emit.call_args_list if call.args[0] == "error"]
    assert emitted == [{"error": detail if error_type is ValueError else "Failed to submit form",
                        "type": "form_error"}]
    logs = _rendered_log(caplog)
    assert _SYNTHETIC_KEY not in logs and _SYNTHETIC_NOTE not in logs
    assert "sid-f01" in logs and error_type.__name__ in logs