# Copyright © 2020 Interplanetary Database Association e.V.,
# Planetmint and IPDB software contributors.
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
# Code is Apache-2.0 and docs are CC-BY-4.0

import pytest

from transactions.types.assets.create import Create
from transactions.types.assets.transfer import Transfer
from transactions.types.assets.compose import Compose
from transactions.types.assets.decompose import Decompose


def test_asset_transfer(b, signed_create_tx, user_pk, user_sk, _bdb):
    tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)], [signed_create_tx.id])
    tx_transfer_signed = tx_transfer.sign([user_sk])

    b.models.store_bulk_transactions([signed_create_tx])

    assert b.validate_transaction(tx_transfer_signed) == tx_transfer_signed
    assert tx_transfer_signed.assets[0]["id"] == signed_create_tx.id


# NOTE: TO BE REMOVED BECAUSE V3.0 ALLOWS FOR MULTIPLE ASSETS THEREFOR MULTIPLE ASSET IDS
# def test_validate_transfer_asset_id_mismatch(b, signed_create_tx, user_pk, user_sk):
#     from planetmint.transactions.common.exceptions import AssetIdMismatch


def test_validate_transfer_asset_id_mismatch(b, signed_create_tx, user_pk, user_sk, _bdb):
    from transactions.common.exceptions import AssetIdMismatch

    tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)], [signed_create_tx.id])
    tx_transfer.assets[0]["id"] = "a" * 64
    tx_transfer_signed = tx_transfer.sign([user_sk])

    b.models.store_bulk_transactions([signed_create_tx])

    with pytest.raises(AssetIdMismatch):
        b.validate_transaction(tx_transfer_signed)


def test_get_asset_id_create_transaction(alice, user_pk):
    from transactions.common.transaction import Transaction

    tx_create = Create.generate([alice.public_key], [([user_pk], 1)])
    assert Transaction.get_asset_id(tx_create) == tx_create.id


def test_get_asset_id_transfer_transaction(b, signed_create_tx, user_pk):
    from transactions.common.transaction import Transaction

    tx_transfer = Transfer.generate(signed_create_tx.to_inputs(), [([user_pk], 1)], [signed_create_tx.id])
    asset_id = Transaction.get_asset_id(tx_transfer)
    assert asset_id == tx_transfer.assets[0]["id"]


def test_asset_id_mismatch(alice, user_pk):
    from transactions.common.transaction import Transaction
    from transactions.common.exceptions import AssetIdMismatch

    tx1 = Create.generate(
        [alice.public_key], [([user_pk], 1)], metadata="QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4"
    )
    tx1.sign([alice.private_key])
    tx2 = Create.generate(
        [alice.public_key], [([user_pk], 1)], metadata="zb2rhe5P4gXftAwvA4eXQ5HJwsER2owDyS9sKaQRRVQPn93bA"
    )
    tx2.sign([alice.private_key])

    with pytest.raises(AssetIdMismatch):
        Transaction.get_asset_id([tx1, tx2])


def test_compose_valid_transactions(b, user_pk, user_sk, alice, signed_create_tx, _bdb):
    validated = b.validate_transaction(signed_create_tx)
    b.models.store_bulk_transactions([validated])

    inputs = signed_create_tx.to_inputs()
    assets = [signed_create_tx.id, "QmW5GVMW98D3mktSDfWHS8nX2UiCd8gP1uCiujnFX4yK8n"]
    compose_transaction = Compose.generate(inputs=inputs, recipients=[([user_pk], 1)], assets=assets)
    compose_transaction.sign([user_sk])
    assert b.validate_transaction(compose_transaction)


def test_decompose_valid_transactions(b, user_pk, user_sk, alice, signed_create_tx, _bdb):
    validated = b.validate_transaction(signed_create_tx)
    b.models.store_bulk_transactions([validated])

    inputs = signed_create_tx.to_inputs()
    assets = [
        signed_create_tx.id,
        "bafkreiawyk3ou5qzqec4ggbvrs56dv5ske2viwprf6he5wj5gr4yv5orsu",
        "bafkreibncbonglm6mi3znbrqbchk56wmgftk4gfevxqlgeif3g5jdotcka",
        "bafkreibkokzihpnnyqf3xslcievqkadf2ozkdi72wyibijih447vq42kjm",
    ]
    decompose_transaction = Decompose.generate(
        inputs=inputs, recipients=[([user_pk], 1), ([user_pk], 2), ([user_pk], 3)], assets=assets
    )
    decompose_transaction.sign([user_sk])
    assert b.validate_transaction(decompose_transaction)


def test_create_decompose_output(b, user_pk, user_sk, signed_create_tx, _bdb):
    validated = b.validate_transaction(signed_create_tx)
    b.models.store_bulk_transactions([validated])

    inputs = signed_create_tx.to_inputs()
    assets = [
        "bafkreiawyk3ou5qzqec4ggbvrs56dv5ske2viwprf6he5wj5gr4yv5orsu",
        "bafkreibncbonglm6mi3znbrqbchk56wmgftk4gfevxqlgeif3g5jdotcka",
        "bafkreibkokzihpnnyqf3xslcievqkadf2ozkdi72wyibijih447vq42kjm",
        signed_create_tx.id,
    ]
    decompose_transaction = Decompose.generate(
        inputs=inputs, recipients=[([user_pk], 1), ([user_pk], 2), ([user_pk], 3)], assets=assets
    )
    decompose_transaction.sign([user_sk])
    validated_decompose = b.validate_transaction(decompose_transaction)
    b.models.store_bulk_transactions([validated_decompose])

    create_inputs = decompose_transaction.to_inputs([0])
    create_tx = Create.generate([user_pk], recipients=[([user_pk], 1)], assets=[assets[0]], inputs=create_inputs)
    signed_decompose_create_tx = create_tx.sign([user_sk])
    assert b.validate_transaction(signed_decompose_create_tx)


def test_create_valid_divisible_asset(b, user_pk, user_sk, _bdb):
    tx = Create.generate([user_pk], [([user_pk], 2)])
    tx_signed = tx.sign([user_sk])
    assert b.validate_transaction(tx_signed) == tx_signed


def test_v_2_0_validation_create(b, signed_2_0_create_tx, _bdb):
    validated = b.validate_transaction(signed_2_0_create_tx)
    assert validated.to_dict() == signed_2_0_create_tx


def test_v_2_0_validation_create_invalid(b, signed_2_0_create_tx_assets, _bdb):
    assert b.validate_transaction(signed_2_0_create_tx_assets)


def test_v_2_0_validation_transfer(b, signed_2_0_create_tx, signed_2_0_transfer_tx, _bdb):
    validated = b.validate_transaction(signed_2_0_create_tx)
    b.models.store_bulk_transactions([validated])
    assert validated.to_dict() == signed_2_0_create_tx
    assert b.validate_transaction(signed_2_0_transfer_tx).to_dict() == signed_2_0_transfer_tx