"""Test for Campaign logic tier."""
import datetime
from unittest.mock import MagicMock

import pytest

from podcast.logic import campaign
from podcast.models import advertisement as advertisement_model
from podcast.models import campaign as campaign_model
from podcast.models import episode as episode_model
from podcast.models import order as order_model
from podcast.models.api_campaign import ApiCampaign
from podcast.utils.exc import OwsError


def test_get_campaigns(monkeypatch):
    """Test get campaigns method."""
    campaigns = [
        {'id': 'ab', 'title': 'campaign 1', 'advertiser': {'name': 'Charlies Horse'}},
        {'id': 'abc', 'title': 'campaign 2', 'advertiser': {'name': 'Charlies Horse'}}
    ]
    monkeypatch.setattr(ApiCampaign, 'get_all', MagicMock(return_value=campaigns))
    monkeypatch.setattr(campaign_model, 'delete_campaign_by_megaphone_ids', MagicMock())
    monkeypatch.setattr(order_model, 'delete_orders_by_megaphone_ids', MagicMock())
    monkeypatch.setattr(campaign_model, 'create_or_update_campaigns', MagicMock())
    results = campaign.campaigns()
    assert results == [
        {'id': 'ab', 'name': 'campaign 1', 'advertiser_name': 'Charlies Horse'},
        {'id': 'abc', 'name': 'campaign 2', 'advertiser_name': 'Charlies Horse'}
    ]
    campaign_model.delete_campaign_by_megaphone_ids.assert_called_once_with(['1', '2'])
    order_model.delete_orders_by_megaphone_ids.assert_called_once_with(
        ['mp1', 'mp2', 'mp3'])
    campaign_model.create_or_update_campaigns.assert_called_once_with([
        {'id': 'ab', 'name': 'campaign 1', 'advertiser_name': 'Charlies Horse'},
        {'id': 'abc', 'name': 'campaign 2', 'advertiser_name': 'Charlies Horse'}
    ])


def test_get_campaigns_by_megaphone_ids():
    """Test get campaigns by ids method."""
    results = campaign.get_campaigns_by_megaphone_ids(['1'])
    assert results['items'] == [{
        'name': 'Random Campaign title',
        'id': '1',
        'advertiser_name': 'Sarahs Business',
        'is_deleted': False
    }]


def test_get_orders(monkeypatch, mock_current_user):
    """Test get orders method."""
    orders = [
        {
            'id': 'chowda',
            'title': 'a',
            'state': 'enabled',
            'startAt': '2090-07-08T20:59:00.000-07:00',
            'endAt': '2090-07-08T20:59:00.000-07:00',
            'campaignId': 'mpid',
            'position': '2',
            'priority': '2',
            'targets': [
                {'type': 'podcast', 'id': '6bf5bea4-a1d4-11e6-8dea-b334e2aa4710'},
                {'type': 'episode', 'id': '6bf5bea4-a1d4-11e6-8dea-b334e2aa4880'},  # part of above podcast
                {'type': 'episode', 'id': '6bf5bea4-a1d4-11e6-8dea-b334e2aa4811'},
            ]
        },
        {
            'id': 'lobsta',
            'title': 'b',
            'state': 'disabled',
            'position': '0',
            'priority': '2',
            'startAt': '2090-07-08T20:59:00.000-07:00',
            'endAt': '2090-07-08T20:59:00.000-07:00',
            'targets': [],
            'campaignId': 'mpid'
        },
        {
            'id': 'wicked',
            'title': 'c',
            'state': 'enabled',
            'position': '1',
            'priority': '2',
            'startAt': '2090-07-08T20:59:00.000-07:00',
            'endAt': '2000-07-08T20:59:00.000-07:00',
            'targets': [],
            'campaignId': 'mpid'
        }
    ]
    monkeypatch.setattr(ApiCampaign, 'get_all_orders', MagicMock(return_value=orders))
    monkeypatch.setattr(order_model, 'delete_orders_by_megaphone_ids', MagicMock())
    monkeypatch.setattr(order_model, 'create_or_update_orders', MagicMock())
    results = campaign.campaign_orders(1)
    assert len(results) == 1
    end_at = datetime.datetime(2090, 7, 9, 3, 59, tzinfo=datetime.timezone.utc)
    end_at_past = datetime.datetime(2000, 7, 9, 3, 59, tzinfo=datetime.timezone.utc)
    order_model.delete_orders_by_megaphone_ids.assert_called_with(['mp1', 'mp2', 'mp3'])
    order_model.create_or_update_orders.assert_called_with([
        {'id': 'chowda', 'name': 'a', 'enabled': 1, 'start_at': end_at,
         'priority': '2', 'pos': '2', 'campaign_id': 'mpid', 'end_at': end_at, 'network_ids': [1],
         'targets': orders[0]['targets']
         },
        {'id': 'lobsta', 'name': 'b', 'enabled': 0, 'start_at': end_at,
         'priority': '2', 'pos': '0', 'campaign_id': 'mpid', 'end_at': end_at, 'network_ids': [],
         'targets': []
         },
        {'id': 'wicked', 'name': 'c', 'enabled': 1, 'start_at': end_at,
         'priority': '2', 'pos': '1', 'campaign_id': 'mpid', 'end_at': end_at_past, 'network_ids': [],
         'targets': []}
    ], 1)


def test_get_campaign_orders_by_megaphone_ids_producer(monkeypatch, mock_current_user):
    """Test get campaign orders by ids method for producer."""
    results = campaign.get_campaign_orders_by_megaphone_ids(['mp1', 'mp2'])['items']
    assert len(results) == 1
    assert results[0]['name'] == 'order 1'


def test_get_campaign_orders_by_megaphone_ids_show_level(monkeypatch, mock_current_podcast_level_user):
    """Test get campaign orders by ids method for show level user."""
    results = campaign.get_campaign_orders_by_megaphone_ids(['mp1', 'mp2', 'mp3'])['items']
    assert len(results) == 2
    assert results[0]['name'] == 'order 1'
    assert results[1]['name'] == 'order 2'


def test_get_campaign_orders_by_megaphone_ids_with_accessible_network(monkeypatch, mock_current_network_admin_user):
    """Test get campaign orders by ids with accessible network for network admin."""
    results = campaign.get_campaign_orders_by_megaphone_ids(['mp1'])['items']
    assert len(results) == 1
    assert results[0]['name'] == 'order 1'
    assert results[0]['network_ids'] == [1]


def test_get_campaign_orders_by_megaphone_ids_network_admin(monkeypatch, mock_current_network_admin_user):
    """Test get campaign orders by ids method for network admin."""
    results = campaign.get_campaign_orders_by_megaphone_ids(['mp1', 'mp2'])['items']
    assert len(results) == 1
    assert results[0]['name'] == 'order 1'


def test_get_campaign_orders_by_megaphone_ids(monkeypatch, mock_current_admin_user):
    """Test get campaign orders by ids method."""
    results = campaign.get_campaign_orders_by_megaphone_ids(['mp1', 'mp2', 'mp3'])['items']
    assert len(results) == 3
    assert results[0]['name'] == 'order 1'
    assert results[1]['name'] == 'order 2'
    assert results[2]['name'] == 'order 3'


def test_get_campaign_orders_by_episode_ids_no_access(mock_current_user):
    """Test get_campaign_orders_by_episode_ids no access."""
    with pytest.raises(OwsError) as err:
        campaign.get_campaign_orders_by_episode_ids([1, 2, 3, 4])
    assert err.value.status == 403


def get_advertisements_by_megaphone_ids(monkeypatch):
    """Test get advertisements by megaphone ids."""
    advertisement_data = dict(
        id=1,
        insertion_point='pre',
        pos=0,
        audio_file='https://megaphone-mock.s3.amazonaws.com/advertisements/14b05686-bc8d-11ea-8c9d.mp3',
        campaign_order_megaphone_id=1,
    )
    monkeypatch.setattr(
        advertisement_model, 'get_advertisements_by_megaphone_ids', MagicMock(
            return_value={'items': [advertisement_data]}))

    result = campaign.get_advertisements_by_megaphone_ids(['14b05686-mock-11ea-8c9d-d73ed5ecmock'])
    assert result == advertisement_data


def test_get_podcast_upcoming_sold_percent_by_ids_no_access(mock_current_user):
    """Test get_podcast_upcoming_sold_percent_by_ids no access."""
    with pytest.raises(OwsError) as err:
        campaign.get_podcast_upcoming_sold_percent_by_ids([1, 2])
    assert err.value.status == 403


def test_get_podcast_upcoming_sold_percent_by_ids(mock_current_user):
    """Test get_podcast_upcoming_sold_percent_by_ids."""
    tomorrow = (datetime.date.today() + datetime.timedelta(days=1)).strftime('%Y-%m-%dT12:00:00.000Z')
    episode_model.update_episode(1, {'published_date': tomorrow})
    episode_model.update_episode(2, {'published_date': tomorrow})

    result = campaign.get_podcast_upcoming_sold_percent_by_ids([1])['items']
    assert result == [{'id': 1, 'upcoming_sold_percent': 33}]


def test_get_podcast_upcoming_sold_percent_by_ids_zero_planned(mock_current_user):
    """Test get_podcast_upcoming_sold_percent_by_ids none planned."""
    tomorrow = (datetime.date.today() + datetime.timedelta(days=1)).strftime('%Y-%m-%dT12:00:00.000Z')
    episode_model.update_episode(1, {'published_date': tomorrow, 'planned_pre_roll_count': 0,
                                     'planned_mid_roll_count': 0, 'planned_post_roll_count': 0})
    result = campaign.get_podcast_upcoming_sold_percent_by_ids([1])['items']
    assert result == [{'id': 1, 'upcoming_sold_percent': None}]


def test_advertisements_with_show_ad_name(monkeypatch):
    """Test get advertisements with podcast_show_advertisement_name ff turned on."""
    advertisements = [
        {
            'id': 1,
            'orderId': 1,
            'insertionPoint': 'pre',
            'position': 1,
            'audioFile': 'abc.mp3',
            'displayName': 'ad 1'
        }
    ]

    monkeypatch.setattr(ApiCampaign, 'get_all_advertisements', MagicMock(return_value=advertisements))
    monkeypatch.setattr(advertisement_model, 'create_or_update_advertisements', MagicMock())
    result = campaign.advertisements(1, 1)
    advertisement_model.create_or_update_advertisements.assert_called_once_with([
        {
            'id': 1,
            'order_id': 1,
            'insertion_point': 'pre',
            'pos': 1,
            'audio_file': 'abc.mp3',
            'name': 'ad 1'
        }
    ], 1)
    assert result == advertisements