"""Tests for exception handler."""

import json
from unittest.mock import MagicMock

from oto import response
from oto import status
from sqlalchemy.exc import SQLAlchemyError

from podcast.constants import error
from podcast.logic import generate_upload_token
from podcast.logic import megaphone
from podcast.logic import podcast
from podcast.models import token
from podcast.utils import exc
from tests.utils import db_operations


def test_create_podcast_handler(fixture_client, monkeypatch):
    """Test create podcast handler."""
    data = dict(
        network_id=1,
        title='title',
        description='description',
        slug='slug',
        copyright='copyright',
        show_type='serial',
        categories=[1],
        email='email@domain.dom',
        link='http://some.dom',
        explicit='clean',
        owner='Sally',
        host='Betty',
        megaphone_id='f64b0f8e-ea77-11e9-9831-df1b1d22b24b',
        language='en',
        artwork_filename='filename'
    )

    monkeypatch.setattr(
        podcast, 'create_podcast', MagicMock(
            return_value=data))

    result = fixture_client.post('/podcasts', json=data)
    assert result.status_code == status.OK


def test_create_podcast_handler_bad_params(fixture_client, monkeypatch):
    """Test create podcast handler with bad params."""
    data = dict()

    monkeypatch.setattr(
        podcast, 'create_podcast', MagicMock(
            side_effect=exc.OwsError.bad_request(error.ERROR_MESSAGE_EMPTY_BODY)))

    result = fixture_client.post('/podcasts', data=data)
    assert result.status_code == status.BAD_REQUEST


def test_get_podcasts_handler(fixture_client, monkeypatch):
    """Test get podcast handler."""
    data = [
        dict(
            title='title',
            description='description',
            show_type='serial',
            slug='slug',
            copyright='copyright',
            email='email',
            link='link',
            explicit='yes',
            created_by='test_user',
            updated_by='test_user')]

    monkeypatch.setattr(
        podcast, 'get_podcasts', MagicMock(
            return_value={'items': data}))

    result = fixture_client.get('/podcasts')

    podcast.get_podcasts.assert_called_once_with(0, 0, [], [])
    assert result.status_code == status.OK
    assert len(result.json['items']) == 1


def test_get_podcasts_handler_with_params(fixture_client, monkeypatch):
    """Test get podcast handler with paramaters."""
    data = [
        dict(
            title='title',
            description='description',
            show_type='serial',
            slug='slug',
            copyright='copyright',
            email='email',
            link='link',
            explicit='yes',
            created_by='test_user',
            updated_by='test_user')]

    monkeypatch.setattr(
        podcast, 'get_podcasts', MagicMock(
            return_value={'items': data}))

    params = '?limit=12&offset=0&network_ids=1&network_ids=2&ids=3&ids=4'
    result = fixture_client.get('/podcasts' + params)

    podcast.get_podcasts.assert_called_once_with(12, 0, [1, 2], [3, 4])
    assert result.status_code == status.OK
    assert len(result.json['items']) == 1


def test_get_podcasts_by_ids_handler(fixture_client, monkeypatch):
    """Test get podcasts by ids handler."""
    url = '/podcasts-by-id'

    results = {'items': [{'id': 1600}, {'id': 1647}]}
    monkeypatch.setattr(
        podcast, 'get_podcasts_by_ids', MagicMock(
            return_value=results))

    result = fixture_client.get(url, data={'ids': [1600, 1647]})

    assert result.status_code == status.OK
    assert result.json == results


def test_update_podcast_handler_bad_request(fixture_client, monkeypatch):
    """Test update podcast handler with bad request."""
    podcast_id = 2
    data = dict()

    monkeypatch.setattr(
        podcast, 'update_podcast', MagicMock(
            return_value=response.create_error_response(
                code=status.BAD_REQUEST,
                message=error.ERROR_MESSAGE_EMPTY_BODY)))

    result = fixture_client.put('/podcasts/{0}'.format(podcast_id), data=data)

    assert result.status_code == status.BAD_REQUEST


def test_delete_podcast_handler(fixture_client, monkeypatch):
    """Test delete podcast handler."""
    podcast_id = 2
    data = dict(
        id=2,
        title='title 2',
        show_type='serial',
        description='description 2',
        slug='slug',
        copyright='copyright',
        email='email',
        link='link',
        explicit='yes',
        created_by='test_user',
        updated_by='test_user')

    monkeypatch.setattr(
        podcast, 'delete_podcast', MagicMock(
            return_value=data))

    result = fixture_client.delete('/podcasts/{0}'.format(podcast_id))

    assert result.status_code == status.OK


def test_delete_podcast_handler_not_found_request(fixture_client, monkeypatch):
    """Test delete podcast handler with not found request."""
    podcast_id = 5
    monkeypatch.setattr(
        podcast, 'delete_podcast', MagicMock(
            side_effect=exc.OwsError.not_found('not found')))

    result = fixture_client.delete('/podcasts/{0}'.format(podcast_id))

    assert result.status_code == status.NOT_FOUND


def test_delete_podcast_handler_success(fixture_client, monkeypatch):
    """Test delete podcast handler returns deleted item."""
    podcast_id = 1
    monkeypatch.setattr(megaphone, 'delete_podcast', MagicMock(
        return_value=response.Response({'status': 'OK'})
    ))
    result = fixture_client.delete('/podcasts/{0}'.format(podcast_id))
    assert result.status_code == status.OK
    data = json.loads(result.data.decode())
    assert data['id'] == podcast_id
    result = fixture_client.get('/podcasts-by-id?ids={0}'.format(podcast_id))
    assert result.json['items'] == []


def test_delete_podcast_handler_unhandled_error(fixture_client, monkeypatch):
    """Test that delete podcast return 500 on SQLAlchemy error."""
    podcast_id = 1
    error_message = 'critical'
    monkeypatch.setattr(podcast, 'delete_podcast', MagicMock(
        side_effect=SQLAlchemyError(error_message)
    ))
    result = fixture_client.delete('/podcasts/{0}'.format(podcast_id))
    assert result.status_code == status.INTERNAL_ERROR


def test_upload_token(fixture_client, monkeypatch):
    """Test upload token handler."""
    monkeypatch.setattr(
        generate_upload_token, 'get_upload_permission', MagicMock(return_value={
            'bucket': 'some-bucket',
            'filename': 'some-file.jpg',
            'credentials': 'abc123'
        })
    )

    http_response = fixture_client.get('/assets/upload-token')
    assert http_response.status_code == 200


def test_upload_token_for_copy(fixture_client, get_upload_permission_fixture, monkeypatch):
    """Test upload token handler for copy type."""
    monkeypatch.setattr(token, 'get_s3_token', MagicMock(return_value=get_upload_permission_fixture['credentials']))

    monkeypatch.setattr(generate_upload_token, '_generate_filename', MagicMock(return_value='filename'))

    http_response = fixture_client.get('/assets/upload-token?upload_copy=1')
    assert http_response.status_code == 200
    token.get_s3_token.assert_called_once_with('filename')
    message = json.loads(http_response.data.decode())
    assert isinstance(message, dict)
    assert 'asset_upload_id' not in message


def test_update_podcast_handler_slug_success(fixture_client, monkeypatch):
    """Test update podcast handler success with same slug."""
    data = db_operations.podcast_data[0]
    podcast_id = data['id']
    data.pop('created_date')
    data.pop('updated_date')
    monkeypatch.setattr(megaphone, 'create_or_update_podcast', MagicMock(
        return_value=response.Response({'status': 'ok'})
    ))
    monkeypatch.setattr(
        podcast, 'validate_artwork_asset', MagicMock(
            return_value=response.Response({'filename': 'filename'})
        )
    )
    result = fixture_client.put('/podcasts/{0}'.format(podcast_id), json=data)
    assert result.status_code == status.OK


def test_get_public_and_private_rss_podcasts_handler(fixture_client, monkeypatch):
    """Test get public-and-private-rss-podcasts handler."""
    url = '/public-and-private-rss-podcasts'

    results = {'items': [{'id': 1, 'title': 'one'}, {'id': 2, 'title': 'two'}]}
    monkeypatch.setattr(podcast, 'get_public_and_private_rss_podcasts', MagicMock(return_value=results))

    result = fixture_client.get(url)

    assert result.status_code == status.OK
    assert result.json == results


def test_get_podcast_original_artwork_asset_handler(fixture_client, monkeypatch):
    """Test get podcast original artwork asset handler."""
    monkeypatch.setattr(
        podcast,
        'get_podcast_original_artwork_asset',
        MagicMock(return_value={'original_artwork_url': 'test'}))
    result = fixture_client.get('/podcast/1/original-artwork')
    assert result.status_code == status.OK