# pylint: disable=redefined-outer-name,unused-argument,too-many-arguments,too-many-locals
from datetime import datetime
from unittest import mock

import pytest
from db_schema.schemas import slz

from slz_check_complete.services.db import DBService
from slz_check_complete.status_transition import Manager


@pytest.fixture
def transition_uow_mock(db):
    uow_item = slz.UnitOfWork(
        unit_of_work_code='spotify-v1-streams',
        licensor_id=1,
        report_id=1,
        report_date='2019-01-02',
        activity_status=slz.ActivityStatusEnum.IN_PROGRESS,
        completeness_status=slz.CompletenessStatusEnum.ACTIVE,
        is_force_complete=False,
        priority=slz.UnitOfWorkPriorityEnum.PRIORITY_5.value,
        next_run_at=datetime(2019, 1, 2),
        created_at=datetime(2019, 1, 2),
        last_updated_at=datetime(2019, 1, 2),
    )
    db.session.add(uow_item)
    db.session.commit()
    cs_1 = slz.ContentStatus(
        unit_of_work_id=uow_item.unit_of_work_id,
        content_name='us.gz',
        context='US',
        content_status=slz.ContentStatusEnum.COMPLETE,
        latest_job_id='1',
        created_at=datetime(2019, 1, 3),
        last_checked_at=datetime(2019, 1, 3),
        failure_count=0,
        metadata_process_status=slz.ContentMetadataStatusEnum.NOT_QUEUED.value,
    )
    cs_2 = slz.ContentStatus(
        unit_of_work_id=uow_item.unit_of_work_id,
        content_name='jp.gz',
        context='JP',
        content_status=slz.ContentStatusEnum.COMPLETE,
        latest_job_id='2',
        created_at=datetime(2019, 1, 3),
        last_checked_at=datetime(2019, 1, 3),
        failure_count=0,
        metadata_process_status=slz.ContentMetadataStatusEnum.NOT_QUEUED.value,
    )
    cs_3 = slz.ContentStatus(
        unit_of_work_id=uow_item.unit_of_work_id,
        content_name='ru.gz',
        context='RU',
        content_status=slz.ContentStatusEnum.COMPLETE,
        latest_job_id='2',
        created_at=datetime(2019, 1, 3),
        last_checked_at=datetime(2019, 1, 3),
        failure_count=0,
        metadata_process_status=slz.ContentMetadataStatusEnum.NOT_QUEUED.value,
    )
    db.session.add_all([cs_1, cs_2, cs_3])
    db.session.commit()
    return uow_item


@pytest.mark.integration
def test_jobs_complete(db, transition_uow_mock, logger_test, now):
    dsp_criteria_service = mock.Mock()
    dsp_criteria_service.required.side_effect = [{'US', 'RU', 'JP'}]
    dsp_criteria_service.min_required.side_effect = [{'US'}]
    db_service = DBService(
        logger=logger_test,
        db_conn=db,
        now=now,
    )
    manager = Manager(
        logger_test,
        dsp_criteria_service,
        db_service,
    )
    result = manager.make_transition(
        'spotify', transition_uow_mock.unit_of_work_id, 'sony', 'streams'
    )
    assert (True, slz.CompletenessStatusEnum.COMPLETE) == result


@pytest.mark.integration
def test_jobs_min_complete(db, transition_uow_mock, logger_test, now):
    dsp_criteria_service = mock.Mock()
    dsp_criteria_service.required.side_effect = [{'AR', 'RU', 'JP'}]
    dsp_criteria_service.min_required.side_effect = [{'US'}]
    db_service = DBService(
        logger=logger_test,
        db_conn=db,
        now=now,
    )
    manager = Manager(
        logger_test,
        dsp_criteria_service,
        db_service,
    )
    result = manager.make_transition(
        'spotify', transition_uow_mock.unit_of_work_id, 'sony', 'streams'
    )
    assert (True, slz.CompletenessStatusEnum.MIN_COMPLETE) == result


@pytest.mark.integration
def test_uow_skip_value_error(db, logger_test, now):
    dsp_criteria_service = mock.Mock()
    db_service = DBService(
        logger=logger_test,
        db_conn=db,
        now=now,
    )
    manager = Manager(
        logger_test,
        dsp_criteria_service,
        db_service,
    )
    result = manager.make_transition('spotify', 12345, 'sony', 'streams')
    assert (False, None) == result


@pytest.mark.integration
def test_jobs_not_in_complete(db, transition_uow_mock, logger_test, now):
    dsp_criteria_service = mock.Mock()
    dsp_criteria_service.required.side_effect = [{'AR', 'RU', 'JP'}]
    dsp_criteria_service.min_required.side_effect = [{'AD'}]
    db_service = DBService(
        logger=logger_test,
        db_conn=db,
        now=now,
    )
    manager = Manager(
        logger_test,
        dsp_criteria_service,
        db_service,
    )
    result = manager.make_transition(
        'spotify', transition_uow_mock.unit_of_work_id, 'sony', 'streams'
    )
    assert (False, slz.CompletenessStatusEnum.ACTIVE) == result


@pytest.mark.integration
def test_make_transition_group_no_group_no_pipeline(
    db,
    transition_uow_mock,
    logger_test,
    now,
):
    db_service = DBService(
        logger=logger_test,
        db_conn=db,
        now=now,
    )
    manager = Manager(
        logger_test,
        mock.Mock(),
        db_service,
    )
    result = manager.make_transition_uow_group(transition_uow_mock)
    assert result is False


@pytest.mark.integration
def test_make_transition_group_no_group(db, transition_uow_mock, logger_test, now):
    pipeline = slz.UnitOfWorkPipeline(
        unit_of_work_id=transition_uow_mock.unit_of_work_id,
        created_at=now,
        config={},
    )
    db.session.add(pipeline)
    db.session.commit()
    db_service = DBService(
        logger=logger_test,
        db_conn=db,
        now=now,
    )
    manager = Manager(
        logger_test,
        mock.Mock(),
        db_service,
    )
    result = manager.make_transition_uow_group(transition_uow_mock)
    assert result is False


@pytest.mark.integration
@pytest.mark.parametrize(
    'uow_completeness_status, expected_group_status, expected_result', [
        (slz.CompletenessStatusEnum.COMPLETE, slz.CompletenessStatusEnum.COMPLETE, True),
        (slz.CompletenessStatusEnum.ACTIVE, slz.CompletenessStatusEnum.ACTIVE, False),
        (slz.CompletenessStatusEnum.MIN_COMPLETE, slz.CompletenessStatusEnum.ACTIVE, False),
    ]
)
def test_make_transition_group_uow(
    uow_completeness_status,
    expected_group_status,
    expected_result,
    db,
    transition_uow_mock,
    logger_test,
    now,
    unit_of_work_stubs,
):
    uow_2 = slz.UnitOfWork(**unit_of_work_stubs[1])
    uow_3 = slz.UnitOfWork(**unit_of_work_stubs[2])
    uow_3.completeness_status = slz.CompletenessStatusEnum.MIN_COMPLETE

    transition_uow_mock.completeness_status = uow_completeness_status
    group = slz.UnitOfWorkGroup(
        created_at=now, completeness_status=slz.CompletenessStatusEnum.ACTIVE.value
    )
    group_2 = slz.UnitOfWorkGroup(
        created_at=now, completeness_status=slz.CompletenessStatusEnum.ACTIVE.value
    )
    db.session.add_all([uow_2, uow_3, group, group_2])
    db.session.commit()
    pipeline = slz.UnitOfWorkPipeline(
        unit_of_work_id=transition_uow_mock.unit_of_work_id,
        unit_of_work_group_id=group.unit_of_work_group_id,
        created_at=now,
        config={},
    )
    pipeline_2 = slz.UnitOfWorkPipeline(
        unit_of_work_id=uow_2.unit_of_work_id,
        unit_of_work_group_id=group.unit_of_work_group_id,
        created_at=now,
        config={},
    )
    pipeline_3 = slz.UnitOfWorkPipeline(
        unit_of_work_id=uow_3.unit_of_work_id,
        unit_of_work_group_id=group_2.unit_of_work_group_id,
        created_at=now,
        config={},
    )
    db.session.add_all([pipeline, pipeline_2, pipeline_3])
    db.session.commit()
    db_service = DBService(
        logger=logger_test,
        db_conn=db,
        now=now,
    )
    manager = Manager(
        logger_test,
        mock.Mock(),
        db_service,
    )
    result = manager.make_transition_uow_group(transition_uow_mock)
    assert result == expected_result
    assert group.completeness_status == expected_group_status