"""Lambda test module."""

import base64
import json

import config
import pytest
from src import app as index


def test_handler(mocker, product_insert_input, product_document_fixture):
    """Test handler function."""
    event = {
        "Records": [
            {"kinesis": {"data": base64.b64encode(json.dumps(product_insert_input).encode("utf8"))}}
        ]
    }
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_product = mocker.patch("src.app.product.prepare_doc")
    mocked_product.return_value = {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_insert_input["data"]["release_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }

    result = index.handler(event, {})
    assert result == {"status": "OK"}
    mocked_product.assert_called_once_with(product_insert_input)
    assert mocked_upload.call_count == 1


def test_handler_product_update(
    mocker, product_update_input, product_document_fixture, prepare_release_tracks_docs_result
):
    """Test handler function."""
    event = {
        "Records": [
            {"kinesis": {"data": base64.b64encode(json.dumps(product_update_input).encode("utf8"))}}
        ]
    }
    product_doc = {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_update_input["data"]["release_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_product = mocker.patch("src.app.product.prepare_doc")
    mocked_product.return_value = product_doc
    mocked_tracks = mocker.patch("src.app.track.prepare_release_tracks_docs")
    mocked_tracks.return_value = prepare_release_tracks_docs_result

    result = index.handler(event, {})
    assert result == {"status": "OK"}
    mocked_product.assert_called_once_with(product_update_input)
    mocked_tracks.assert_called_once_with(product_update_input)
    assert mocked_upload.call_count == 1
    mocked_upload.assert_called_once_with(
        [
            *prepare_release_tracks_docs_result,
            product_doc,
        ]
    )


def test_handler_track_insert(mocker, track_insert_input, track_document_fixture):
    """Test handler function."""
    event = {
        "Records": [
            {"kinesis": {"data": base64.b64encode(json.dumps(track_insert_input).encode("utf8"))}}
        ]
    }
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_track = mocker.patch("src.app.track.prepare_doc")
    mocked_track.return_value = {
        "_index": config.TRACK_INDEX_NAME,
        "_op_type": "update",
        "_id": track_insert_input["data"]["id"],
        "doc": track_document_fixture,
        "doc_as_upsert": True,
    }

    result = index.handler(event, {})
    assert result == {"status": "OK"}
    mocked_track.assert_called_once_with(track_insert_input)
    assert mocked_upload.call_count == 1


def test_handler_project_insert(mocker, project_insert_input, project_document_fixture):
    """Test handler function."""
    event = {
        "Records": [
            {"kinesis": {"data": base64.b64encode(json.dumps(project_insert_input).encode("utf8"))}}
        ]
    }
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_project = mocker.patch("src.app.project.prepare_doc")
    mocked_project.return_value = {
        "_index": config.PROJECT_INDEX_NAME,
        "_op_type": "update",
        "_id": project_insert_input["data"]["project_id"],
        "doc": project_document_fixture,
        "doc_as_upsert": True,
    }

    result = index.handler(event, {})
    assert result == {"status": "OK"}
    mocked_project.assert_called_once_with(project_insert_input)
    assert mocked_upload.call_count == 1


def test_handler_no_data(mocker):
    """Test handler function."""
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_product = mocker.patch("src.app.product.prepare_doc")

    result = index.handler({}, {})
    assert result == {"status": "BAD_INPUT"}
    assert mocked_upload.call_count == 0
    assert mocked_product.call_count == 0


def test_handler_bad_data(mocker):
    """Test handler function."""
    event = {
        "Records": [
            {"kinesis": {"data": base64.b64encode(json.dumps({"foo": "bar"}).encode("utf8"))}}
        ]
    }
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_product = mocker.patch("src.app.product.prepare_doc")
    mocked_logger = mocker.patch("src.app.logger")

    result = index.handler(event, {})
    assert result == {"status": "OK"}
    assert mocked_upload.call_count == 1
    assert mocked_product.call_count == 0
    assert mocked_logger.info.call_count == 1


def test_handler_track_additional_isrc_insert(
    mocker, track_additional_isrc_insert_input, product_document_fixture
):
    """Test handler routes track_additional_isrc events to the product handler."""
    event = {
        "Records": [
            {
                "kinesis": {
                    "data": base64.b64encode(
                        json.dumps(track_additional_isrc_insert_input).encode("utf8")
                    )
                }
            }
        ]
    }
    product_doc = {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": track_additional_isrc_insert_input["data"]["track_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_product = mocker.patch("src.app.product.prepare_doc_from_track_additional_isrc")
    mocked_product.return_value = product_doc

    result = index.handler(event, {})
    assert result == {"status": "OK"}
    mocked_product.assert_called_once_with(track_additional_isrc_insert_input)
    assert mocked_upload.call_count == 1


def test_handler_exception(mocker, product_insert_input, product_document_fixture):
    """Test handler function."""
    event = {
        "Records": [
            {"kinesis": {"data": base64.b64encode(json.dumps(product_insert_input).encode("utf8"))}}
        ]
    }
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_upload.side_effect = Exception("some opensearch error")
    mocked_product = mocker.patch("src.app.product.prepare_doc")
    mocked_product.return_value = {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_insert_input["data"]["release_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }

    with pytest.raises(Exception, match="some opensearch error"):
        index.handler(event, {})


def test_handler_product_additional_upc_insert(
    mocker, product_additional_upc_insert_input, product_document_fixture
):
    """Test handler routes product_additional_upc events to its product handler."""
    event = {
        "Records": [
            {
                "kinesis": {
                    "data": base64.b64encode(
                        json.dumps(product_additional_upc_insert_input).encode("utf8")
                    )
                }
            }
        ]
    }
    product_doc = {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_additional_upc_insert_input["data"]["product_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }
    mocked_upload = mocker.patch("src.app.upload_bulk_documents")
    mocked_product = mocker.patch("src.app.product.prepare_doc_from_product_additional_upc")
    mocked_product.return_value = product_doc

    result = index.handler(event, {})
    assert result == {"status": "OK"}
    mocked_product.assert_called_once_with(product_additional_upc_insert_input)
    assert mocked_upload.call_count == 1