import pytest
from requests.models import Response

from unittest.mock import Mock

from labelaudit.connectors import api_client as api_connector
from labelaudit.lib.vapi.api_client import ApiClient
from labelaudit.logic import audit_release

base_url = 'https://api.notreal.com'
access_token = 'not-a-real-token-either'
api_client = ApiClient(base_url, access_token)
audit_id = 1
offset = 0
audit_release_id = 1


@pytest.fixture
def releases_json():
    return {
        'youtubeAuditReleases': [
            {
                'youtubeAuditReleaseId': '1',
                'youtubeAuditId': '1',
                'releaseId': '12',
                'assetCmsAccountId': None,
                'isCmsAccountAsset': None,
                'isYoutubeAsset': None,
                'auditStatus': 'pending',
                'numAssets': None,
                'error': None,
                'lastUpdated': '2015-05-26 11:56:49'
            }
        ]
    }


def updated_release_json():
    return {
        'youtubeAuditRelease': {
            'youtubeAuditReleaseId': 85177,
            'isCmsAccountAsset': 'Y',
            'isYoutubeAsset': 'Y',
            'numAssets': None,
            'auditStatus': 'pending',
            'error': None,
            'releaseId': 1369359,
            'youtubeAuditId': 7,
            'assetCmsAccountId': 1,
            'lastUpdated': '2015-06-24 11:50:56'
        }
    }


def audit_params():
    return {
        {
            'isCmsAccountAsset': 'Y',
            'isYoutubeAsset': 'Y',
            'assetCmsAccountId': '1'
        }
    }


@pytest.fixture
def vapi_client(monkeypatch):
    base_url = 'https://api.notreal.com'
    access_token = 'not-a-real-token-either'
    api_client = ApiClient(base_url, access_token)
    monkeypatch.setattr(
        api_connector, 'get_client', Mock(return_value=api_client))
    return api_client


@pytest.fixture(params=[201, 200])
def good_status(request):
    return request.param


def fake_result(monkeypatch, vapi_status, vapi_json=None):
    vapi_response = Response()
    vapi_response.status_code = vapi_status
    monkeypatch.setattr(vapi_response, 'json', Mock(return_value=vapi_json))
    return vapi_response


def test_set_audit_releases_success(monkeypatch, good_status, vapi_client):
    successful_result = {'youtubeAuditQualifiedReleasesCount': 100}
    response = fake_result(monkeypatch, good_status, successful_result)
    monkeypatch.setattr(vapi_client, 'post', Mock(return_value=response))
    result = audit_release.set_audit_releases(audit_id)
    assert result.status == good_status


def test_set_audit_releases_returns_count(monkeypatch, vapi_client):
    successful_result = {'youtubeAuditQualifiedReleasesCount': 100}
    response = fake_result(monkeypatch, 201, successful_result)
    monkeypatch.setattr(vapi_client, 'post', Mock(return_value=response))
    result = audit_release.set_audit_releases(audit_id)
    assert result.message == 100


def test_set_audit_releases_handles_not_found(monkeypatch, vapi_client):
    failed_result = {'fault': {'id': 'Not found'}}
    response = fake_result(monkeypatch, 404, failed_result)
    monkeypatch.setattr(vapi_client, 'post', Mock(return_value=response))
    result = audit_release.set_audit_releases(audit_id)
    assert result.status == 404


def test_set_audit_releases_handles_error(monkeypatch, vapi_client):
    failed_result = {'fault': {'Something went wrong'}}
    response = fake_result(monkeypatch, 500, failed_result)
    monkeypatch.setattr(vapi_client, 'post', Mock(return_value=response))
    result = audit_release.set_audit_releases(audit_id)
    assert result.status == 500


def test_fetch_audit_releases_success(monkeypatch, vapi_client, releases_json):
    successful_result = releases_json
    response = fake_result(monkeypatch, 200, successful_result)
    monkeypatch.setattr(vapi_client, 'get', Mock(return_value=response))
    result = audit_release.fetch_audit_releases(audit_id, offset)
    assert result.status == 200


def test_fetch_audit_releases_handles_not_found(monkeypatch, vapi_client):
    failed_result = {'fault': {'id': 'Not found'}}
    response = fake_result(monkeypatch, 404, failed_result)
    monkeypatch.setattr(vapi_client, 'get', Mock(return_value=response))
    result = audit_release.fetch_audit_releases(audit_id, offset)
    assert result.status == 404


def test_fetch_audit_releases_handles_error(monkeypatch, vapi_client):
    failed_result = {'fault': {'Something went wrong'}}
    response = fake_result(monkeypatch, 500, failed_result)
    monkeypatch.setattr(vapi_client, 'get', Mock(return_value=response))
    result = audit_release.fetch_audit_releases(audit_id, offset)
    assert result.status == 500


def test_update_audit_release_success(monkeypatch, vapi_client):
    successful_result = updated_release_json
    response = fake_result(monkeypatch, 200, successful_result)
    monkeypatch.setattr(vapi_client, 'put', Mock(return_value=response))
    result = audit_release.update_audit_release(audit_release_id, audit_params)
    assert result.status == 200


def test_update_audit_handles_error(monkeypatch, vapi_client):
    failed_result = {'fault': {'Something went wrong'}}
    response = fake_result(monkeypatch, 500, failed_result)
    monkeypatch.setattr(vapi_client, 'put', Mock(return_value=response))
    result = audit_release.update_audit_release(audit_release_id, audit_params)
    assert result.status == 500