"""Tests for Handlers."""

import json
from unittest.mock import MagicMock
from unittest.mock import patch

from oto import response
from oto import status
from owsrequest import flask_request
import pytest

from promo_player import handlers
from promo_player.constants import promo_player as promo_player_constants
from promo_player.logic import promo_player
from promo_player.logic import promo_player_track


@patch('promo_player.handlers.g')
def test_exception_handler(mock_g, app_context):
    """Verify exception_Handler returns 500 status code and json payload."""
    message = (
        'The server encountered an internal error '
        'and was unable to complete your request.')
    mock_error = MagicMock()
    server_response = handlers.exception_handler(mock_error)
    mock_g.log.exception.assert_called_with(mock_error)

    # assert status code is 500
    assert server_response.status_code == 500

    # assert json payload
    response_message = json.loads(server_response.data.decode())
    assert response_message['message'] == message
    assert response_message['code'] == response.error.ERROR_CODE_INTERNAL_ERROR


@pytest.mark.parametrize('method, path', [
    ('post', '/product/1/player'),
    ('post', '/player/1/track/1'),
    ('get', '/product/1/player'),
    ('put', '/product/1/player/1'),
    ('put', '/player/1/track/1'),
    ('delete', '/player/1/track/1'),
    ('get', '/product/1/players'),
    ('delete', '/admin/product/1/players')])
def test_respects_verify_grass_ownership_failure(
        monkeypatch, fixture_client, fixture_fatal, method, path):
    """Test handlers immediately return on failed verify_grass_ownership."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_ownership',
        MagicMock(return_value=fixture_fatal))

    test_method = getattr(fixture_client, method)

    result = test_method(path)

    assert result.status_code == fixture_fatal.status


def test_create_promo_player_no_grass_headers(
        monkeypatch, fixture_client, fixture_success,
        fixture_no_grass_headers):
    """Test create promo player response when no Grass headers."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_ownership',
        MagicMock(return_value=fixture_success))

    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_no_grass_headers))

    monkeypatch.setattr(
        promo_player,
        'create',
        MagicMock(return_value=fixture_success))

    product_id = 1
    url = '/product/{0}/player'.format(product_id)
    data = {
        'vendor_id': 123,
        'expiration_mode': promo_player_constants.EXPIRATION_MODE_NONE,
        'skin': promo_player_constants.SKIN_LIGHT
    }

    expected_data = {
        'vendor_id': 123,
        'expiration_mode': promo_player_constants.EXPIRATION_MODE_NONE,
        'skin': promo_player_constants.SKIN_LIGHT,
        'product_id': product_id
    }

    result = fixture_client.post(url, data=json.dumps(data))

    promo_player.create.assert_called_with(expected_data)
    assert result.status_code == fixture_success.status


def test_create_promo_player_grass_headers_vendor(
        monkeypatch, fixture_client, fixture_success,
        fixture_grass_headers_vendor):
    """Test create promo player response when vendor Grass headers."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_ownership',
        MagicMock(return_value=fixture_success))

    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_grass_headers_vendor))

    monkeypatch.setattr(
        promo_player,
        'create',
        MagicMock(return_value=fixture_success))

    account_type, account_id = fixture_grass_headers_vendor
    product_id = 1
    url = '/product/{0}/player'.format(product_id)
    data = {
        'expiration_mode': promo_player_constants.EXPIRATION_MODE_NONE,
        'skin': promo_player_constants.SKIN_LIGHT
    }

    expected_data = {
        'expiration_mode': promo_player_constants.EXPIRATION_MODE_NONE,
        'skin': promo_player_constants.SKIN_LIGHT,
        'product_id': product_id,
        'vendor_id': account_id
    }

    result = fixture_client.post(url, data=json.dumps(data))

    promo_player.create.assert_called_with(expected_data)
    assert result.status_code == fixture_success.status


def test_create_promo_player_without_product_no_grass_headers(
        monkeypatch, fixture_client, fixture_success,
        fixture_no_grass_headers):
    """Test create promo player without product when no Grass headers."""
    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_no_grass_headers))

    monkeypatch.setattr(
        promo_player,
        'create',
        MagicMock(return_value=fixture_success))

    url = '/player'
    data = {
        'vendor_id': 123,
        'expiration_mode': promo_player_constants.EXPIRATION_MODE_NONE,
        'skin': promo_player_constants.SKIN_LIGHT
    }

    expected_data = {
        'vendor_id': 123,
        'expiration_mode': promo_player_constants.EXPIRATION_MODE_NONE,
        'skin': promo_player_constants.SKIN_LIGHT
    }

    result = fixture_client.post(url, data=json.dumps(data))

    promo_player.create.assert_called_with(expected_data)
    assert result.status_code == fixture_success.status


def test_create_promo_player_without_product_grass_headers_vendor(
        monkeypatch, fixture_client, fixture_success,
        fixture_grass_headers_vendor):
    """Test create promo player without product when vendor Grass headers."""
    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_grass_headers_vendor))

    monkeypatch.setattr(
        promo_player,
        'create',
        MagicMock(return_value=fixture_success))

    account_type, account_id = fixture_grass_headers_vendor
    url = '/player'
    data = {
        'expiration_mode': promo_player_constants.EXPIRATION_MODE_NONE,
        'skin': promo_player_constants.SKIN_LIGHT
    }

    expected_data = {
        'expiration_mode': promo_player_constants.EXPIRATION_MODE_NONE,
        'skin': promo_player_constants.SKIN_LIGHT,
        'vendor_id': account_id
    }

    result = fixture_client.post(url, data=json.dumps(data))

    promo_player.create.assert_called_with(expected_data)
    assert result.status_code == fixture_success.status


def test_create_promo_player_track(
        monkeypatch, fixture_client, fixture_success):
    """Test create promo player track."""
    monkeypatch.setattr(
        promo_player_track,
        'create',
        MagicMock(return_value=fixture_success))

    promo_player_id = 123
    track_id = 456
    url = '/player/{0}/track/{1}'.format(promo_player_id, track_id)
    data = {'sequence_number': 1}

    expected_data = {
        'sequence_number': 1,
        'promo_player_id': 123,
        'track_id': 456
    }

    result = fixture_client.post(url, data=json.dumps(data))

    promo_player_track.create.assert_called_with(expected_data)
    assert result.status_code == fixture_success.status


def test_get_active_promo_player_by_product_id(
        monkeypatch, fixture_client, fixture_success,
        fixture_no_grass_headers):
    """Test get the active promo player for a product."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_ownership',
        MagicMock(return_value=fixture_success))

    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_no_grass_headers))

    monkeypatch.setattr(
        promo_player,
        'get_active_by_product_id',
        MagicMock(return_value=fixture_success))

    product_id = 1
    url = '/product/{0}/player'.format(product_id)

    result = fixture_client.get(url)

    promo_player.get_active_by_product_id.assert_called_with(product_id)
    assert result.status_code == fixture_success.status


def test_update_promo_player(
        monkeypatch, fixture_client, fixture_success,
        fixture_no_grass_headers):
    """Test update promo player response."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_ownership',
        MagicMock(return_value=fixture_success))

    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_no_grass_headers))

    monkeypatch.setattr(
        promo_player,
        'update',
        MagicMock(return_value=fixture_success))

    product_id = 1
    promo_player_id = 2
    url = '/product/{0}/player/{1}'.format(product_id, promo_player_id)
    data = {
        'active': False
    }

    expected_data = {
        'active': False,
        'promo_player_id': 2,
        'product_id': 1
    }

    result = fixture_client.put(url, data=json.dumps(data))

    promo_player.update.assert_called_with(expected_data)
    assert result.status_code == fixture_success.status


def test_update_promo_player_without_product(
        monkeypatch, fixture_client, fixture_success,
        fixture_no_grass_headers):
    """Test update promo player without product response."""
    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_no_grass_headers))

    monkeypatch.setattr(
        promo_player,
        'update',
        MagicMock(return_value=fixture_success))

    promo_player_id = 2
    url = '/player/{0}'.format(promo_player_id)
    data = {
        'active': False
    }

    expected_data = {
        'active': False,
        'promo_player_id': 2
    }

    result = fixture_client.put(url, data=json.dumps(data))

    promo_player.update.assert_called_with(expected_data)
    assert result.status_code == fixture_success.status


def test_update_promo_player_track(
        monkeypatch, fixture_client, fixture_success):
    """Test update promo player track."""
    monkeypatch.setattr(
        promo_player_track,
        'update',
        MagicMock(return_value=fixture_success))

    promo_player_id = 123
    track_id = 456
    url = '/player/{0}/track/{1}'.format(promo_player_id, track_id)
    data = {'sequence_number': 2}

    expected_data = {
        'sequence_number': 2,
        'promo_player_id': 123,
        'track_id': 456
    }

    result = fixture_client.put(url, data=json.dumps(data))

    promo_player_track.update.assert_called_with(expected_data)
    assert result.status_code == fixture_success.status


def test_delete_promo_player_track(
        monkeypatch, fixture_client, fixture_success):
    """Test delete promo player track."""
    monkeypatch.setattr(
        promo_player_track,
        'delete',
        MagicMock(return_value=fixture_success))

    promo_player_id = 123
    track_id = 456
    url = '/player/{0}/track/{1}'.format(promo_player_id, track_id)

    result = fixture_client.delete(url)

    promo_player_track.delete.assert_called_with(promo_player_id, track_id)
    assert result.status_code == fixture_success.status


def test_get_promo_players_by_product_id(
        monkeypatch, fixture_client, fixture_success,
        fixture_no_grass_headers):
    """Test get promo players by product_id response."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_ownership',
        MagicMock(return_value=fixture_success))

    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_no_grass_headers))

    monkeypatch.setattr(
        promo_player,
        'get_by_product_id',
        MagicMock(return_value=fixture_success))

    product_id = 1
    url = '/product/{0}/players'.format(product_id)

    result = fixture_client.get(url)

    promo_player.get_by_product_id.assert_called_with(product_id)
    assert result.status_code == fixture_success.status


def test_get_promo_players_by_vendor_id(
        monkeypatch, fixture_client, fixture_success,
        fixture_grass_headers_vendor):
    """Test get promo players by vendor_id response."""
    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_grass_headers_vendor))

    monkeypatch.setattr(
        promo_player,
        'get_by_vendor_id',
        MagicMock(return_value=fixture_success))

    account_type, account_id = fixture_grass_headers_vendor
    url = '/players'

    result = fixture_client.get(url)

    promo_player.get_by_vendor_id.assert_called_with(account_id)
    assert result.status_code == fixture_success.status


def test_get_promo_players_by_vendor_id_no_grass_headers(
        monkeypatch, fixture_client, fixture_no_grass_headers):
    """Test get promo players by vendor_id response when no Grass headers."""
    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_no_grass_headers))

    url = '/players'

    result = fixture_client.get(url)

    assert result.status_code == status.BAD_REQUEST


def test_get_promo_player_by_code(
        monkeypatch, fixture_client, fixture_success):
    """Test get promo player by code response."""
    monkeypatch.setattr(
        promo_player,
        'get_by_code',
        MagicMock(return_value=fixture_success))

    code = '0123456789abcdefghij'
    url = '/player/code/{0}'.format(code)

    result = fixture_client.get(url)

    promo_player.get_by_code.assert_called_with(code)
    assert result.status_code == fixture_success.status


def test_delete_promo_players_by_product_id(
        monkeypatch, fixture_client, fixture_success,
        fixture_no_grass_headers):
    """Test delete promo players by product_id response."""
    monkeypatch.setattr(
        flask_request,
        'verify_grass_ownership',
        MagicMock(return_value=fixture_success))

    monkeypatch.setattr(
        flask_request,
        'get_grass_headers',
        MagicMock(return_value=fixture_no_grass_headers))

    monkeypatch.setattr(
        promo_player,
        'delete_by_product_id',
        MagicMock(return_value=fixture_success))

    product_id = 1
    url = '/admin/product/{0}/players'.format(product_id)

    result = fixture_client.delete(url)

    promo_player.delete_by_product_id.assert_called_with(product_id)
    assert result.status_code == fixture_success.status