"""Tests for get_label_details."""
from unittest.mock import MagicMock
from oto import response
from oto import status

from prs.constants import tools_message
from prs.logic import label_details_logic
from prs.logic import tool_log_logic
from prs.models import country
from prs.models import collection_society
from prs.models import label_details
from prs.models import label_delivery_history
from prs.utils import s3
from tests.constants import s3 as s3testconstants
from tests.testutils import db


@db.test_schema
def test_get_label_data_success(
        tool_param_data, label_query_response, monkeypatch):
    """Test get_label_data response contents upon success."""
    db.insert_to_table_raw(
        db.ar_db_session(), db.INSERT_INTO_TABLE_VW_LABEL_DETAIL)

    monkeypatch.setattr(
        label_details,
        'get_label_details',
        MagicMock(return_value=response.Response(
                message=label_query_response)))

    result = label_details_logic.get_label_data(tool_param_data)
    assert result.status == status.OK
    assert result.message


def test_fetch_label_details_success(
        mocker, label_details_response, label_data_response, tool_param_data):
    """Test fetch_label_details response contents on success."""
    log_values = {'tool_log_id': 1}
    mocker.patch.object(
        tool_log_logic, 'initialize_tool',
        return_value=response.Response(message=log_values))

    mocker.patch.object(
        label_details_logic, 'get_label_data',
        return_value=response.Response(message=label_data_response))

    country_name = {'name': 'USA'}
    mocker.patch.object(
        country, 'get_country_name_by_id',
        return_value=response.Response(message=country_name))

    mocker.patch.object(
        label_details_logic, 'generate_csv_link',
        return_value=label_details_response)

    mocker.patch.object(
        tool_log_logic, 'complete_tool')

    result_label_details = label_details_logic.fetch_label_details(
        tool_param_data)
    assert result_label_details.status == status.OK
    assert result_label_details.message['message'] == label_details_response[
        'message']
    assert result_label_details.message['s3_url'] == label_details_response[
        's3_url']


def test_fetch_label_details_vendor_list_failure(
        tool_param_data_vendor_list_error):
    """Test fetch_label_details when invalid eligible_vendor_list input."""
    result_label_details = label_details_logic.fetch_label_details(
        tool_param_data_vendor_list_error)
    assert result_label_details.status == status.BAD_REQUEST


def test_fetch_label_details_initialize_log_failure(mocker, tool_param_data):
    """Test fetch_label_details when initialize_log fails."""
    mocker.patch.object(
        tool_log_logic, 'initialize_tool',
        return_value=response.create_fatal_response())

    result_label_details = label_details_logic.fetch_label_details(
        tool_param_data)
    assert result_label_details.status == status.INTERNAL_ERROR


def test_fetch_label_details_failure(mocker, tool_param_data):
    """Test fetch_label_details when get_label_data fails."""
    log_values = {'tool_log_id': 1}
    mocker.patch.object(
        tool_log_logic, 'initialize_tool',
        return_value=response.Response(message=log_values))

    mocker.patch.object(
        label_details_logic, 'get_label_data',
        return_value=response.create_not_found_response())

    result_label_details = label_details_logic.fetch_label_details(
        tool_param_data)
    assert result_label_details.status == status.NOT_FOUND


def test_fetch_label_details_country_name_failure(
        mocker, label_data_response, tool_param_data_country_id_not_zero):
    """Test fetch_label_details when get_country_name_by_id fails."""
    log_values = {'tool_log_id': 1}
    mocker.patch.object(
        tool_log_logic, 'initialize_tool',
        return_value=response.Response(message=log_values))

    mocker.patch.object(
        label_details_logic, 'get_label_data',
        return_value=response.Response(message=label_data_response))

    mocker.patch.object(
        country, 'get_country_name_by_id',
        return_value=response.create_not_found_response())

    result_label_details = label_details_logic.fetch_label_details(
        tool_param_data_country_id_not_zero)
    assert result_label_details.status == status.NOT_FOUND


def test_fetch_label_details_generate_csv_failure(
        mocker, label_data_success, tool_param_data_country_id_not_zero):
    """Test fetch_label_details when generate_csv_link fails."""
    log_values = {'tool_log_id': 1}
    mocker.patch.object(
        tool_log_logic, 'initialize_tool',
        return_value=response.Response(message=log_values))

    mocker.patch.object(
        label_details_logic, 'get_label_data',
        return_value=response.Response(message=label_data_success))

    country_name = {'name': 'USA'}
    mocker.patch.object(
        country, 'get_country_name_by_id',
        return_value=response.Response(message=country_name))

    mocker.patch.object(
        s3, 'write_csv_to_s3', return_value=response.create_error_response(
            message=s3testconstants.S3_ERROR_MESSAGE,
            code=s3testconstants.S3_ERROR_CODE))

    result_label_details = label_details_logic.fetch_label_details(
        tool_param_data_country_id_not_zero)
    assert result_label_details.status == status.BAD_REQUEST


def test_generate_csv_link(
        mocker, label_details_response, label_data_response):
    """Test generate_csv_link upon success."""
    log_values = {'tool_log_id': 1}
    country_name = 'USA'

    # mock write_csv_to_s3 response contents upon success.
    mocker.patch.object(
        s3, 'write_csv_to_s3', return_value=response.Response(
            message=tools_message.CSV_GENERATION_SUCCESS_MESSAGE))

    # mock get_presigned_url response contents upon success.
    mocker.patch.object(
        s3, 'get_presigned_url', return_value=label_details_response['s3_url'])

    result = label_details_logic.generate_csv_link(
        log_values, country_name, label_data_response)
    assert result['message'] == label_details_response[
        'message']
    assert result['s3_url'] == label_details_response[
        's3_url']


def test_generate_csv_link_error(mocker, label_data_success):
    """Test generate_csv_link upon failure."""
    log_values = {'tool_log_id': 1}
    country_name = 'USA'
    # mock write_csv_to_s3 response contents upon failure.
    mocker.patch.object(
        s3, 'write_csv_to_s3', return_value=response.create_error_response(
            message=s3testconstants.S3_ERROR_MESSAGE,
            code=s3testconstants.S3_ERROR_CODE))

    result = label_details_logic.generate_csv_link(
        log_values, country_name, label_data_success)
    assert result.status == status.BAD_REQUEST


def test_get_label_delivery_history(
        mocker, label_delivery_history_response,
        label_query_response, monkeypatch):
    """Test get label delivery history success scenario."""
    society_for_country = {'society_id': 1}
    country_id = 1

    mocker.patch.object(
        collection_society, 'get_society_id_by_country_id',
        return_value=response.Response(message=society_for_country))

    mocker.patch.object(
        label_delivery_history, 'get_last_delivery_by_vendor_and_society_id',
        return_value=response.Response(
            message={'label_delivery_history': label_delivery_history_response}
                    ))

    result = label_details_logic.get_label_delivery_history(
        label_query_response, country_id)

    assert result