"""Integration API tests for ows-assets streaming functionality ."""

from typing import Any

import pytest

from assets.constants.asset_upload import ASSET_TYPE_AUDIO

from tests.testutils.api_client.api_client import APIClient
from tests.testutils.api_client.product_digital_api_client import (
    ProductDigitalAPIClient,
)
from tests.testutils.api_client.track_api_client import TrackAPIClient
from tests.testutils.file_helper.file_helper import FileHelper
from tests.testutils.s3_helper.s3_helper import S3Helper
from tests.testutils.test_helper.test_helper import TestHelper


@pytest.mark.parametrize(
    "status,track_id", [("invalid", 999999999999999), ("not_owned", 11345435)]
)
def test_get_stream_url_negative(
    workstation_api_client: APIClient, track_id: int, status: str
) -> None:
    """GET stream_url negative scenarios."""
    # Execute GET against list of track_ids
    response_get = workstation_api_client.get_stream_url(track_id)
    get_content = response_get.json()

    if status == "not_owned":
        expected_message = "Product not owned by account"
        expected_code = "not_owned"
        assert response_get.status_code == 403, (
            "Result of GET was {}, expected 403.".format(response_get.status_code)
        )
        assert get_content["message"] == expected_message, (
            "Expected message to be {}, got {}".format(
                expected_message, get_content["message"]
            )
        )
        assert get_content["code"] == expected_code, (
            "Expected message to be {}, got {}".format(
                expected_message, get_content["code"]
            )
        )
    elif status == "invalid":
        expected_message = f"Track not found for provided track id. {track_id}"
        expected_code = "not_found_error"
        assert response_get.status_code == 404, (
            "Result of GET was {}, expected 404.".format(response_get.status_code)
        )
        assert get_content["message"] == expected_message, (
            "Expected message to be {}, got {}".format(
                expected_message, get_content["message"]
            )
        )
        assert get_content["code"] == expected_code, (
            "Expected message to be {}, got {}".format(
                expected_message, get_content["code"]
            )
        )
    else:
        raise NotImplementedError()


def test_get_stream_url_valid_v2(
    workstation_api_client: APIClient,
    workstation_product_digital_api_client: ProductDigitalAPIClient,
    workstation_track_api_client: TrackAPIClient,
    product_data: dict[str, Any],
) -> None:
    """Test getting a wowza url with v2 streaming."""
    asset_file = "tests/integration/assets/wav_file.wav"
    file_data = FileHelper.get_file_data_from_asset(asset_file)

    upload_token = S3Helper.get_upload_token(workstation_api_client, ASSET_TYPE_AUDIO)
    product_dict = TestHelper.create_product(
        workstation_product_digital_api_client, product_data
    )
    tuid = TestHelper.create_track_if_audio(
        workstation_track_api_client, file_data["file_type"], product_dict["product_id"]
    )

    metadata = S3Helper.s3_metadata(product_dict, file_data["file_ext"], tuid)
    S3Helper.upload_to_s3_check_response(
        asset_file,
        metadata,
        file_data["file_ext"],
        file_data["content_type"],
        upload_token,
    )

    # Execute GETs against asset/status
    TestHelper.assert_with_timeout(
        workstation_api_client.get_asset_status,
        upload_token["filename"],
        TestHelper.expect_completely_encoded_asset,
        additional_assert_args=upload_token["filename"],
    )

    asset_status_response = workstation_api_client.get_asset_status(
        upload_token["filename"]
    )
    assert asset_status_response.status_code == 200, (
        "Result of GET was {}, expected 200.".format(asset_status_response.status_code)
    )

    for asset in asset_status_response.json()["message"]["result_assets"]:
        if "mp3" in asset["key"]:
            mezzanine_filename = asset["key"]

    assert tuid is not None
    response_get = workstation_api_client.get_stream_url(tuid)
    get_content = response_get.json()
    assert response_get.status_code == 200, (
        "Result of GET was {}, expected 200.".format(response_get.status_code)
    )
    assert "wowza" in get_content["url"], (
        "wowza value was not found within stream url, got {}".format(get_content["url"])
    )
    assert "vods3" in get_content["url"], (
        '"vods3" was not found within stream url, got {}'.format(get_content["url"])
    )
    assert "qa-orcd-mezzanine-assets" in get_content["url"], (
        '"qa-orcd-mezzanine-assets" was not found within stream url, got {}'.format(
            get_content["url"]
        )
    )
    assert mezzanine_filename in get_content["url"], (
        "{} was not found within stream url, got {}".format(
            mezzanine_filename, get_content["url"]
        )
    )