"""Test transfer from s3 to storage."""

import importlib
import json
import os
from unittest.mock import call

import pytest

from video import config
from video.connectors import s3 as s3_connector
from video.constants import assets
from video.constants import job_io_fields
from video.constants import job_statuses
from video.logic.activities import transfer_from_s3_to_storage
from video.models import ows_video


@pytest.mark.parametrize((
    'test_description',
    'expected_windows_path',
    'expected_s3_bucket',
    'expected_s3_key'
), [
    (
        'start download',
        '{}/{}/4011200296908/4011200296908_1_1.mov',
        'test-orcd-video-assets',
        'mezzanine/prores/5614/0c399362-e2bd-11e8-bbe8-acbc32b98ae7.mov'
    )
])
def test_transfer_prores_from_s3_to_ripper(
        mocker, tmpdir, test_description, expected_windows_path,
        expected_s3_bucket, expected_s3_key):
    """Test transfer_from_s3_to_storage."""
    mount_dir = tmpdir.mkdir('foo')
    ripper_dir = 'bar'
    upc = '4011200296908'

    os.mkdir('{}/{}'.format(mount_dir, ripper_dir))
    os.mkdir('{}/{}/{}'.format(mount_dir, ripper_dir, upc))

    mocker.patch.object(ows_video, 'set_job_fields')
    mocker.patch.object(
        s3_connector,
        'get_s3_client',
        autospec=True,
    )
    mocker.patch.object(
        config, 'RIPPER_OUTPUT_VIDEO_WINDOWS_MOUNT_PATH', mount_dir)
    mocker.patch.object(
        config, 'OUTPUT_VIDEO_PRORES_MEZZANINE_DIR', ripper_dir)
    mocker.patch.object(job_io_fields, 'UPC', upc)
    mocker.patch.object(os, 'mkdir', side_effect=FileExistsError)

    importlib.reload(transfer_from_s3_to_storage)

    test_inputs = {
        job_io_fields.TRANSFER_PRORES_FROM_S3_TO_RIPPER_JOB_ID: 123,
        job_io_fields.PRORES_MEZZANINE_OUTPUT_S3_KEY: expected_s3_key,
        job_io_fields.UPC: upc
    }
    outputs = transfer_from_s3_to_storage.transfer_prores_from_s3_to_ripper(
        test_inputs)

    os.mkdir.assert_called_once_with('{}/{}/{}'.format(
        mount_dir, config.OUTPUT_VIDEO_PRORES_MEZZANINE_DIR, upc))

    assert os.path.exists(
        os.path.join(mount_dir, ripper_dir, upc, '4011200296908.done'))
    assert outputs == {}
    (s3_connector
        .get_s3_client
        .return_value
        .download_file
        .assert_called_once_with(
            expected_s3_bucket, expected_s3_key,
            expected_windows_path.format(mount_dir, ripper_dir)))
    ows_video.set_job_fields.assert_called_with({'id': 123, 'outputs': {}})


@pytest.mark.parametrize((
    'test_description',
    'expected_windows_path',
    'expected_s3_bucket',
    'expected_s3_key'
), [
    (
        'start download',
        '{}/{}/3011200296908_1_1_V337.mp4'.format(
            config.RIPPER_OUTPUT_VIDEO_WINDOWS_MOUNT_PATH,
            config.OUTPUT_VIDEO_H264_MEZZANINE_DIR),
        'test-orcd-video-assets',
        'mezzanine/h.264/5614/0c399362-e2bd-11e8-bbe8-acbc32b98ae7.mp4'
    )
])
def test_transfer_h264_from_s3_to_ripper(
        mocker, test_description, expected_windows_path,
        expected_s3_bucket, expected_s3_key):
    """Test transfer_from_s3_to_storage."""
    mocker.patch.object(ows_video, 'set_job_fields')
    mocker.patch.object(
        s3_connector,
        'get_s3_client',
        autospec=True,
    )
    mocker.patch.object(os, 'mkdir', side_effect=FileExistsError)
    importlib.reload(transfer_from_s3_to_storage)
    test_inputs = {
        job_io_fields.TRANSFER_H264_FROM_S3_TO_RIPPER_JOB_ID: 123,
        job_io_fields.H264_MEZZANINE_OUTPUT_S3_KEY: expected_s3_key,
        job_io_fields.UPC: 3011200296908,
        job_io_fields.PRORES_MEZZANINE_METADATA: json.dumps({
            job_io_fields.VIDEO_STREAM_WIDTH_PIXELS: 960,
            job_io_fields.VIDEO_STREAM_HEIGHT_PIXELS: 960
        })
    }
    outputs = transfer_from_s3_to_storage.transfer_h264_from_s3_to_ripper(
        test_inputs)

    os.mkdir.assert_called_once_with('{}/{}'.format(
        config.RIPPER_OUTPUT_VIDEO_WINDOWS_MOUNT_PATH,
        config.OUTPUT_VIDEO_H264_MEZZANINE_DIR))

    assert outputs == {}
    (s3_connector
        .get_s3_client
        .return_value
        .download_file
        .assert_called_once_with(
            expected_s3_bucket, expected_s3_key, expected_windows_path))
    ows_video.set_job_fields.assert_called_with({'id': 123, 'outputs': {}})


@pytest.mark.parametrize((
    'test_description',
    'thumbnail_path',
    'expected_s2_s3_key',
    'expected_s2_windows_path',
    'expected_s5_s3_key',
    'expected_s5_windows_path',
), [
    (
        'start download',
        'mezzanine/tiff/5614/123456',
        'mezzanine/tiff/5614/123456_s2.tif',
        '{}/{}/3011200296908_S2.tif'.format(
            config.RIPPER_OUTPUT_THUMBNAIL_WINDOWS_MOUNT_PATH,
            config.OUTPUT_TIFF_DIR),
        'mezzanine/tiff/5614/123456_s5.tif',
        '{}/{}/3011200296908_S5.tif'.format(
            config.RIPPER_OUTPUT_THUMBNAIL_WINDOWS_MOUNT_PATH,
            config.OUTPUT_TIFF_DIR),
    )
])
def test_transfer_tiff_thumbnail_from_s3_to_ripper(
        mocker, test_description, thumbnail_path, expected_s2_windows_path,
        expected_s2_s3_key, expected_s5_windows_path, expected_s5_s3_key):
    """Test transfer_tiff_thumbnail_from_s3_to_ripper."""
    mocker.patch.object(ows_video, 'set_job_fields')
    mocker.patch.object(
        s3_connector,
        'get_s3_client',
        autospec=True,
    )
    mocker.patch.object(os, 'mkdir', side_effect=FileExistsError)
    importlib.reload(transfer_from_s3_to_storage)
    test_inputs = {
        job_io_fields.TRANSFER_TIFF_THUMBNAIL_FROM_S3_TO_RIPPER_JOB_ID: 123,
        job_io_fields.TIFF_THUMBNAIL_S3_KEY: thumbnail_path,
        job_io_fields.UPC: 3011200296908
    }
    outputs = (
        transfer_from_s3_to_storage
        .transfer_tiff_thumbnail_from_s3_to_ripper(test_inputs))

    os.mkdir.assert_called_once_with('{}/{}'.format(
        config.RIPPER_OUTPUT_THUMBNAIL_WINDOWS_MOUNT_PATH,
        config.OUTPUT_TIFF_DIR))
    assert outputs == {}
    (s3_connector
        .get_s3_client
        .return_value
        .download_file
        .assert_has_calls([
            call(
                assets.VIDEO_S3_BUCKET, expected_s2_s3_key,
                expected_s2_windows_path),
            call(
                assets.VIDEO_S3_BUCKET, expected_s5_s3_key,
                expected_s5_windows_path),
        ]))
    ows_video.set_job_fields.assert_called_with({'id': 123, 'outputs': {}})


@pytest.mark.parametrize(
    'task, job_key, is_delivery_ready, expected_change_job_status_calls, '
    'result_key, is_asset_ready_calls',
    [
        (transfer_from_s3_to_storage.is_ripper_mezzanine_processing_done,
         job_io_fields.TRANSFER_PRORES_FROM_S3_TO_RIPPER_JOB_ID,
         True,
         [call(123, job_statuses.COMPLETE)],
         job_io_fields.IS_RIPPER_MEZZANINE_PROCESSING_DONE,
         [call(3011200296908, transfer_from_s3_to_storage.ASSET_TYPE_PRORES)]
         ),
        (transfer_from_s3_to_storage.is_ripper_mezzanine_processing_done,
         job_io_fields.TRANSFER_PRORES_FROM_S3_TO_RIPPER_JOB_ID,
         False,
         [],
         job_io_fields.IS_RIPPER_MEZZANINE_PROCESSING_DONE,
         [call(3011200296908, transfer_from_s3_to_storage.ASSET_TYPE_PRORES)]
         ),
        (transfer_from_s3_to_storage.is_ripper_h264_processing_done,
         job_io_fields.TRANSFER_H264_FROM_S3_TO_RIPPER_JOB_ID,
         True,
         [call(123, job_statuses.COMPLETE)],
         job_io_fields.IS_RIPPER_H264_PROCESSING_DONE,
         [call(3011200296908, transfer_from_s3_to_storage.ASSET_TYPE_H264)]
         ),
        (transfer_from_s3_to_storage.is_ripper_tiff_thumbnail_processing_done,
         job_io_fields.TRANSFER_TIFF_THUMBNAIL_FROM_S3_TO_RIPPER_JOB_ID,
         True,
         [call(123, job_statuses.COMPLETE)],
         job_io_fields.IS_RIPPER_TIFF_THUMBNAIL_PROCESSING_DONE,
         [call(3011200296908, transfer_from_s3_to_storage.ASSET_TYPE_TIFF_S2),
          call(3011200296908, transfer_from_s3_to_storage.ASSET_TYPE_TIFF_S5)]
         ),
    ])
def test_is_ripper_mezzanine_processing_done(
        mocker, task, job_key, is_delivery_ready,
        expected_change_job_status_calls, result_key, is_asset_ready_calls):
    """Test is_ripper_mezzanine_processing_done."""
    mocker.patch.object(
        ows_video,
        'is_asset_ready_for_delivery',
        return_value=is_delivery_ready)

    mocker.patch.object(ows_video, 'change_job_status')
    test_inputs = {
        job_key: 123,
        job_io_fields.UPC: 3011200296908
    }

    outputs = task(test_inputs)

    assert ows_video.change_job_status.call_count == len(
        expected_change_job_status_calls)
    ows_video.change_job_status.assert_has_calls(
        expected_change_job_status_calls)
    assert ows_video.is_asset_ready_for_delivery.call_count == len(
        is_asset_ready_calls)
    ows_video.is_asset_ready_for_delivery.assert_has_calls(
        is_asset_ready_calls)

    assert outputs == {
        result_key: is_delivery_ready
    }