"""Tests for exception handler."""

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

from oto import response
from oto import status

from podcast.logic import episode
from podcast.logic import megaphone
from podcast.utils.exc import OwsError
from tests.utils import db_operations


def test_create_episode_handler(fixture_client, monkeypatch):
    """Test create episode handler."""
    data = dict(
        id=3,
        podcast_id=1,
        title='Episode Title',
        description='Episode Description',
        season_number=1,
        episode_number=1,
        episode_type='full',
        content='clean',
        created_by='test_user',
        updated_by='test_user',
        draft=True
    )
    podcast_id = 1

    monkeypatch.setattr(
        episode, 'create_episode', MagicMock(
            return_value=data))

    handler_url = '/podcasts/{podcast_id}/episodes'.format(
        podcast_id=podcast_id)

    result = fixture_client.post(
        handler_url,
        json=data)
    assert result.status_code == status.OK


def test_get_episodes_handler(fixture_client, monkeypatch):
    """Test create episode handler."""
    data = dict(
        id=3,
        podcast_id=1,
        title='Episode Title',
        summary='Episode Summary',
        season_number=1,
        episode_number=1,
        episode_type='full',
        content='clean',
        created_by='test_user',
        updated_by='test_user'
    )
    podcast_id = 1

    monkeypatch.setattr(
        episode, 'get_episodes', MagicMock(
            return_value={'items': [data]}))

    handler_url = '/podcasts/{podcast_id}/episodes'.format(
        podcast_id=podcast_id)

    result = fixture_client.get(handler_url, data=data)
    assert result.status_code == status.OK


def test_get_episodes_null_start_date_handler(fixture_client, monkeypatch):
    """Test create episode handler."""
    podcast_id = 1

    handler_url = '/podcasts/{podcast_id}/episodes?start_date=null&end_date=null'.format(
        podcast_id=podcast_id)

    result = fixture_client.get(handler_url)
    assert result.status_code == status.OK


def test_episode_edit_handler(
        fixture_client,
        episode_fixture,
        monkeypatch
):
    """Test episode edit endpoint."""
    monkeypatch.setattr(
        episode, 'update_episode', MagicMock(
            return_value=episode_fixture))

    result = fixture_client.put(
        '/podcasts/1/episodes/1',
        json=episode_fixture)
    assert result.status_code == response.status.OK
    result = json.loads(result.data)
    assert result['episode_number'] == episode_fixture['episode_number']


def test_episode_edit_handler_not_found(
        fixture_client,
        episode_fixture,
        db_fixture
):
    """Test episode edit endpoint."""
    result = fixture_client.put(
        '/podcasts/101/episodes/1',
        json=episode_fixture)
    assert result.status_code == response.status.NOT_FOUND


def test_episode_edit_handler_validation_error(fixture_client):
    """Validation episode edit endpoint's body."""
    data_change = {
        'draft': True,
    }
    result = fixture_client.put(
        '/podcasts/1/episodes/1',
        json=data_change)
    assert result.status_code == response.status.BAD_REQUEST
    decoded = json.loads(result.data.decode())
    assert 'title' in decoded['message']


def test_episode_by_id(fixture_client):
    """Test to get episode by id."""
    podcast_id = 1
    episode_id = 1
    result = fixture_client.get('/podcasts/{0}/episodes/{1}'.format(
        podcast_id, episode_id))
    assert result
    data = json.loads(result.data.decode())
    assert data['id'] == episode_id
    assert data['podcast_id'] == podcast_id


def test_episode_by_id_not_found(fixture_client):
    """Test to get 404 with wrong ids."""
    podcast_id = 11
    episode_id = 1
    result = fixture_client.get('/podcasts/{0}/episodes/{1}'.format(
        podcast_id, episode_id))
    assert result.status_code == response.status.NOT_FOUND
    podcast_id = 1
    episode_id = 11
    result = fixture_client.get('/podcasts/{0}/episodes/{1}'.format(
        podcast_id, episode_id))
    assert result.status_code == response.status.NOT_FOUND


def test_delete_episode(fixture_client, monkeypatch):
    """Test to delete episode on handler's layer."""
    podcast_id = 1
    episode_id = 1
    monkeypatch.setattr(megaphone, 'delete_episode', MagicMock(
        return_value={'status': 'ok'}
    ))
    result = fixture_client.delete('/podcasts/{0}/episodes/{1}'.format(
        podcast_id, episode_id
    ))
    assert result.status_code == response.status.OK
    item = json.loads(result.data.decode())
    assert item['id'] == episode_id

    result = fixture_client.delete('/podcasts/{0}/episodes/{1}'.format(
        podcast_id, episode_id
    ))
    assert result.status_code == response.status.NOT_FOUND


def test_delete_episode_otoresponseexception(fixture_client, monkeypatch):
    """Test that on megaphone error raised exception is properly handled."""
    podcast_id = 1
    episode_id = 1

    monkeypatch.setattr(megaphone, 'delete_episode', MagicMock(side_effect=OwsError('Delete no way')))
    result = fixture_client.delete('/podcasts/{0}/episodes/{1}'.format(podcast_id, episode_id))
    assert result.status_code == 500


def test_get_episodes_with_insertion_points(fixture_client):
    """Test that get_episodes returns insertion_points."""
    podcast_id = 1
    result = fixture_client.get('/podcasts/{0}/episodes'.format(podcast_id))
    assert result.status_code == response.status.OK
    data = json.loads(result.data.decode())
    items = data['items']
    assert items
    assert all(isinstance(item['insertion_points'], list) for item in items)


def test_get_episode_by_id_with_insertion_points(fixture_client):
    """Test that get_episode_by_id returns insertion_points."""
    podcast_id = 1
    episode_id = 1
    result = fixture_client.get('/podcasts/{0}/episodes/{1}'.format(
        podcast_id, episode_id))
    assert result.status_code == response.status.OK
    item = json.loads(result.data.decode())
    assert isinstance(item['insertion_points'], list)
    assert item['insertion_points']


def test_planned_inventory(fixture_client, planned_inventory_fixture, monkeypatch):
    """Test that get_episode_by_id returns insertion_points."""
    podcast_id = 1
    data = 'response'
    monkeypatch.setattr(
        episode, 'create_planned_inventory', MagicMock(
            return_value=data))

    result = fixture_client.post('/podcasts/{0}/episodes/planned-inventory'.format(
        podcast_id), json=planned_inventory_fixture)

    assert result.status_code == response.status.OK
    assert result.data.decode() == 'response'


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

    results = {'items': [{'id': 1600}, {'id': 1647}]}
    monkeypatch.setattr(
        episode, 'get_episodes_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_get_most_recent_episodes(fixture_client, db_session, episode_fixture):
    """Test get most recent episodes handler."""
    starting_id = len(db_operations.episode_data) + 1
    del episode_fixture['id']
    del episode_fixture['insertion_points']
    episode_fixture['draft'] = False

    episode_fixture['published_date'] = datetime(2019, 6, 1, 8, 20, 20)
    db_operations.insert_episodes(db_session, episode_fixture)

    episode_fixture['published_date'] = datetime(2090, 8, 1, 8, 20, 20)
    db_operations.insert_episodes(db_session, episode_fixture)

    episode_fixture['published_date'] = datetime(2019, 8, 1, 8, 20, 20)
    db_operations.insert_episodes(db_session, episode_fixture)

    result = fixture_client.get('/episodes/most-recent', data={'limit': 3})
    response_body = json.loads(result.data.decode())
    assert response_body == [
        {'episode_id': starting_id + 2},
        {'episode_id': 1},
        {'episode_id': starting_id},
    ]


@patch('podcast.logic.episode.reupload_mp3_to_megaphone')
def test_reupload_mp3_to_megaphone_handler(mock_reupload_mp3_to_megaphone, fixture_client):
    """Test reupload mp3 to megaphone handler."""
    result = fixture_client.put('/episode/1/reupload-mp3')
    assert result.status_code == status.OK


def test_get_episode_wav_asset_handler(fixture_client, monkeypatch):
    """Test get episode wav asset handler."""
    monkeypatch.setattr(
        episode, 'get_episode_wav_asset', MagicMock(return_value={'audio_wav_url': 'test'}))
    result = fixture_client.get('/asset/1/wav')
    assert result.status_code == status.OK


def test_replicate_single_episode_handler(fixture_client, monkeypatch, replicate_single_episode_fixture):
    """Test replicate single episode handler."""
    monkeypatch.setattr(
        episode, 'replicate_single_episode_and_assets', MagicMock(return_value=[]))
    result = fixture_client.post('/replicate-single-episode', json=replicate_single_episode_fixture)
    assert result.status_code == status.OK


def test_replicate_episodes_and_create_assets_handler(fixture_client, monkeypatch):
    """Test replicate episodes and create assets."""
    payload = {
        'original_podcast_id': 1,
        'podcast_id': 1,
        'original_episode_ids': [1, 2],
        'seasons': [],
        'replication_type': 'bulk',
        'is_copy_apple_episode_id': True
    }
    monkeypatch.setattr(
        episode, 'replicate_episodes_and_create_assets', MagicMock(return_value=[]))
    result = fixture_client.post('/replicate-episodes-and-create-assets', json=payload)
    assert result.status_code == status.OK