"""Unit tests for tasks for handling overall feed status in DynamoDB."""

from unittest.mock import MagicMock, call
from unittest.mock import patch

import boto3
import freezegun
from garcon import activity
from garcon_contrib.dynamo_feed_status import \
    garcon_feed_status

from feed_ingestion.tasks import overall_status_tasks


@patch.object(overall_status_tasks.garcon_feed_status, 'set_overall_status')
@freezegun.freeze_time('2024-12-31T12:59:59.1234', tz_offset=0)
def test_set_overall_status_enhanced(set_overall_status_mock):
    activity = MagicMock()
    activity.context = {
        'execution.domain': 'test_domain',
        'execution.run_id': 'test_run_id',
        'execution.workflow_id': 'test_workflow_id',
        'context_date': '2015-01-01',
    }

    overall_status_tasks.set_overall_status_enhanced(
        'feeder', '2015-01-01', 'INGESTED', activity)

    assert set_overall_status_mock.call_args_list == [
        call(
            'feeder', '2015-01-01', 'INGESTED',
            attributes={
                'updated_at': '2024-12-31T12:59:59Z',
                'swf_domain': 'test_domain',
                'swf_run_id': 'test_run_id',
                'swf_workflow_id': 'test_workflow_id'
            })
    ]


def test_advance_overall_status_downloaded(monkeypatch):
    """Test advance_overall_status if current status is DOWNLOADED."""
    monkeypatch.setattr(
        garcon_feed_status, 'set_overall_status', MagicMock(
            return_value=None))

    # Test if current status is downloaded
    monkeypatch.setattr(
        garcon_feed_status, 'get_overall_status', MagicMock(
            return_value=garcon_feed_status.STATUS_DOWNLOADED))
    overall_status_tasks.advance_overall_status(
        activity.Activity(boto3.client('swf', 'us-east-1')),
        '2015-01-01', 'feeder')
    garcon_feed_status.set_overall_status.assert_called_with(
        'feeder', '2015-01-01', garcon_feed_status.STATUS_POPULATED_RAW_TABLE)


def test_advance_overall_status_not_available(monkeypatch):
    """Test advance_overall_status if current status is NOT_AVAILABLE."""
    monkeypatch.setattr(
        garcon_feed_status, 'set_overall_status', MagicMock(
            return_value=None))

    # test if current status is not available
    monkeypatch.setattr(
        garcon_feed_status, 'get_overall_status', MagicMock(
            return_value=garcon_feed_status.STATUS_NOT_AVAILABLE))
    overall_status_tasks.advance_overall_status(
        activity.Activity(boto3.client('swf', 'us-east-1')),
        '2015-01-01', 'feeder')
    garcon_feed_status.set_overall_status.assert_called_with(
        'feeder', '2015-01-01')


def test_advance_overall_status_ingested(monkeypatch):
    """Test advance_overall_status if current status is INGESTED."""
    monkeypatch.setattr(
        garcon_feed_status, 'set_overall_status', MagicMock(
            return_value=None))

    # test if current status is ingested
    monkeypatch.setattr(
        garcon_feed_status, 'get_overall_status', MagicMock(
            return_value=garcon_feed_status.STATUS_INGESTED))
    overall_status_tasks.advance_overall_status(
        activity.Activity(boto3.client('swf', 'us-east-1')),
        'feeder', '2015-01-01')
    assert not garcon_feed_status.set_overall_status.called


@patch('feed_ingestion.tasks.overall_status_tasks.task_status')
@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
@freezegun.freeze_time('2024-12-31', tz_offset=0)
def test_set_overall_status(mock_feed_status, mock_task_status):
    """Test set_overall_status."""
    overall_status_tasks.set_overall_status(
        activity.Activity(boto3.client('swf', 'us-east-1')),
        '2012-12-21', 'feed', 'INGESTED')
    kwargs = dict(
        attributes={'updated_at': '2024-12-31T00:00:00Z'}
    )
    mock_feed_status.set_overall_status.assert_called_with(
        'feed', '2012-12-21', 'INGESTED',
        **kwargs)


@patch('feed_ingestion.tasks.overall_status_tasks.task_status')
@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
@freezegun.freeze_time('2024-12-31', tz_offset=0)
def test_set_overall_status_set_status_once(
        mock_feed_status, mock_task_status):
    """Test set_overall_status with set_status_once param."""
    # task completed and set_status_once=True
    mock_task_status.is_completed_task.return_value = True
    overall_status_tasks.set_overall_status(
        activity.Activity(boto3.client('swf', 'us-east-1')),
        '2012-12-21', 'feed', 'INGESTED', True)
    assert mock_feed_status.set_overall_status.call_count == 0

    mock_feed_status.reset_mock()
    mock_task_status.reset_mock()

    # task completed and set_status_once=False
    overall_status_tasks.set_overall_status(
        activity.Activity(boto3.client('swf', 'us-east-1')),
        '2012-12-21', 'feed', 'INGESTED', False)
    kwargs = dict(
        attributes={'updated_at': '2024-12-31T00:00:00Z'}
    )
    mock_feed_status.set_overall_status.assert_called_with(
        'feed', '2012-12-21', 'INGESTED',
        **kwargs)
    mock_task_status.mark_completed_task.assert_called_with(
        'feed', '2012-12-21', 'set_overall_status_INGESTED')

    mock_feed_status.reset_mock()
    mock_task_status.reset_mock()

    # task not completed and set_status_once=True
    mock_task_status.is_completed_task.return_value = False
    overall_status_tasks.set_overall_status(
        activity.Activity(boto3.client('swf', 'us-east-1')),
        '2012-12-21', 'feed', 'INGESTED', True)
    kwargs = dict(
        attributes={'updated_at': '2024-12-31T00:00:00Z'}
    )
    mock_feed_status.set_overall_status.assert_called_with(
        'feed', '2012-12-21', 'INGESTED',
        **kwargs)
    mock_task_status.mark_completed_task.assert_called_with(
        'feed', '2012-12-21', 'set_overall_status_INGESTED')


@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
def test_delete_overall_status(mock_feed_status):
    """Test delete_overall_status task."""
    overall_status_tasks.delete_overall_status(
        MagicMock(), 'test', '2018-12-01')
    mock_feed_status.delete_status.assert_called_with('2018-12-01', 'test')


@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
def test_check_feed_status(mock_feed_status):
    """Test check_feed_status task."""
    result = overall_status_tasks.check_feed_status(
        MagicMock(), 'feed', '2018-12-01', None, 'licensor')
    mock_feed_status.get_overall_status.assert_called_with(
        'feed_licensor', '2018-12-01')
    assert result == {'feed_name': 'feed_licensor'}


@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
def test_check_feed_status_with_reload(mock_feed_status):
    """Test check_feed_status task with reload."""
    result = overall_status_tasks.check_feed_status(
        MagicMock(), 'feed', '2018-12-01', 'True', 'licensor')
    mock_feed_status.delete_status.assert_called_with(
        'feed_licensor', '2018-12-01')
    assert result == {'feed_name': 'feed_licensor'}


def test_check_feed_status_already_ingested(monkeypatch):
    """Test check_feed_status task if status is already ingested."""
    monkeypatch.setattr(
        garcon_feed_status, 'get_overall_status', MagicMock(
            return_value=garcon_feed_status.STATUS_INGESTED))
    result = overall_status_tasks.check_feed_status(
        MagicMock(), 'feed', '2018-12-01', None, 'licensor')
    assert result == {'stop': True}


@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
def test_check_feed_status_with_report(mock_feed_status):
    """Test check_feed_status task with licensor and report."""
    result = overall_status_tasks.check_feed_status(
        MagicMock(), 'feed', '2018-12-01', 'True', 'licensor', 'report1')
    mock_feed_status.delete_status.assert_called_with(
        'feed_licensor_report1', '2018-12-01')
    assert result == {'feed_name': 'feed_licensor_report1'}


@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
def test_check_feed_status_only_report(mock_feed_status):
    """Test check_feed_status task with only report (no licensor)."""
    result = overall_status_tasks.check_feed_status(
        MagicMock(), 'feed', '2018-12-01', None, None, 'report1')
    mock_feed_status.get_overall_status.assert_called_with(
        'feed_report1', '2018-12-01')
    assert result == {'feed_name': 'feed_report1'}


@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
def test_check_feed_status_no_licensor_no_report(mock_feed_status):
    """Test check_feed_status task with no licensor and no report."""
    result = overall_status_tasks.check_feed_status(
        MagicMock(), 'feed', '2018-12-01', None, None, None)
    mock_feed_status.get_overall_status.assert_called_with(
        'feed', '2018-12-01')
    assert result == {'feed_name': 'feed'}


@patch('feed_ingestion.tasks.overall_status_tasks.garcon_feed_status')
def test_check_feed_status_with_report_and_reload(mock_feed_status):
    """Test check_feed_status task with report and reload."""
    result = overall_status_tasks.check_feed_status(
        MagicMock(), 'feed', '2018-12-01', 'True', 'licensor', 'report1')
    mock_feed_status.delete_status.assert_called_with(
        'feed_licensor_report1', '2018-12-01')
    assert result == {'feed_name': 'feed_licensor_report1'}