"""Tests for network participant logic."""

from unittest.mock import patch

import participant.constants.network_participant_queries as q
import pytest
from owsresponse import response
from participant.logic import network_participant as network_participant_logic
from participant.models import base as base_models
from participant.utils.convert import format_response

mock_network_participant_response = {
    'name': 'A name',
    'id': 1,
    'network_id': 123,
}


@pytest.fixture
def get_nodes_mock(mocker):
    """Mock get_nodes function."""
    return mocker.patch.object(
        base_models,
        'get_nodes',
        return_value=[mock_network_participant_response],
        autospec=True,
    )


@pytest.fixture
def get_node_mock(mocker):
    """Mock get_node function."""
    return mocker.patch.object(
        base_models,
        'get_node',
        return_value=mock_network_participant_response,
        autospec=True,
    )


@pytest.fixture
def create_node_mock(mocker):
    """Mock create_node function."""
    return mocker.patch.object(
        base_models,
        'create_node',
        return_value=mock_network_participant_response,
        autospec=True,
    )


@pytest.fixture
def update_node_mock(mocker):
    """Mock update_node function."""
    return mocker.patch.object(
        base_models,
        'update_node',
        return_value=mock_network_participant_response,
        autospec=True,
    )


def test_search_network_participant(get_nodes_mock):
    """Test network_search_participant function."""
    name = ' A name '
    network_id = 123

    result = network_participant_logic.search_network_participant(name, network_id)
    name = name.strip()
    base_models.get_nodes.assert_called_once_with(
        q.search_network_participant,
        wildcard_query=f'{name}*',
        network_id=network_id,
    )
    assert result.message == format_response([mock_network_participant_response])


def test_create_network_participant(create_node_mock):
    """Test create_network_participant function."""
    name = 'A name'
    network_id = 123

    result = network_participant_logic.create_network_participant(name, network_id)

    base_models.create_node.assert_called_once_with(
        q.create_network_participant,
        name=name,
        network_id=network_id,
    )
    assert result.message == format_response(mock_network_participant_response)


def test_update_network_participant(update_node_mock):
    """Test update_network_participant function."""
    network_participant_id = 1
    network_id = 1
    params = {'name': 'Updated name'}

    result = network_participant_logic.update_network_participant(
        network_participant_id, network_id, params
    )

    base_models.update_node.assert_called_once_with(
        q.update_network_participant,
        id=network_participant_id,
        network_id=network_id,
        update_params=params,
    )
    assert result.message == format_response(mock_network_participant_response)


def test_get_network_participant_by_id(get_node_mock):
    """Test get_network_participant_by_id function."""
    network_participant_id = 1

    result = network_participant_logic.get_network_participant_by_id(
        network_participant_id
    )

    base_models.get_node.assert_called_once_with(
        q.get_network_participant_by_id,
        id=network_participant_id,
    )
    assert result.message == format_response(mock_network_participant_response)


@patch('participant.models.ows.ows_podcast.current_user_owns_network_id')
def test_current_user_owns_network_id(podcast_model_mock):
    """Test current_user_owns_network_id function."""
    podcast_model_mock.return_value = response.Response({'authorized': True})
    result = network_participant_logic.current_user_owns_network_id(1)
    assert result.status == response.status.OK
    assert result.message == {'authorized': True}
    podcast_model_mock.assert_called_once_with(1)