"""Functional tests for delete product handler."""
from datetime import datetime
import json

from owsrequest import request
from owsrequest import test_utils
import pytest

from product_digital.constants import services
from product_digital.models import rejection_notes
from product_digital.models import release_approval_queue
from product_digital.models import release_artist
from product_digital.models import release_grid
from product_digital.models import release_logging
from product_digital.models import release_manual_adjustment
from product_digital.models import release_status
from product_digital.models import release_subtitles
from product_digital.models import track
from tests.factories import release as release_factory
from tests.factories import release_subgenre as factory
from tests.testutils import db


@pytest.fixture
def test_release_subgenre():
    """Create a set of release subgenre data for testing."""
    return {
        'release_id': 12345,
        'subgenre_id': 5678,
        'upc': 123456789012}


@pytest.fixture
def upc():
    """Return a fake UPC."""
    return 123456789012


@pytest.fixture
def project_id():
    """Return a fake project_id."""
    return 123


@pytest.fixture
def role():
    """Return a fake role."""
    return 'natural horn'


@pytest.fixture
def release_approval_data():
    """Fake release_approval_id for testing."""
    return 123456


def setup_data(
    client,
    product_id,
    upc,
    role,
    test_release_subgenre,
    release_approval_data,
    account_type,
    account_id,
    project_id,
    valid_headers
):
    """Setup product related db data to be deleted."""
    existing_release = release_factory.ReleaseFactory.build(
        release_id=product_id, project_id=project_id
    )
    db.seed_models(existing_release)

    new_release_artist = release_artist.ReleaseArtist(
        release_id=product_id, upc=upc, role=role, artist_name='Charles Q.'
    )
    db.seed_models(new_release_artist)

    existing_rs = factory.ReleaseSubgenreFactory.build(**test_release_subgenre)
    db.seed_models(existing_rs)

    new_release_status = release_status.ReleaseStatus(
        release_id=product_id, status='label_processing',
        date=datetime.today(), changed_by=account_id, changed_by_type=account_type
    )
    db.seed_models(new_release_status)

    new_release_grid = release_grid.ReleaseGrid(
        release_id=product_id, product_no='abc', create_time=datetime.today()
    )
    db.seed_models(new_release_grid)

    client.post(
        '/product/{}/mkt_priority'.format(product_id),
        data=json.dumps({
            'country_id': 2,
            'priority': 'a',
        }),
        headers=valid_headers
    )

    new_release_logging = release_logging.ReleaseLogging(
        release_id=product_id, updated_timestamp=datetime.today()
    )
    db.seed_models(new_release_logging)

    new_release_manual_adjustment = release_manual_adjustment.ReleaseManualAdjustment(
        date_created=datetime.today(), created_by=179, category_id=1,
        release_id=product_id, amount=1, currencies_id=1,
        vendor_manual_adjustment_id=1, last_updated=datetime.today()
    )
    db.seed_models(new_release_manual_adjustment)

    new_release_subtitles = release_subtitles.ReleaseSubtitles(
        release_id=product_id, import_asset_id=1, file_type='srt',
        language_tag='abc', track_id=11, status='new'
    )
    db.seed_models(new_release_subtitles)

    new_release_approval_data = release_approval_queue.ReleaseApprovalQueue(
        release_id=product_id, status='rejected',
        last_updated=datetime.today(), date_submitted=datetime.today()
    )
    db.seed_models(new_release_approval_data)

    new_rejection_notes = rejection_notes.RejectionNotes(
        release_approval_id=release_approval_data, table_name='release',
        comments='abc', corrected='N', date_added=datetime.today()
    )
    db.seed_models(new_rejection_notes)

    new_track_data = track.Track(
        release_id=product_id, meta_language='english'
    )
    db.seed_models(new_track_data)


@db.test_schema
def test_delete(
    client,
    product_id,
    upc,
    role,
    test_release_subgenre,
    release_approval_data,
    account_type,
    account_id,
    project_id,
    valid_headers_for_vendor,
    valid_headers,
    mocker
):
    """Check that delete product functionality works."""
    setup_data(
        client, product_id, upc, role, test_release_subgenre,
        release_approval_data, account_type, account_id, project_id, valid_headers)

    ownership_path = '/ownership/{account_type}/{account_id}/project/{project_id}'.format(
        account_id=account_id, account_type=account_type, project_id=project_id)

    head_specs = [{
        'service': services.OWS_PROJECT_MANAGER,
        'path': ownership_path,
        'status': 200,
        'json': None}]

    delete_track_path = '/product/{}/tracks'.format(product_id)

    delete_specs = [{
        'service': services.OWS_TRACK,
        'path': delete_track_path,
        'status': 200,
        'json': None
    }]

    delete_timed_release_specs = [{
        'service': services.OWS_TIMED_RELEASE,
        'path': f'/scheduled_update/{product_id}',
        'status': 200,
        'json': None
    }]

    mocker.patch.object(
        request, 'head', test_utils.mock_ows_requests(head_specs))

    mocker.patch.object(
        request, 'delete', test_utils.mock_ows_requests(delete_specs + delete_timed_release_specs))

    response = client.delete(
        '/product/{}'.format(product_id),
        headers=valid_headers_for_vendor
    )
    response_body = json.loads(response.data.decode())

    assert response.status_code == 200
    assert response_body.get('status') == 'ok'