"""Tests for ows-salessheets models."""

from unittest.mock import MagicMock

from flexmock import flexmock
import pytest

from sqlalchemy.exc import SQLAlchemyError
from salessheets.connectors import mysql
from salessheets.constants import models
from salessheets.models import release


@pytest.mark.parametrize('context, context_type', [
    ([123456789123, 1234567891237861], models.UPC),
    (['0123456789123', '01234567891237861'], models.DISPLAY_UPC)
])
def test_get_multiple_release_ids_success(context, context_type):
    """Test get_multiple_release_ids for successful result."""
    release_ids = ('192183', '678273')
    test_result = [
        {
            context_type: context[0],
            models.RELEASE_ID: release_ids[0],
            models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
        },
        {
            context_type: context[1],
            models.RELEASE_ID: release_ids[1],
            models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
        },
    ]
    session_scope = MagicMock()
    session_scope.__enter__().execute.return_value = iter(test_result)
    (flexmock(mysql)
     .should_receive('ar_db_session')
     .and_return(session_scope))
    result = release.get_multiple_release_ids(context, context_type)
    assert sorted(result.message) == sorted(release_ids)
    sql = session_scope.__enter__().execute.mock_calls[0][1][0]
    assert 'product_type_id = 1' in sql


def test_get_multiple_release_ids_no_data_for_one_upc():
    """Test get_multiple_release_ids for valid exception."""
    upcs = [123456789123, 1234567891237861]
    release_ids = (192183, 678273)
    expected_message = 'release with upc {0} doesn\'t exist'.format(upcs[1])
    test_result = [{
        models.UPC: upcs[0],
        models.RELEASE_ID: release_ids[0],
        models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
    }]
    session_scope = flexmock(
        execute=lambda query, data: iter(test_result)
    )
    (flexmock(mysql)
     .should_receive('ar_db_session')
     .and_return(session_scope))
    result = release.get_multiple_release_ids(upcs, models.UPC)
    assert result.status == 404
    assert result.errors['message'] == expected_message


def test_get_multiple_release_ids_no_data_for_one_display_upc():
    """Test get_multiple_release_ids for valid exception."""
    display_upcs = [123456789123, 1234567891237861]
    release_ids = (192183, 678273)
    expected_message = 'release with display_upc {0} doesn\'t exist'.format(
        display_upcs[1])
    test_result = [{
        models.DISPLAY_UPC: display_upcs[0],
        models.RELEASE_ID: release_ids[0],
        models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
    }]
    session_scope = flexmock(
        execute=lambda query, data: iter(test_result)
    )
    (flexmock(mysql)
     .should_receive('ar_db_session')
     .and_return(session_scope))
    result = release.get_multiple_release_ids(
        display_upcs, models.DISPLAY_UPC)
    assert result.status == 404
    assert result.errors['message'] == expected_message


@pytest.mark.parametrize('context_type', [
    models.UPC,
    models.DISPLAY_UPC
])
def test_get_multiple_release_ids_no_upcs_provided(context_type):
    """Test get_multiple_release_ids for 404 exception."""
    upcs = []
    result = release.get_multiple_release_ids(upcs, context_type)
    assert result.status == 404


def test_get_multiple_release_ids_wrong_status():
    """Test get_multiple_release_ids for releases with not allowed statuses."""
    upcs = (
        123456789003,
        123456789004,
        123456789005,
    )
    release_ids = (
        '100001',
        '100002',
        '100003',
    )
    statuses = [
        models.RELEASE_STATUS_IN_CONTENT,
        models.RELEASE_STATUS_IN_CONTENT,
        models.RELEASE_STATUS_LABEL_PROCESSING,
    ]
    # Indexes of test data with statuses different from 'in_content'.
    not_allowed_status_indexes = (1, 2)
    not_allowed_status_upcs = []
    for idx in not_allowed_status_indexes:
        statuses[idx] = models.RELEASE_STATUS_IN_CONTENT + '-other'
        not_allowed_status_upcs.append(upcs[idx])

    expected_message = (
        'The following products must be in '
        'one of these statuses: {allowed_statuses} '
        'to generate sales sheets: {upcs}'.format(
            allowed_statuses=models.ALLOWED_RELEASE_STATUSES,
            upcs=', '.join(str(upc) for upc in not_allowed_status_upcs)))

    test_result = [
        {
            models.UPC: upcs[idx],
            models.RELEASE_ID: release_ids[idx],
            models.RELEASE_STATUS: statuses[idx],
        }
        for idx, upc in enumerate(upcs)
    ]
    session_scope = flexmock(
        execute=lambda query, data: iter(test_result)
    )
    (flexmock(mysql)
     .should_receive('ar_db_session')
     .and_return(session_scope))
    result = release.get_multiple_release_ids(upcs, models.UPC)
    assert result.status == 404
    assert result.errors['message'] == expected_message


@pytest.mark.parametrize('context_type', [
    models.UPC,
    models.DISPLAY_UPC
])
def test_get_multiple_release_ids_exception(context_type):
    """Test get_multiple_release_ids for valid exception."""
    upcs = [1]
    (flexmock(mysql)
     .should_receive('ar_db_session')
     .and_raise(SQLAlchemyError))
    (flexmock(mysql)
     .should_receive('capture_exception')
     .once())
    result = release.get_multiple_release_ids(upcs)
    assert result.status == 500


def test_get_multiple_release_ids_without_context_type():
    """Test get_multiple_release_ids uses default context_type."""
    display_upcs = [123456789123, 1234567891237861]
    release_ids = ('192183', '678273')
    test_result = [
        {
            models.DISPLAY_UPC: display_upcs[0],
            models.RELEASE_ID: release_ids[0],
            models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
        },
        {
            models.DISPLAY_UPC: display_upcs[1],
            models.RELEASE_ID: release_ids[1],
            models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
        },
    ]
    session_scope = flexmock(
        execute=lambda query, data: iter(test_result)
    )
    (flexmock(mysql)
     .should_receive('ar_db_session')
     .and_return(session_scope))
    result = release.get_multiple_release_ids(display_upcs)
    assert result.message == release_ids


def test_get_multiple_release_ids_invalid_context_type():
    """Test get_multiple_release_ids for invalid context_type exception."""
    upcs = [1]
    context_type = 'invalid_context_type'
    expected_message = 'Context type is not equal to "upc" or "display_upc"'
    result = release.get_multiple_release_ids(upcs, context_type)
    assert result.status == 400
    assert result.errors['message'] == expected_message


def test_get_multiple_release_ids_for_duplicate_upc():
    """Test multiple release_ids are collected correctly for duplicate upc."""
    display_upcs = [123456789123, 1234567891237861]
    release_ids = ('192183', '678273', '765234')
    test_result = [
        {
            models.DISPLAY_UPC: display_upcs[0],
            models.RELEASE_ID: release_ids[0],
            models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
        },
        {
            models.DISPLAY_UPC: display_upcs[0],
            models.RELEASE_ID: release_ids[1],
            models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
        },
        {
            models.DISPLAY_UPC: display_upcs[1],
            models.RELEASE_ID: release_ids[2],
            models.RELEASE_STATUS: models.RELEASE_STATUS_IN_CONTENT,
        },
    ]
    session_scope = flexmock(
        execute=lambda query, data: iter(test_result)
    )
    (flexmock(mysql)
     .should_receive('ar_db_session')
     .and_return(session_scope))
    result = release.get_multiple_release_ids(
        display_upcs, context_type=models.DISPLAY_UPC)
    assert result.message == release_ids