"""Helper utils for integration tests."""

import os
import re

import boto3
import requests

from tests.integration import config
from tests.integration.consts import api
import tests.integration.test_helpers.api as api_calls


def validate_response_status(response, expect_status=api.STATUS_OK):
    """Validate response for expected status and return body as json."""
    assert response.status_code == expect_status, \
        'Expected status_code to be {}, was {}, body: {}'.format(
            expect_status, response.status_code, response.json())
    return response.json()


def assert_has_keys(source_object, keys_list):
    """Validate that key exists in object.

    Args:
        source_object (dict): object that must contain target keys
        keys_list (iterable): list of keys to compare
    """
    for key in keys_list:
        assert key in source_object, \
            'Expected {} key to exist in {}'.format(key, source_object)


def pattern_matched(pattern, string):
    """Validate regexp pattern matching."""
    return re.match(pattern, string)


def omit_keys(source_object, keys):
    """Return source_object without keys."""
    return {k: value for k, value in source_object.items() if k not in keys}


def assert_url_accessible(url):
    """Validate that url is accessible."""
    response = requests.get(url)
    assert response.status_code == api.STATUS_OK, \
        'Expected 200 code for {}, got {}'.format(
            url, response.status_code
        )


def create_asset_final_from_asset_upload(asset_upload):
    """Create and return final assets for given asset_upload."""
    asset_filename = asset_upload['filename']
    if asset_upload['asset_type'] in [api.ASSET_TYPE_JPG]:
        asset_type = asset_upload['asset_type']
        asset_subtype = 'xlarge_cover'
        asset_key = api.TEST_ASSET_JPG_FILENAME
    elif asset_upload['asset_type'] in [api.ASSET_TYPE_WAV]:
        asset_type = 'WAV'
        asset_subtype = None
        asset_key = api.TEST_ASSET_MP3_FILENAME
    else:
        asset_type = 'WAV'
        asset_subtype = None
        asset_key = api.TEST_ASSET_MP3_FILENAME

    final_assets = [
        {
            'asset_type': asset_type,
            'asset_subtype': asset_subtype,
            'key': asset_key,
            'duration': 900
        }
    ]

    response = api_calls.asset.post_final(asset_filename, final_assets)
    return validate_response_status(response)


def send_asset_status(filename, status):
    """Send status for given filename."""
    return validate_response_status(
        api_calls.asset.post_status(filename, status)
    )


def asset_podcast_url(filename):
    """Return full url for podcast cdn."""
    return 'https://{}/{}'.format(
        config.OUTPUT_PODCAST_CDN, filename
    )


def put_asset_to_s3(filename, upload_token_data, object_type, object_id):
    """Send asset to s3 bucket."""
    _, file_extension = os.path.splitext(filename)
    assert file_extension in ['.jpg', '.wav']
    if file_extension == '.jpg':
        content_type = 'image/jpeg'
        asset_type = 'JPG'
    elif file_extension == '.wav':
        content_type = 'audio/wav'
        asset_type = 'WAV'
    else:
        raise ValueError(f'Unsupported file extension {file_extension}')

    with open(os.path.join(config.BASE_DIR, 'assets', filename), 'rb') as file:
        content = file.read()
    assert len(content) > 0, 'Empty file'

    bucket = upload_token_data['bucket']
    filename_key = upload_token_data['filename']
    destination_filename = f'{filename_key}{file_extension}'
    credentials = upload_token_data['credentials']

    metadata = {
        'asset_type': asset_type,
        'object_id': str(object_id),
        'object_type': object_type,
        'original_filename': filename,
    }

    s3 = boto3.client(
        's3',
        aws_access_key_id=credentials['aws_access_key_id'],
        aws_secret_access_key=credentials['aws_secret_access_key'],
        aws_session_token=credentials['token'],
    )

    s3.put_object(
        Metadata=metadata,
        Bucket=bucket,
        Key=destination_filename,
        Body=content,
        ContentType=content_type
    )