"""Tests for ProductStoreMapping."""

import sqlite3
from unittest.mock import patch

from product_store_mapping.connectors import helper, mysql
from product_store_mapping.models import productstoremapping

TEST_MAPPING_DATA = [
    (123456, 1, 1234654, 0, '{"provider": "orchard", "custom_id": "807978099098790"}'),
    (123457, 2, 1234655, 0, '{"provider": "orchard", "custom_id": "807978099098791"}'),
    (123457, 2, 1234656, 0, '{"provider": "orchard", "custom_id": "807978099098792"}'),
    (123456, 1, 12346545234, 1, '{"custom_id": "34523452345_ASDF3412341"}'),
    (123456, 1, 12346542345, 2, '{"custom_id": "34523452345_ASDF3414534"}'),
    (123458, 1, 12346542345, 3, '{"custom_id": "34523452345_ASDF3414534"}'),
    (123458, 1, 12346542345, 3, '{"custom_id": "34523452345_ASDF3414534"}'),
]


productstoremapping.QUERY_DELETE_PRODUCT = (
    productstoremapping.QUERY_DELETE_PRODUCT.replace("%s", "?")
)

productstoremapping.QUERY_PRODUCT_TRACKS = (
    productstoremapping.QUERY_PRODUCT_TRACKS.replace("%s", "?")
)

productstoremapping.QUERY_PRODUCT = productstoremapping.QUERY_PRODUCT.replace("%s", "?")

productstoremapping.QUERY_TRACK = productstoremapping.QUERY_TRACK.replace("%s", "?")

PRODUCT_REPLACE_QUERY = """REPLACE INTO product_store_mapping
    (product_id, dms_id, store_unique_id, track_unique_id, mapping_data)
    VALUES (?, ?, ?, ?, ?)"""

# mapping ON DUPLICATE KEY UPDATE with REPLACE query as it don't support
# in sqlite
productstoremapping.QUERY_INSERT_PRODUCT = PRODUCT_REPLACE_QUERY


def create_temp_mapping_table(db_conn):
    """Create temporary tables to query test mapping data.

    Args:
        db_conn (sqlite3.Connection): open database connection.
    """
    db_insert_query = "INSERT INTO product_store_mapping VALUES (?, ?, ?, ?, ?)"

    helper.execute_query(
        db_conn,
        "CREATE TABLE product_store_mapping (product_id INTEGER,"
        " dms_id INTEGER, store_unique_id INTEGER,"
        " track_unique_id INTEGER, mapping_data TEXT)",
    )
    for insert_row in TEST_MAPPING_DATA:
        helper.execute_query(db_conn, db_insert_query, insert_row)


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_delete_product_success(mock_obj):
    """Test delete_product not found."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.delete_product(123457, 2)
    assert result.status == 200


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_delete_product_not_found(mock_obj):
    """Test delete_product not found."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.delete_product(54321, 5)
    assert result.status == 200


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_product_with_tracks_not_found(mock_obj):
    """Test get_product_with_tracks."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_product_with_tracks(0, 1)
    assert result.status == 404


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_product_with_tracks(mock_obj):
    """Test get_product_with_tracks."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_product_with_tracks(123456, 1)

    products = []
    for row in TEST_MAPPING_DATA:
        if row[0] == 123456:
            products.append(
                productstoremapping.ProductStoreMapping(
                    row[0], row[1], row[2], row[3], row[4]
                )
            )

    assert result.message == products


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_product(mock_obj):
    """Test get_product."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_product(123456, 1)

    products = []
    for row in TEST_MAPPING_DATA:
        products.append(
            productstoremapping.ProductStoreMapping(
                row[0], row[1], row[2], row[3], row[4]
            )
        )

    assert result.message == products[0]


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_product_not_found(mock_obj):
    """Test get_product_with_tracks."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_product(0, 1)
    assert result.status == 404


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_track(mock_obj):
    """Test get_track."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_track(1, 1)

    row = TEST_MAPPING_DATA[3]
    track = productstoremapping.ProductStoreMapping(
        row[0], row[1], row[2], row[3], row[4]
    )

    assert result.message == track


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_track_not_found(mock_obj):
    """Test get_track not found."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_track(None, 1)
    assert result.status == 404


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_track_multiple_results(mock_obj):
    """Test get_track."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_track(3, 1)

    assert result.status == 500
    assert result.errors["message"] == "more than 1 records found for 3 and 1"


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_product_too_many_matches(mock_obj):
    """Test get_product."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_product(123457, 2)
    assert result.status == 500


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_get_product_with_tracks_found_multiple(mock_obj):
    """Test get_product_with_tracks."""
    create_temp_mapping_table(mysql.get_connection())
    result = productstoremapping.get_product_with_tracks(123457, 2)

    products = []
    for row in TEST_MAPPING_DATA:
        if row[0] == 123457:
            products.append(
                productstoremapping.ProductStoreMapping(
                    row[0], row[1], row[2], row[3], row[4]
                )
            )

    assert result.status == 500
    assert (
        result.errors["message"] == "More than 1 records for product"
        " 123457 found for store 2"
    )


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_save_product(mock_obj):
    """Test save_product."""
    create_temp_mapping_table(mysql.get_connection())
    input_data = {
        "provider": "Test New Orchard",
        "video_order_id": "USALL0300138",
        "store_unique_id": 0,
        "track_unique_id": 0,
    }

    storeResponse = productstoremapping.save_product(1020, 1, input_data)

    assert storeResponse.status == 200


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_save_update_product(mock_obj):
    """Test save product and also update product with duplicate keys."""
    create_temp_mapping_table(mysql.get_connection())
    input_data = {
        "provider": "New Orchard",
        "video_order_id": "USALL0300140",
        "store_unique_id": 0,
        "track_unique_id": 0,
    }

    result_response = productstoremapping.save_product(123457, 2, input_data)

    expected_response = {
        "product_id": 123457,
        "store_id": 2,
        "provider": "New Orchard",
        "video_order_id": "USALL0300140",
        "store_unique_id": 0,
        "track_unique_id": 0,
    }

    assert result_response.message == expected_response
    assert result_response.status == 200


@patch("pymysql.connect", return_value=sqlite3.connect(":memory:"))
def test_save_product_error(mock_obj):
    """Test save_product with 404 error."""
    data = {
        "provider": "New Orchard",
        "video_order_id": "USALL0300140",
        "store_unique_id": 0,
        "track_unique_id": 0,
    }
    storeResponse = productstoremapping.save_product(123457, 2, data)

    assert storeResponse.status == 400