"""Fixtures for testing."""
# flake8: noqa
from collections import OrderedDict
import json
from types import SimpleNamespace

from integration_scripts.general_use import sanitize_json_dumps
from constants import database as db_consts

from unittest.mock import MagicMock
import pytest


# xlsx_to_pandas.py
@pytest.fixture
def test_track_list_csv():
    """Fixture for labels."""
    return [
        '/file1.csv', '/file2.csv', '/file_3.csv'
    ]


@pytest.fixture
def test_track_list_xlsx():
    """Fixture for labels."""
    return [
        '/file1.xlsx', '/file2.xlsx', '/file_3.xlsx'
    ]


@pytest.fixture
def test_s3_track_list_clean():
    """Fixture for labels."""
    return [
        SimpleNamespace(key='bucket/path1/file_1.csv'),
        SimpleNamespace(key='bucket/path1/file_2.csv'),
        SimpleNamespace(key='bucket/path2/file_3.csv')
    ]


@pytest.fixture
def test_s3_track_list_mixed():
    """Fixture for labels."""
    return [
        SimpleNamespace(key='bucket/path1/file_1.xlsx'),
        SimpleNamespace(key='bucket/path2/file_2.csv'),
        SimpleNamespace(key='bucket/path2/file_3'),
        SimpleNamespace(key='bucket/path2/path3/'),
        SimpleNamespace(key='bucket/path2/path3/file_4.csv'),
        SimpleNamespace(key='bucket/path2/path3/file_5.txt'),
    ]


# previous
@pytest.fixture
def label_list():
    """Fixture for labels."""
    return [
        1000, 2000, 3000
    ]


@pytest.fixture
def test_label_id(num=None):
    """Fixture for labels."""
    if not num:
        num = 1

    return str(int(num) * 1000)


@pytest.fixture
def single_release_id():
    """Fixture for a release_id."""
    return '123456'


@pytest.fixture
def snowflake_release_response():
    """Response from db when searching for label_id give release_id."""
    return [
        {
            'orchlabelid': 1000,
            'data': 'abcdefg'
        }
    ]


@pytest.fixture
def vector_api_code():
    """Mock vapi access code."""
    return '1234567'


@pytest.fixture
def test_session_id():
    """Arbitrary session string."""
    return '12345678900987654321'


@pytest.fixture
def bulk_upload_rows(num=None):
    """Fake rows from the bulk uploader."""
    if not num:
        num = 1

    num = str(num)

    return [
        {
            db_consts.release_name: 'Release Name {}'.format(num.zfill(2)),
            db_consts.project_code: 'PROJECT{}'.format(num.zfill(2)),
            db_consts.product_code: 'PRODUCT{}'.format(num.zfill(2))
        }
    ]


@pytest.fixture
def test_url():
    """Test URL for bulk upload endpoint."""
    return 'vapi.example.com'


@pytest.fixture
def test_request(bulk_upload_rows):
    """A request based on rows from the bulk uploader."""
    code = '{}_____{}'.format(
        bulk_upload_rows[0][db_consts.project_code],
        bulk_upload_rows[0][db_consts.product_code])

    return {
        code: bulk_upload_rows[0]
    }


@pytest.fixture
def test_request_list(test_request):
    """Returns a request as a list."""
    return [test_request]


@pytest.fixture
def chunk_requests_response():
    """Response from the chunk_requests function."""
    return [{
        'data': OrderedDict(
            [
                ('PROJECT01_____PRODUCT01',
                 [
                     {
                         'excel_line_number': 2,
                         'Folder Name / Project Code': 'PROJECT01',
                         'Product Code': 'PRODUCT01',
                         'Release Name': 'Release Name 01'
                     }
                 ]
                 )
            ]
        ),
        'access_token': '1234567'
    }]


@pytest.fixture
def test_full_request_dict(test_label_id, vector_api_code, test_request):
    """Dict containing all elements of request needed."""
    return {
        test_label_id: [{
            'access_token': vector_api_code,
            'data': sanitize_json_dumps(test_request)
        }]
    }


@pytest.fixture
def test_full_request_list(test_label_id, vector_api_code, test_request):
    """Dict containing all elements of request needed."""
    return [
        {
            'access_token': vector_api_code,
            'data': sanitize_json_dumps(test_request)
        }
    ]


@pytest.fixture
def test_multiprocess_param(test_session_id, test_label_id, test_request):
    """Parameters fed to the multiprocessing method."""
    return [{
        'request_num': 1,
        'session_id': test_session_id,
        'name': 'Request #{} of {} for label {}'.format(
            1, 1, test_label_id),
        'label_chunk_request': test_request,
        'label_id': test_label_id
    }]


@pytest.fixture
def test_full_request(test_label_id, vector_api_code, test_request, test_url):
    """Parameters for the requests.post() function."""
    return {
        'params': {
            'access_token': vector_api_code,
            'XDEBUG_SESSION_START': 'devorch',
            'errorMode': '1',
            'processMode': 'mass_ingest'
        },
        'data': {
            'isMechadmin': '',
            'data': json.dumps(test_request, ensure_ascii=False),
            'data_format': 'json'
        },
        'url': 'http://{}/bulkupload/post'.format(test_url)
    }


@pytest.fixture
def test_bulk_upload_response():
    """An example response."""
    return_val = SimpleNamespace()

    return_val.text = """
         {
          "envelope": {
            "request": "",
            "header": {
              "httpStatusCode": 200,
              "baseUrl": "vapi.example.com",
              "apiVersion": "1.0"
            },
            "response": {
              "new_releases": {
                "28699_____VJ04007-2": {
                  "project_id": "3977968",
                  "Artist Name": "Elektro Ompaniet",
                  "release_id": 2381877,
                  "Release Name": "Toskedalen",
                  "folder_name": "28699",
                  "Release Date": "2004-04-06"
                }
              },
              "error": {
                "26847_____VJ980052": {
                  "1_11_82": {
                    "Duplicate Tracks": "Duplicate Track: Track level fields are identical to Volume 1 - Track 10"
                  },
                  "data": {
                    "release_name": "Tid A Hausta Inn",
                    "line_numbers": [
                      74,
                      75,
                      76,
                      77,
                      78,
                      79,
                      80,
                      81,
                      82,
                      83,
                      84,
                      85,
                      86,
                      87,
                      88,
                      89,
                      90,
                      91,
                      92
                    ],
                    "artist_name": "Kari Bremnes & Lars Klevestrand",
                    "vendor_catalog_number": 26847
                  }
                }
              }
            }
          }
        }
    """

    return return_val


@pytest.fixture
def test_response_data():
    """An example response."""
    return {
        'new_releases': {
            '28699_____VJ04007-2': {
                'project_id': '3977968',
                'Artist Name': 'Elektro Ompaniet',
                'release_id': 2381877,
                'Release Name': 'Toskedalen',
                'folder_name': '28699',
                'Release Date': '2004-04-06'
            }
        },
        'error': {
            '26847_____VJ980052': {
                '1_11_82': {
                    'Duplicate Tracks': 'Duplicate Track: Track level fields are identical to Volume 1 - Track 10'  # noqa
                },
                'data': {
                    'release_name': 'Tid A Hausta Inn',
                    'line_numbers': [
                        74,
                        75,
                        76,
                        77,
                        78,
                        79,
                        80,
                        81,
                        82,
                        83,
                        84,
                        85,
                        86,
                        87,
                        88,
                        89,
                        90,
                        91,
                        92
                    ],
                    'artist_name': 'Kari Bremnes & Lars Klevestrand',
                    'vendor_catalog_number': 26847
                }
            }
        }
    }


@pytest.fixture
def test_params(test_label_id, test_session_id):
    """Params for process_bulk_upload."""
    return {
        'orchard_vendor_id': test_label_id,
        'session_id': test_session_id,
        'request_num': 1
    }


@pytest.fixture
def test_audio_backup_list():
    return [
        '12345_1_1.wav',
        '12345_1_2.wav',
        '12345_1_3.wav',
        '12345_1_4.wav',
        '12345_1_5.wav',
        '12345_1_6.wav',
        '12345_1_7.wav',
    ]


@pytest.fixture
def test_real_response():
    """An example real response."""
    return \
    {
      'envelope': {
        'request': '/bulkupload/post?processMode=mass_ingest&errorMode=1&access_token=50487ec72aff5a58af9ea3f6293f33ad&XDEBUG_SESSION_START=devorch',  # noqa
        'header': {
          'httpStatusCode': 200,
          'baseUrl': 'vapi.example.com',
          'apiVersion': '1.0'
        },
        'response': {
          'updated_releases': {
            '28699_____VJ04007-2': {
              'project_id': '3977968',
              'Artist Name': 'Elektro Ompaniet',
              'release_id': 2381877,
              'Release Name': 'Toskedalen',
              'folder_name': '28699',
              'Release Date': '2004-04-06'
            },
            '29074_____VJ04008': {
              'project_id': '3977962',
              'Artist Name': 'Svein Folkvord',
              'release_id': 2381871,
              'Release Name': 'Across',
              'folder_name': '29074',
              'Release Date': '2004-11-18'
            },
            '25321_____VJ18962': {
              'project_id': '3977964',
              'Artist Name': 'Fliflet',
              'release_id': 2381873,
              'Release Name': 'Hamre Energiforsyning / Moro Post Mortem - Live',  # noqa
              'folder_name': '25321',
              'Release Date': '2000-08-30'
            },
            '30918_____VJ060102': {
              'project_id': '3977969',
              'Artist Name': 'Sonic Stories',
              'release_id': 2381878,
              'Release Name': 'Feels Like Night',
              'folder_name': '30918',
              'Release Date': '2006-04-18'
            },
            '30873_____VJ060112': {
              'project_id': '3977966',
              'Artist Name': 'Terje Isungset',
              'release_id': 2381875,
              'Release Name': 'Dider Petit',
              'folder_name': '30873',
              'Release Date': '2006-04-03'
            },
            '28496_____VJ03006-2': {
              'project_id': '3977967',
              'Artist Name': 'Tore Brunborg',
              'release_id': 2381876,
              'Release Name': 'Gravity',
              'folder_name': '28496',
              'Release Date': '2003-12-17'
            },
            '25320_____VJ980042': {
              'project_id': '3977970',
              'Artist Name': 'Opheim, Kjellemyr, Mjølsnes, Jørgensen, Apeland',
              'release_id': 2381879,
              'Release Name': 'Fryd',
              'folder_name': '25320',
              'Release Date': '2000-08-30'
            },
            '31254_____VJ060122': {
              'project_id': '3977963',
              'Artist Name': 'Subtrio',
              'release_id': 2381872,
              'Release Name': 'Subtrio',
              'folder_name': '31254',
              'Release Date': '2006-08-02'
            },
            '30405_____VJO4007-3': {
              'project_id': '3977965',
              'Artist Name': 'Elektro Ompaniet',
              'release_id': 2381874,
              'Release Name': 'Electromecanibalism',
              'folder_name': '30405',
              'Release Date': '2005-11-21'
            }
          },
          'error': {
            '26847_____VJ980052': {
              '1_11_82': {
                'Duplicate Tracks': 'Duplicate Track: Track level fields are identical to Volume 1 - Track 10'  # noqa
              },
              'data': {
                'release_name': 'Tid Å Hausta Inn',
                'line_numbers': [
                  74,
                  75,
                  76,
                  77,
                  78,
                  79,
                  80,
                  81,
                  82,
                  83,
                  84,
                  85,
                  86,
                  87,
                  88,
                  89,
                  90,
                  91,
                  92
                ],
                'artist_name': 'Kari Bremnes & Lars Klevestrand',
                'vendor_catalog_number': 26847
              }
            }
          }
        }
      }
    }


@pytest.fixture
def test_actions_values():
    return {
        '12345_001_001.wav': 'completed',
        '12345_001_002.wav': 'completed',
        '12345_001_003.wav': 'completed',
        '12345_001_004.wav': 'completed',
        '12345_001_005.wav': 'failed',
    }


@pytest.fixture
def test_actions_empty():
    return {}


@pytest.fixture
def test_asset_list():
    return []


@pytest.fixture
def test_empty_list():
    return []


@pytest.fixture
def test_audio_results():
    return [
        {'phono_audio_file': '12345_001_001.wav'},
        {'phono_audio_file': '12345_001_002.wav'},
        {'phono_audio_file': '12345_001_003.wav'},
        {'phono_audio_file': '12345_001_004.wav'},
        {'phono_audio_file': '12345_001_005.wav'},
    ]


@pytest.fixture
def test_list_5_items():
    return [
        '12345_001_001.wav',
        '12345_001_002.wav',
        '12345_001_003.wav',
        '12345_001_004.wav',
        '12345_001_005.wav',
    ]


@pytest.fixture
def test_list_4_items():
    return [
        '12345_001_001.wav',
        '12345_001_002.wav',
        '12345_001_003.wav',
        '12345_001_004.wav',
    ]


@pytest.fixture
def test_sentry(mocker):
    """Return a mocked Sentry object"""
    return mocker.patch(
        'connectors.sentry.sentry_client.captureMessage')


# @pytest.fixture
# def test_print_log(mocker):
#     """Return a mocked logger object"""
#     return mocker.patch('util.general_use.print_log')


@pytest.fixture
def test_copy_from_backoff(mocker):
    return mocker.patch(
        'util.s3_backoff_utils.copy_from_backoff')


@pytest.fixture
def test_copy_from_backoff_exception(mocker):
    return mocker.patch(
        'util.s3_backoff_utils.copy_from_backoff', side_effect=Exception())


@pytest.fixture
def test_head_object_backoff(mocker):
    return mocker.patch(
        'util.s3_backoff_utils.head_object_backoff')


@pytest.fixture
def test_head_object_backoff_exception(mocker):
    return mocker.patch(
        'util.s3_backoff_utils.head_object_backoff', side_effect=Exception())


@pytest.fixture
def test_download_fileobj_backoff(mocker):
    return mocker.patch(
        'util.s3_backoff_utils.download_fileobj_backoff')


@pytest.fixture
def test_download_fileobj_backoff_exception(mocker):
    return mocker.patch(
        'util.s3_backoff_utils.download_fileobj_backoff',
        side_effect=Exception())


@pytest.fixture
def test_delete_backoff(mocker):
    return mocker.patch('util.s3_backoff_utils.delete_backoff')


@pytest.fixture
def test_delete_backoff_exception(mocker):
    return mocker.patch(
        'util.s3_backoff_utils.delete_backoff', side_effect=Exception())


@pytest.fixture
def test_image(mocker):
    mock_image = MagicMock()
    return mocker.patch(
         'PIL.Image.open', return_value=mock_image)


@pytest.fixture
def test_image_exception(mocker):
    return mocker.patch(
        'PIL.Image.open', side_effect=Exception())


# @pytest.fixture
# def test_get_s3_file_key(mocker):
#     return mocker.patch('util.file_utils.get_s3_file_key')

@pytest.fixture
def test_audio_asset_list():
    """Test fixture for audio assets."""
    return [
        {
            'pf_relid': '12345',
            'orch_upc': '12345678909',
            'volume': '1',
            'track': '1',
            'file_name': 'Phonofile_audio/12345_001_001.wav'
        },
        {
            'pf_relid': '12345',
            'orch_upc': '12345678909',
            'volume': '1',
            'track': '2',
            'file_name': 'Phonofile_audio/12345_001_002.wav'
        },
        {
            'pf_relid': '22345',
            'orch_upc': '22345678909',
            'volume': '1',
            'track': '1',
            'file_name': 'Phonofile_audio/22345_001_001.wav'
        }
    ]


@pytest.fixture(scope='class')
def test_audio_asset_list_class(request):
    """Test fixture for audio assets."""
    request.cls.test_audio_asset_list_class = [
        {
            'pf_relid': '12345',
            'orch_upc': '12345678909',
            'volume': '1',
            'track': '1',
            'file_name': 'Phonofile_audio/12345_001_001.wav'
        },
        {
            'pf_relid': '12345',
            'orch_upc': '12345678909',
            'volume': '1',
            'track': '2',
            'file_name': 'Phonofile_audio/12345_001_002.wav'
        }
    ]


@pytest.fixture(scope='class')
def test_preprocess(request):
    process_list = {
        '12345_001_001.wav': 'original',
        '12345_001_002.wav': 'original',
    }
    request.cls.test_preprocess = ([], process_list, 2, 1, False)


@pytest.fixture
def test_cover_asset_list():
    """Test fixture for cover assets."""
    return [
        {
            'pf_relid': '12345',
            'orch_upc': '12345678909',
            'file_name': 'Phonofile_cover/12345.tif'
        },
        {
            'pf_relid': '22345',
            'orch_upc': '22345678909',
            'file_name': 'Phonofile_cover/22345.tif'
        }
    ]


@pytest.fixture
def test_actions_list():
    """Test fixture for action list."""
    return {
        'file_1': 'completed',
        'file_2': 'skipped',
        'file_3': 'restored',
        'file_4': 'failed',
        'file_5': 'missing',
        'file_6': 'file_count_mismatch',
        'file_7': 'undefined'
    }

#
# @pytest.fixture(scope='class')
# def test_filter_list_original(request):
#     """Test fixture for returned filter list."""
#     release_id = 12345
#     obj_list = list()
#
#     for i in range(5):
#         key = '{}/{}_{}_{}.file'.format(release_id, release_id, 1, i)
#         obj_list.append(SimpleNamespace(key=key))
#
#     request.cls.test_filter_list_original = obj_list


@pytest.fixture(scope='class')
def test_filter_list(request):
    """Test fixture for returned filter list."""
    def _test_filter_list(*args, **kwargs):
        release_id = 12345
        obj_list = list()

        for i in range(kwargs['request_num']):
            key = '{}/{}_{}_{}.file'.format(release_id, release_id, 1, i)
            obj_list.append(SimpleNamespace(key=key))

        return obj_list

    request.cls.test_filter_list = _test_filter_list


@pytest.fixture
def test_to_excel_return_values():
    """Values for returned for mock_to_excel method."""
    return [
        ('file_name_01', 'unused'),
        ('file_name_02', 'unused'),
        ('file_name_03', 'unused')
    ]


@pytest.fixture
def test_to_excel_results():
    """Results for mock_to_excel method."""
    return (
        [
            'file_name_01',
            'file_name_02',
            'file_name_03',
        ],
        [
            'unused',
            'unused',
            'unused'
        ]
    )