"""Unit tests for the release correction detail model."""
from datetime import datetime
import json

import pytest

from product_workflow.connectors import mysql
from product_workflow.models import release_correction
from product_workflow.models import release_correction_detail
from tests.factories import release_correction as release_correction_factory
from tests.factories import release_correction_detail \
    as release_correction_detail_factory
from tests.testutils import db


@pytest.fixture
def correction_detail_id():
    """Create a release correction detail id for testing."""
    return 123


@pytest.fixture
def correction_id():
    """Create a release correction detail id for testing."""
    return 456


@pytest.fixture
def correction_details_data():
    """Create a release correction detail for testing."""
    return {
        'items': [
            {
                'table_name': 'randy',
                'field_name': 'butternubs',
                'key_id': 123,
                'key_value': 'track_1.wav',
                'last_updated_by': 1234,
                'last_updated_type': 'vendor',
            },
            {
                'table_name': 'releases',
                'field_name': 'remixer',
                'key_id': 124,
                'key_value': [{
                    'role': 'remixer',
                    'name': 'Greatest Artist'
                }],
                'last_updated_by': 1234,
                'last_updated_type': 'vendor'
            },
            {
                'table_name': 'jake',
                'field_name': 'the_doge',
                'key_id': 125,
                'key_value': 808,
                'last_updated_by': 1234,
                'last_updated_type': 'vendor'
            }
        ]
    }


@pytest.fixture
def correction_details_return_data():
    """Create a release correction detail for testing."""
    return {
        'items': [
            {
                'release_correction_detail_id': 1,
                'table_name': 'randy',
                'field_name': 'butternubs',
                'key_id': 123,
                'key_value': 'track_1.wav',
            },
            {
                'release_correction_detail_id': 2,
                'table_name': 'releases',
                'field_name': 'remixer',
                'key_id': 124,
                'key_value': [{
                    'role': 'remixer',
                    'name': 'Greatest Artist'
                }]
            },
            {
                'release_correction_detail_id': 3,
                'table_name': 'jake',
                'field_name': 'the_doge',
                'key_id': 125,
                'key_value': 808,
            }
        ]
    }


def test_to_dict_with_primitive_key_value(correction_detail_id, correction_id):
    """Test that the expected properties are returned."""
    table_name = 'tracks'
    field_name = 'release_name'
    key_id = 4090520
    key_value = 'derp'

    correction_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value=key_value,
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1)

    assert correction_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': key_value
    }


def test_to_dict_converts_coverart_key_value_to_boolean(
        correction_detail_id,
        correction_id
):
    """Test that boolean values are booleans."""
    table_name = 'releases'
    field_name = 'coverart'
    key_id = 4090520

    true_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value='true',
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1
    )
    false_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value='false',
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1
    )

    assert true_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': True
    }
    assert false_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': False
    }


def test_to_dict_converts_track_key_value_to_boolean(
        correction_detail_id,
        correction_id
):
    """Test that boolean values are booleans."""
    table_name = 'track'
    field_name = 'track'
    key_id = 4090520

    true_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value='true',
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1
    )
    false_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value='false',
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1
    )

    assert true_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': True
    }
    assert false_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': False
    }


def test_to_dict_with_object_key_value(correction_detail_id, correction_id):
    """Test that the expected properties are returned."""
    table_name = 'track'
    field_name = 'track_artist'
    key_id = 4090520
    key_value = [{
        'artist_name': 'Emerald Park',
        'role': 'primary'
    }]

    correction_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value=json.dumps(key_value),
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1)

    assert correction_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': key_value
    }


def test_to_dict_with_numerical_key_value(correction_detail_id, correction_id):
    """Test that the expected properties are returned."""
    table_name = 'tracks'
    field_name = 'track_name'
    key_id = 4090520
    key_value = '123'

    correction_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value=key_value,
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1)

    assert correction_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': key_value
    }


def fetch_release_correction(release_correction_id):
    """Fetch release correction from the db by release_correction_id."""
    with mysql.db_session() as session:
        correction = session.query(
            release_correction.ReleaseCorrection).filter_by(
            release_correction_id=release_correction_id).first()

        session.expunge(correction)
        return correction


def fetch_release_correction_details(release_correction_id):
    """Fetch correction details from the db by release_correction_id."""
    details = []
    with mysql.db_session() as session:
        query = session.query(
            release_correction_detail.ReleaseCorrectionDetail).filter_by(
            release_correction_id=release_correction_id)
        for detail in query:
            session.expunge(detail)
            details.append(detail)
        return details


@db.test_schema
def test_create_release_correction_details(
        correction_details_data, correction_details_return_data):
    """Test that new release correction details are returned."""
    release_correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='active')[0]
    db.seed_models(release_correction)

    result = release_correction_detail.upsert_many(
        release_correction.release_correction_id, correction_details_data)

    assert result.status == 201
    assert result.message == correction_details_return_data


@db.test_schema
def test_create_release_correction_details_not_found(
        correction_details_data):
    """Test that new release correction details are returned."""
    result = release_correction_detail.upsert_many(
        123, correction_details_data)

    assert result.status == 404


@db.test_schema
def test_create_release_correction_details_without_payload():
    """Test that new release correction fails without a payload."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(
            1,
            status='active',
            last_updated_by=1,
            last_updated_type='oa')[0]
    release_correction_id = correction.release_correction_id
    db.seed_models(correction)
    result = release_correction_detail.upsert_many(
        release_correction_id, {'items': []})

    assert result.errors == {
        'code': 'internal_error',
        'message': 'Can not update correction details without data'}
    assert result.status == 400


@db.test_schema
def test_create_release_correction_details_updates_correction(
        correction_details_data, correction_details_return_data):
    """Test release correction fields are updated when creating details."""
    release_correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(
            1,
            status='active',
            last_updated_by=1,
            last_updated_type='oa')[0]
    release_correction_id = release_correction.release_correction_id

    db.seed_models(release_correction)

    result = release_correction_detail.upsert_many(
        release_correction_id, correction_details_data)

    assert result.status == 201
    assert result.message == correction_details_return_data

    release_correction = fetch_release_correction(release_correction_id)
    assert release_correction.last_updated_by == 1234
    assert release_correction.last_updated_type == 'vendor'


@db.test_schema
def test_release_correction_details_for_coverart():
    """Test boolean for coverart is saved as a string."""
    release_correction = release_correction_factory\
        .ReleaseCorrectionFactory\
        .build_batch(
            1,
            status='active',
            last_updated_by=1,
            last_updated_type='oa'
        )[0]

    release_correction_id = release_correction.release_correction_id

    db.seed_models(release_correction)

    result = release_correction_detail.upsert_many(
        release_correction_id,
        {
            'items': [
                {
                    'table_name': 'releases',
                    'field_name': 'coverart',
                    'key_id': 123,
                    'key_value': True,
                    'last_updated_by': 1234,
                    'last_updated_type': 'vendor',
                },
                {
                    'table_name': 'releases',
                    'field_name': 'coverart',
                    'key_id': 123,
                    'key_value': False,
                    'last_updated_by': 1234,
                    'last_updated_type': 'vendor',
                },
            ]
        }
    )

    assert result.status == 201
    true_detail, false_detail = fetch_release_correction_details(
        release_correction_id
    )
    assert true_detail.key_value == 'true'
    assert false_detail.key_value == 'false'


@db.test_schema
def test_release_correction_details_for_track():
    """Test boolean for track is saved as a string."""
    release_correction = release_correction_factory\
        .ReleaseCorrectionFactory\
        .build_batch(
            1,
            status='active',
            last_updated_by=1,
            last_updated_type='oa'
        )[0]

    release_correction_id = release_correction.release_correction_id

    db.seed_models(release_correction)

    result = release_correction_detail.upsert_many(
        release_correction_id,
        {
            'items': [
                {
                    'table_name': 'track',
                    'field_name': 'track',
                    'key_id': 123,
                    'key_value': True,
                    'last_updated_by': 1234,
                    'last_updated_type': 'vendor',
                },
                {
                    'table_name': 'track',
                    'field_name': 'track',
                    'key_id': 123,
                    'key_value': False,
                    'last_updated_by': 1234,
                    'last_updated_type': 'vendor',
                },
            ]
        }
    )

    assert result.status == 201
    true_detail, false_detail = fetch_release_correction_details(
        release_correction_id
    )
    assert true_detail.key_value == 'true'
    assert false_detail.key_value == 'false'


@db.test_schema
def test_create_release_correction_details_updates_existing_details(
        correction_details_data):
    """Test that existing release correction details are updated."""
    correction = release_correction_factory.ReleaseCorrectionFactory \
        .build_batch(1, status='active')[0]

    correction_id = correction.release_correction_id

    factory = release_correction_detail_factory.ReleaseCorrectionDetailFactory
    correction_detail = factory.build_batch(
        1,
        release_correction_id=correction_id,
        table_name='randy',
        field_name='butternubs',
        key_id=123,
        key_value='track_0.wav',
        last_updated_by=1,
        last_updated_type='oa')[0]

    db.seed_models(correction)
    db.seed_models(correction_detail)

    result = release_correction_detail.upsert_many(
        correction_id, correction_details_data)

    assert result.status == 201
    details = fetch_release_correction_details(correction_id)
    assert len(details) == 3
    assert details[0].field_name == 'butternubs'
    assert details[0].last_updated_by == 1234
    assert details[0].last_updated_type == 'vendor'


def test_to_dict_with_release_name_key_value(correction_detail_id, correction_id):
    """Test that the expected properties are returned."""
    table_name = 'releases'
    field_name = 'release_name'
    key_id = 4090520
    key_value = 'test release name'

    correction_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value=key_value,
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1)

    assert correction_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': key_value
    }

def test_to_dict_with_delivered_version_key_value(
        correction_detail_id, correction_id):
    """Test that delivered_version field_name converts key_value to string."""
    table_name = 'releases'
    field_name = 'delivered_version'
    key_id = 4090520
    key_value = '1'

    correction_detail = release_correction_detail.ReleaseCorrectionDetail(
        release_correction_detail_id=correction_detail_id,
        release_correction_id=correction_id,
        table_name=table_name,
        field_name=field_name,
        key_id=key_id,
        key_value=key_value,
        last_updated=datetime(2017, 6, 10, 0, 0, 0),
        last_updated_by=1)

    assert correction_detail.to_dict() == {
        'release_correction_detail_id': correction_detail_id,
        'table_name': table_name,
        'field_name': field_name,
        'key_id': key_id,
        'key_value': key_value
    }