"""Tests for processor module."""

from unittest.mock import MagicMock, patch

import httpx
from owsclient.test import OwsClientMock

import config
from reserves_take.constants.snowflake import GET_TRANSACTIONS_SQL
from reserves_take.processor import ReservesTakeProcessor


def test_set_statement_period(
    mock_accounting_run_response,
    mock_accounting_period_response,
    mock_event,
    ows_client_mock: OwsClientMock,
):
    """Test _set_statement_period method."""
    processor = ReservesTakeProcessor(event=mock_event)
    accounting_run_id = int(mock_event['target_id'])
    accounting_period_id = mock_accounting_run_response['accounting_period_id']

    ows_client_mock.get(
        'ows-royalties',
        f'/accounting-run/{accounting_run_id}',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_accounting_run_response
        )
    )

    ows_client_mock.get(
        'ows-royalties',
        f'/accounting-period/{accounting_period_id}',
    ).mock(
        return_value=httpx.Response(
            200,
            json=mock_accounting_period_response
        )
    )

    assert processor._accounting_run_id == accounting_run_id
    assert processor._event == mock_event
    assert processor._statement_period_id is None

    processor._set_statement_period()
    assert processor._statement_period_id == mock_accounting_period_response[
        'statement_period_id'
    ]


@patch('reserves_take.processor.SnowflakeSQLExecutor')
@patch('reserves_take.processor.get_formatted_query')
def test_get_transactions(mock_get_query, mock_sf_executor, mock_event):
    """Test for _get_transactions method."""
    executor_instance = MagicMock()
    executor_instance.fetchall.return_value = 'Data'
    mock_get_query.return_value = 'formatted query'
    mock_sf_executor.return_value.__enter__.return_value = executor_instance
    processor = ReservesTakeProcessor(event=mock_event)
    result = processor._get_transactions()
    mock_sf_executor.assert_called_once_with(config.SNOWFLAKE_CONFIG)
    executor_instance.fetchall.assert_called_once_with(
        'formatted query', dict_cursor=True)
    assert result == 'Data'
    mock_get_query.assert_called_once_with(
        GET_TRANSACTIONS_SQL,
        {'accounting_run_id': int(mock_event['target_id'])}
    )


@patch('reserves_take.processor.chunk_post_payload')
@patch('reserves_take.processor.get_contract_ids_by_accounting_run')
@patch('reserves_take.processor.get_contract_reserve_by_contract_ids_royalties')
@patch('reserves_take.processor.bulk_create_ledger_reserve_taken_entries')
@patch('reserves_take.processor.bulk_create_ledger_deposit_entries')
def test_process(
    create_ledger_deposit_entries_mock,
    create_reserve_taken_entries_mock,
    get_contract_reserves_mock,
    get_contract_ids_mock,
    mock_chunk_payload,
    mock_sales_transactions_response,
    mock_contract_reserves_response,
    mock_contract_ids_response,
    mock_ledger_reserve_taken_body,
    mock_ledger_deposit_body,
    mock_event
):
    """Test process method."""
    ReservesTakeProcessor._get_transactions = MagicMock(
        return_value=mock_sales_transactions_response)
    ReservesTakeProcessor._set_statement_period = MagicMock()
    get_contract_reserves_mock.return_value = mock_contract_reserves_response
    get_contract_ids_mock.return_value = mock_contract_ids_response
    mock_chunk_payload.side_effect = [
        mock_ledger_reserve_taken_body,
        mock_ledger_deposit_body
    ]

    processor = ReservesTakeProcessor(event=mock_event)
    processor.process()

    get_contract_ids_mock.assert_called_once_with(int(mock_event['target_id']))
    get_contract_reserves_mock.assert_called_once_with(mock_contract_ids_response)
    processor._set_statement_period.assert_called_once()
    create_ledger_deposit_entries_mock.assert_called_once()
    create_reserve_taken_entries_mock.assert_called_once()