from os import path

import pytest
from tools.client_regression import ClientRegression
from tools import paths
from tools.utils import (
    assert_run_failure,
    assert_storage_contains,
    bake,
    init_with_transfer,
    assert_balance,
)
from tools.constants import IDENTITIES
from .contract_paths import OPCODES_CONTRACT_PATH, MINI_SCENARIOS_CONTRACT_PATH
from . import protocol

KEY1 = 'foo'
KEY2 = 'bar'


@pytest.mark.incremental
@pytest.mark.slow
@pytest.mark.contract
@pytest.mark.regression
class TestContractOnchainOpcodes:
    """Tests for individual opcodes that requires origination."""

    def test_gen_keys(self, client_regtest_scrubbed: ClientRegression):
        """Add keys used by later tests."""
        client = client_regtest_scrubbed
        client.gen_key(KEY1)
        client.gen_key(KEY2)

    def test_store_input(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        client.transfer(1000, "bootstrap1", KEY1, ['--burn-cap', '0.257'])
        bake(client)

        client.transfer(2000, "bootstrap1", KEY2, ['--burn-cap', '0.257'])
        bake(client)

        assert_balance(client, KEY1, 1000)
        assert_balance(client, KEY2, 2000)

        # Create a contract and transfer 100 ꜩ to it
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'store_input.tz'),
            '""',
            100,
            'bootstrap1',
        )

        client.transfer(
            100,
            "bootstrap1",
            "store_input",
            ["-arg", '"abcdefg"', '--burn-cap', '10'],
        )
        bake(client)

        assert_balance(client, "store_input", 200)

        assert_storage_contains(client, "store_input", '"abcdefg"')

        client.transfer(
            100,
            "bootstrap1",
            "store_input",
            ["-arg", '"xyz"', '--burn-cap', '10'],
        )
        bake(client)

        assert_storage_contains(client, "store_input", '"xyz"')

    def test_transfer_amount(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'transfer_amount.tz'),
            '0',
            100,
            'bootstrap1',
        )

        client.transfer(
            500,
            "bootstrap1",
            'transfer_amount',
            ['-arg', 'Unit', '--burn-cap', '10'],
        )

        bake(client)

        assert_storage_contains(client, "transfer_amount", '500000000')

    def test_now(self, client_regtest_scrubbed: ClientRegression):
        # Regtest is disabled for this test, since one would need to
        # scrub storage for this one as it changes (the timestamp)
        # on every run.
        client = client_regtest_scrubbed
        client.set_regtest(None)

        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'store_now.tz'),
            '"2017-07-13T09:19:01Z"',
            100,
            'bootstrap1',
        )

        client.transfer(
            500, "bootstrap1", 'store_now', ['-arg', 'Unit', '--burn-cap', '10']
        )
        bake(client)

        assert_storage_contains(
            client, 'store_now', f'"{protocol.get_now(client)}"'
        )

    def test_transfer_tokens(self, client_regtest_scrubbed: ClientRegression):
        """Tests TRANSFER_TOKENS."""
        client = client_regtest_scrubbed
        client.originate(
            'test_transfer_account1',
            100,
            'bootstrap1',
            path.join(OPCODES_CONTRACT_PATH, 'noop.tz'),
            ['--burn-cap', '10'],
        )
        bake(client)

        client.originate(
            'test_transfer_account2',
            20,
            'bootstrap1',
            path.join(OPCODES_CONTRACT_PATH, 'noop.tz'),
            ['--burn-cap', '10'],
        )
        bake(client)

        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'transfer_tokens.tz'),
            'Unit',
            1000,
            'bootstrap1',
        )

        assert_balance(client, 'test_transfer_account1', 100)

        account1_addr = client.get_contract_address('test_transfer_account1')
        client.transfer(
            100,
            'bootstrap1',
            'transfer_tokens',
            ['-arg', f'"{account1_addr}"', '--burn-cap', '10'],
        )
        bake(client)

        # Why isn't this 200 ꜩ? Baking fee?
        assert_balance(client, 'test_transfer_account1', 200)

        account2_addr = client.get_contract_address('test_transfer_account2')
        client.transfer(
            100,
            'bootstrap1',
            'transfer_tokens',
            ['-arg', f'"{account2_addr}"', '--burn-cap', '10'],
        )
        bake(client)

        assert_balance(client, 'test_transfer_account2', 120)

    def test_self(self, client_regtest_scrubbed: ClientRegression):
        # Regtest is disabled for this test, since one would need to
        # scrub storage for this one as it changes (the contract
        # address) on every run.
        client = client_regtest_scrubbed
        client.set_regtest(None)

        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'self.tz'),
            '"tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx"',
            1000,
            'bootstrap1',
        )

        client.transfer(0, 'bootstrap1', 'self', ['--burn-cap', '10'])
        bake(client)

        self_addr = client.get_contract_address('self')
        assert_storage_contains(client, 'self', f'"{self_addr}"')

    def test_contract_fails(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        client.set_regtest(None)

        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'contract.tz'),
            'Unit',
            1000,
            'bootstrap1',
        )

        client.transfer(0, 'bootstrap1', 'self', ['--burn-cap', '10'])
        bake(client)
        addr = client.get_contract_address('contract')

        with assert_run_failure(r'script reached FAILWITH instruction'):
            client.transfer(
                0,
                'bootstrap1',
                'contract',
                ['-arg', f'"{addr}"', '--burn-cap', '10'],
            )

    def test_init_proxy(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'proxy.tz'),
            'Unit',
            1000,
            'bootstrap1',
        )

    def test_source(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        init_store = IDENTITIES['bootstrap4']['identity']
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'source.tz'),
            f'"{init_store}"',
            1000,
            'bootstrap1',
        )

        # direct transfer to the contract
        client.transfer(0, 'bootstrap2', 'source', ['--burn-cap', '10'])
        bake(client)

        source_addr = IDENTITIES['bootstrap2']['identity']
        assert_storage_contains(client, 'source', f'"{source_addr}"')

        # indirect transfer to the contract through proxy
        contract_addr = client.get_contract_address('source')
        client.transfer(
            0,
            'bootstrap2',
            'proxy',
            ['--burn-cap', '10', '--arg', f'"{contract_addr}"'],
        )
        bake(client)
        assert_storage_contains(client, 'source', f'"{source_addr}"')

    def test_sender(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        client.set_regtest(None)

        init_store = IDENTITIES['bootstrap4']['identity']
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'sender.tz'),
            f'"{init_store}"',
            1000,
            'bootstrap1',
        )

        # direct transfer to the contract
        client.transfer(0, 'bootstrap2', 'sender', ['--burn-cap', '10'])
        bake(client)

        sender_addr = IDENTITIES['bootstrap2']['identity']
        assert_storage_contains(client, 'sender', f'"{sender_addr}"')

        # indirect transfer to the contract through proxy
        contract_addr = client.get_contract_address('sender')
        proxy_addr = client.get_contract_address('proxy')
        client.transfer(
            0,
            'bootstrap2',
            'proxy',
            ['--burn-cap', '10', '--arg', f'"{contract_addr}"'],
        )
        bake(client)
        assert_storage_contains(client, 'sender', f'"{proxy_addr}"')

    def test_slice(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'slices.tz'),
            '"sppk7dBPqMPjDjXgKbb5f7V3PuKUrA4Zuwc3c3H7XqQerqPUWbK7Hna"',
            1000,
            'bootstrap1',
        )

    @pytest.mark.parametrize(
        'contract_arg',
        [
            line.rstrip('\n')
            for line in open(
                f'{paths.TEZOS_HOME}'
                + '/tests_python/tests_013/'
                + 'test_slice_fails_params.txt'
            )
        ],
    )
    def test_slice_fails(
        self, client_regtest_scrubbed: ClientRegression, contract_arg: str
    ):
        client = client_regtest_scrubbed

        with assert_run_failure(r'script reached FAILWITH instruction'):
            client.transfer(
                0,
                'bootstrap1',
                'slices',
                ['-arg', contract_arg, '--burn-cap', '10'],
            )
        # bake(client)

    @pytest.mark.parametrize(
        'contract_arg',
        [
            line.rstrip('\n')
            for line in open(
                f'{paths.TEZOS_HOME}'
                + '/tests_python/tests_013/'
                + 'test_slice_success_params.txt'
            )
        ],
    )
    def test_slice_success(
        self, client_regtest_scrubbed: ClientRegression, contract_arg: str
    ):
        client = client_regtest_scrubbed
        client.transfer(
            0,
            'bootstrap1',
            'slices',
            ['-arg', contract_arg, '--burn-cap', '10'],
        )
        bake(client)

    def test_split_string(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'split_string.tz'),
            '{}',
            1000,
            'bootstrap1',
        )

        client.transfer(
            0,
            'bootstrap1',
            'split_string',
            ['-arg', '"abc"', '--burn-cap', '10'],
        )
        bake(client)
        assert_storage_contains(client, 'split_string', '{ "a" ; "b" ; "c" }')

        client.transfer(
            0,
            'bootstrap1',
            'split_string',
            ['-arg', '"def"', '--burn-cap', '10'],
        )
        bake(client)
        assert_storage_contains(
            client, 'split_string', '{ "a" ; "b" ; "c" ; "d" ; "e" ; "f" }'
        )

    def test_split_bytes(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'split_bytes.tz'),
            '{}',
            1000,
            'bootstrap1',
        )

        client.transfer(
            0,
            'bootstrap1',
            'split_bytes',
            ['-arg', '0xaabbcc', '--burn-cap', '10'],
        )
        bake(client)
        assert_storage_contains(client, 'split_bytes', '{ 0xaa ; 0xbb ; 0xcc }')

        client.transfer(
            0,
            'bootstrap1',
            'split_bytes',
            ['-arg', '0xddeeff', '--burn-cap', '10'],
        )
        bake(client)
        assert_storage_contains(
            client, 'split_bytes', '{ 0xaa ; 0xbb ; 0xcc ; 0xdd ; 0xee ; 0xff }'
        )

    def test_set_delegate(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'set_delegate.tz'),
            'Unit',
            1000,
            'bootstrap1',
        )
        bake(client)

        assert client.get_delegate('set_delegate').delegate is None

        addr = IDENTITIES['bootstrap5']['identity']
        client.transfer(
            0, 'bootstrap1', 'set_delegate', ['-arg', f'(Some "{addr}")']
        )
        bake(client)

        assert client.get_delegate('set_delegate').delegate == addr

        client.transfer(0, 'bootstrap1', 'set_delegate', ['-arg', 'None'])
        bake(client)

        assert client.get_delegate('set_delegate').delegate is None

    @pytest.mark.parametrize(
        'contract',
        [
            'compare_big_type.tz',
            'compare_big_type2.tz',
        ],
    )
    def test_trace_origination(self, client_regtest_scrubbed, contract):
        client = client_regtest_scrubbed
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, contract),
            'Unit',
            1000,
            'bootstrap1',
        )
        bake(client)


@pytest.mark.incremental
class TestTickets:
    """Tests for tickets."""

    def test_ticket_user_forge(self, client):
        bake(client)
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticket_store-2.tz'),
            'None',
            100,
            'bootstrap1',
            'storer',
        )

        # Create parameter by hand with a ticket type but no ticket in it
        client.transfer(
            100, 'bootstrap1', 'storer', ['-arg', 'None', '--burn-cap', '10']
        )

        with assert_run_failure(r'Unexpected forged value'):
            # Create parameter by hand with a ticket in it
            client.transfer(
                100,
                'bootstrap1',
                'storer',
                ['-arg', 'Some 1', '--burn-cap', '10'],
            )

        with assert_run_failure(r'Unexpected forged value'):
            # Create storage by hand with a ticket in it
            init_with_transfer(
                client,
                path.join(OPCODES_CONTRACT_PATH, 'ticket_bad.tz'),
                '1',
                100,
                'bootstrap1',
                'ticket_bad',
            )

    def test_ticket_user_big_forge(self, client):
        bake(client)
        contract_name = 'big_storer'
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticket_big_store.tz'),
            '{}',
            100,
            'bootstrap1',
            contract_name,
        )
        bake(client)
        client.transfer(
            100, 'bootstrap1', contract_name, ['-arg', '42', '--burn-cap', '10']
        )
        bake(client)
        storage = client.get_storage(contract_name)

        with assert_run_failure(r'Unexpected forged value'):
            # Create a storage with the ID of a big map that has tickets in it
            init_with_transfer(
                client,
                path.join(OPCODES_CONTRACT_PATH, 'ticket_big_store.tz'),
                storage,
                100,
                'bootstrap1',
                'thief',
            )

        with assert_run_failure(r'Unexpected forged value'):
            # Create a storage with the ID of a big map that has tickets in it
            init_with_transfer(
                client,
                path.join(OPCODES_CONTRACT_PATH, 'ticket_big_store.tz'),
                '(Pair ' + storage + ' {})',
                100,
                'bootstrap1',
                'thief',
            )

    def test_ticket_read(self, client):
        """Test TICKETS"""
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticketer.tz'),
            '42',
            100,
            'bootstrap1',
            'ticketer_read',
        )
        bake(client)
        ticketer_addr = client.get_contract_address('ticketer_read')
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticket_read.tz'),
            '"' + ticketer_addr + '"',
            100,
            'bootstrap1',
            'reader',
        )
        bake(client)
        reader_addr = client.get_contract_address('reader')
        client.transfer(
            100,
            'bootstrap1',
            'ticketer_read',
            ['-arg', '"' + reader_addr + '"', '--burn-cap', '10'],
        )
        bake(client)
        assert_storage_contains(client, "reader", '"' + ticketer_addr + '"')

    def test_bad_ticket(self, client):
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticketer.tz'),
            '42',
            100,
            'bootstrap1',
            'ticketer_bad',
        )
        bake(client)
        ticketer_addr = client.get_contract_address('ticketer_bad')
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticket_read.tz'),
            '"' + ticketer_addr + '"',
            100,
            'bootstrap1',
            'reader_bad',
        )
        bake(client)
        with assert_run_failure(r'Unexpected forged value'):
            client.transfer(
                100,
                'bootstrap1',
                'reader_bad',
                ['-arg', '1', '--burn-cap', '10'],
            )
            bake(client)

    def test_ticket_utxo(self, client):
        """Test UTXOs"""
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'utxor.tz'),
            '42',
            100,
            'bootstrap1',
        )
        bake(client)
        utxor_addr = client.get_contract_address('utxor')
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'utxo_read.tz'),
            '"' + utxor_addr + '"',
            100,
            'bootstrap1',
            "reader_a",
        )
        bake(client)
        reader_a_addr = client.get_contract_address('reader_a')
        utxor_addr = client.get_contract_address('utxor')
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'utxo_read.tz'),
            '"' + utxor_addr + '"',
            100,
            'bootstrap1',
            "reader_b",
        )
        bake(client)
        reader_b_addr = client.get_contract_address('reader_b')
        client.transfer(
            100,
            'bootstrap1',
            'utxor',
            [
                '-arg',
                '(Pair "' + reader_a_addr + '" "' + reader_b_addr + '")',
                '--burn-cap',
                '10',
            ],
        )
        bake(client)

    def test_ticket_split(self, client):
        def ticket(target_addr, param, utxo_amount):
            param = (
                '(Pair (Pair "'
                + target_addr
                + '" '
                + str(param)
                + ') '
                + str(utxo_amount)
                + ')'
            )
            client.transfer(
                100,
                'bootstrap1',
                'ticketer',
                ['-arg', param, '--burn-cap', '10'],
            )

        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticketer-2.tz'),
            'Unit',
            100,
            'bootstrap1',
            'ticketer',
        )
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticket_split.tz'),
            'Unit',
            100,
            'bootstrap1',
            'splitter',
        )
        bake(client)
        splitter_addr = client.get_contract_address('splitter')
        ticket(splitter_addr, 42, 3)
        with assert_run_failure(r'script reached FAILWITH instruction'):
            # Wrong Split Amount
            ticket(splitter_addr, 42, 4)
        bake(client)

    def test_ticket_join(self, client):
        """Test JOIN"""

        def params(target_addr, utxo_amount, param):
            return (
                '(Pair (Pair "'
                + target_addr
                + '" '
                + str(param)
                + ') '
                + str(utxo_amount)
                + ')'
            )

        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticketer-2.tz'),
            'Unit',
            100,
            'bootstrap1',
            'ticketer_a',
        )
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticketer-2.tz'),
            'Unit',
            100,
            'bootstrap1',
            'ticketer_b',
        )
        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'ticket_join.tz'),
            'None',
            100,
            'bootstrap1',
            'joiner',
        )
        bake(client)
        joiner_addr = client.get_contract_address('joiner')
        client.transfer(
            100,
            'bootstrap1',
            'ticketer_a',
            ['-arg', params(joiner_addr, 42, 1), '--burn-cap', '10'],
        )
        bake(client)
        client.transfer(
            100,
            'bootstrap1',
            'ticketer_a',
            ['-arg', params(joiner_addr, 144, 1), '--burn-cap', '10'],
        )
        bake(client)
        with assert_run_failure(r'script reached FAILWITH instruction'):
            # Different Ticketer
            client.transfer(
                100,
                'bootstrap1',
                'ticketer_b',
                ['-arg', params(joiner_addr, 23, 1), '--burn-cap', '10'],
            )
        with assert_run_failure(r'script reached FAILWITH instruction'):
            # Different Content
            client.transfer(
                100,
                'bootstrap1',
                'ticketer_a',
                ['-arg', params(joiner_addr, 21, 23), '--burn-cap', '10'],
            )

    def test_ticket_fungible_originations(self, client, session):
        """Test the origination of builder and wallet contracts for fungible
        tokens implemented using tickets."""

        builder_path = path.join(
            MINI_SCENARIOS_CONTRACT_PATH, 'ticket_builder_fungible.tz'
        )

        wallet_path = path.join(
            MINI_SCENARIOS_CONTRACT_PATH, 'ticket_wallet_fungible.tz'
        )

        manager_address = IDENTITIES['bootstrap1']['identity']

        builders = {}
        wallets = {}

        # Helper functions
        def originate_builder(name):
            """Create a fungible token contract managed by bootstrap1."""
            origination = client.originate(
                contract_name=f'builder_{name}',
                amount="0",
                sender='bootstrap1',
                contract=builder_path,
                args=['--init', f'"{manager_address}"', '--burn-cap', "10"],
            )
            builders[name] = origination.contract
            bake(client)

        def originate_wallet(name):
            """Create a fungible token wallet managed by bootstrap1."""
            origination = client.originate(
                contract_name=f'wallet_{name}',
                amount="0",
                sender='bootstrap1',
                contract=wallet_path,
                args=[
                    '--init',
                    f'Pair "{manager_address}" {{}}',
                    '--burn-cap',
                    "10",
                ],
            )
            wallets[name] = origination.contract
            bake(client)

        # Create 3 token contracts "A", "B", and "C".
        originate_builder("A")
        originate_builder("B")
        originate_builder("C")

        # Create 2 wallets "Alice" and "Bob".
        originate_wallet("Alice")
        originate_wallet("Bob")

        session['fungible_builders'] = builders
        session['fungible_wallets'] = wallets

    def test_ticket_fungible_transfers(self, client, session):
        """Test the life cycle of fungible tokens implemented using tickets."""

        manager_address = IDENTITIES['bootstrap1']['identity']

        builders = session['fungible_builders']
        wallets = session['fungible_wallets']

        def mint(builder, wallet, amount):
            """Mint fungible tokens."""
            wallet_address = wallets[wallet]
            parameter = f'(Pair "{wallet_address}%receive" {amount})'
            client.transfer(
                amount=0,
                giver=manager_address,
                receiver=f'builder_{builder}',
                args=[
                    '--burn-cap',
                    '2',
                    '--entrypoint',
                    'mint',
                    '--arg',
                    parameter,
                ],
            )
            bake(client)

        def burn(builder, wallet, amount):
            """Burn fungible tokens."""
            builder_addr = builders[builder]
            parameter = f'Pair "{builder_addr}%burn" {amount} "{builder_addr}"'
            client.transfer(
                amount=0,
                giver=manager_address,
                receiver=f'wallet_{wallet}',
                args=[
                    '--burn-cap',
                    '2',
                    '--entrypoint',
                    'send',
                    '--arg',
                    parameter,
                ],
            )
            bake(client)

        def transfer(builder, source_wallet, destination_wallet, amount):
            """Transfer fungible tokens."""
            builder_addr = builders[builder]
            dest_addr = wallets[destination_wallet]
            parameter = f'Pair "{dest_addr}%receive" {amount} "{builder_addr}"'
            client.transfer(
                amount=0,
                giver=manager_address,
                receiver=f'wallet_{source_wallet}',
                args=[
                    '--burn-cap',
                    '2',
                    '--entrypoint',
                    'send',
                    '--arg',
                    parameter,
                ],
            )
            bake(client)

        # 100A --> Alice
        mint(builder="A", wallet="Alice", amount=100)
        # 100B --> Alice
        mint(builder="B", wallet="Alice", amount=100)

        # Fail: Alice --1C--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="C",
                source_wallet="Alice",
                destination_wallet="Bob",
                amount=1,
            )

        # Fail: Alice --0C--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="C",
                source_wallet="Alice",
                destination_wallet="Bob",
                amount=0,
            )

        # Fail: Alice --150A--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="A",
                source_wallet="Alice",
                destination_wallet="Bob",
                amount=150,
            )

        # Fail: Bob --50A--> Alice
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="A",
                source_wallet="Bob",
                destination_wallet="Alice",
                amount=50,
            )

        # Alice --50A--> Bob
        transfer(
            builder="A",
            source_wallet="Alice",
            destination_wallet="Bob",
            amount=50,
        )

        # Alice --50A--> Bob
        transfer(
            builder="A",
            source_wallet="Alice",
            destination_wallet="Bob",
            amount=50,
        )

        # Alice --0A--> Bob
        transfer(
            builder="A",
            source_wallet="Alice",
            destination_wallet="Bob",
            amount=0,
        )

        # Fail: Alice --1A--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="A",
                source_wallet="Alice",
                destination_wallet="Bob",
                amount=1,
            )

        # Bob --100A--> Bob
        transfer(
            builder="A",
            source_wallet="Bob",
            destination_wallet="Bob",
            amount=100,
        )

        # Fail: Bob --150A--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="A",
                source_wallet="Bob",
                destination_wallet="Bob",
                amount=150,
            )

        # Bob --100A-->
        burn(builder="A", wallet="Bob", amount=100)

        # Bob --0A-->
        burn(builder="A", wallet="Bob", amount=0)

        # Fail: Bob --1A-->
        with assert_run_failure(r'script reached FAILWITH instruction'):
            burn(builder="A", wallet="Bob", amount=1)

    def test_ticket_non_fungible_originations(self, client, session):
        """Test the origination of builder and wallet contracts for
        non-fungible tokens implemented using tickets."""

        builder_path = path.join(
            MINI_SCENARIOS_CONTRACT_PATH, 'ticket_builder_non_fungible.tz'
        )

        wallet_path = path.join(
            MINI_SCENARIOS_CONTRACT_PATH, 'ticket_wallet_non_fungible.tz'
        )

        manager_address = IDENTITIES['bootstrap1']['identity']

        builders = {}
        wallets = {}

        # Helper functions
        def originate_builder(name):
            """Create a non-fungible token contract managed by bootstrap1."""
            storage = f'(Pair "{manager_address}" 0)'
            origination = client.originate(
                contract_name=f'nft_builder_{name}',
                amount="0",
                sender='bootstrap1',
                contract=builder_path,
                args=['--init', storage, '--burn-cap', "10"],
            )
            builders[name] = origination.contract
            bake(client)

        def originate_wallet(name):
            """Create a non-fungible token wallet managed by bootstrap1."""
            origination = client.originate(
                contract_name=f'nft_wallet_{name}',
                amount="0",
                sender='bootstrap1',
                contract=wallet_path,
                args=[
                    '--init',
                    f'Pair "{manager_address}" {{}}',
                    '--burn-cap',
                    "10",
                ],
            )
            wallets[name] = origination.contract
            bake(client)

        # Create 3 token contracts "A", "B", and "C".
        originate_builder("A")
        originate_builder("B")
        originate_builder("C")

        # Create 2 wallets "Alice" and "Bob".
        originate_wallet("Alice")
        originate_wallet("Bob")

        session['non_fungible_builders'] = builders
        session['non_fungible_wallets'] = wallets

    def test_ticket_non_fungible_transfers(self, client, session):
        """Test the life cycle of non-fungible tokens implemented using
        tickets."""

        manager_address = IDENTITIES['bootstrap1']['identity']

        builders = session['non_fungible_builders']
        wallets = session['non_fungible_wallets']

        def mint(builder, wallet, token_id):
            """Mint a non-fungible token and assert that it has the expected
            id."""
            builder_alias = f'nft_builder_{builder}'
            expected_builder_storage = f'Pair "{manager_address}" {token_id}'
            actual_builder_storage = client.get_storage(builder_alias)
            assert expected_builder_storage == actual_builder_storage

            wallet_address = wallets[wallet]
            parameter = f'"{wallet_address}%receive"'
            client.transfer(
                amount=0,
                giver=manager_address,
                receiver=builder_alias,
                args=[
                    '--burn-cap',
                    '2',
                    '--entrypoint',
                    'mint_destination',
                    '--arg',
                    parameter,
                ],
            )
            bake(client)

        def burn(builder, wallet, token_id):
            """Burn a non-fungible token."""
            builder_addr = builders[builder]
            parameter = (
                f'Pair "{builder_addr}%burn" "{builder_addr}" {token_id}'
            )
            client.transfer(
                amount=0,
                giver=manager_address,
                receiver=f'nft_wallet_{wallet}',
                args=[
                    '--burn-cap',
                    '2',
                    '--entrypoint',
                    'send',
                    '--arg',
                    parameter,
                ],
            )
            bake(client)

        def transfer(builder, source_wallet, destination_wallet, token_id):
            """Transfer fungible tokens."""
            builder_addr = builders[builder]
            dest_addr = wallets[destination_wallet]
            parameter = (
                f'Pair "{dest_addr}%receive" "{builder_addr}" {token_id}'
            )
            client.transfer(
                amount=0,
                giver=manager_address,
                receiver=f'nft_wallet_{source_wallet}',
                args=[
                    '--burn-cap',
                    '2',
                    '--entrypoint',
                    'send',
                    '--arg',
                    parameter,
                ],
            )
            bake(client)

        # A0 --> Alice
        mint(builder="A", wallet="Alice", token_id=0)
        # A1 --> Alice
        mint(builder="A", wallet="Alice", token_id=1)
        # B0 --> Alice
        mint(builder="B", wallet="Alice", token_id=0)

        # Fail: Alice --C0--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="C",
                source_wallet="Alice",
                destination_wallet="Bob",
                token_id=0,
            )

        # Fail: Alice --A2--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="A",
                source_wallet="Alice",
                destination_wallet="Bob",
                token_id=2,
            )

        # Fail: Bob --A0--> Alice
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="A",
                source_wallet="Bob",
                destination_wallet="Alice",
                token_id=0,
            )

        # Fail: Bob --A1--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="A",
                source_wallet="Bob",
                destination_wallet="Bob",
                token_id=1,
            )

        # Alice --A1--> Bob
        transfer(
            builder="A",
            source_wallet="Alice",
            destination_wallet="Bob",
            token_id=1,
        )

        # Alice --A0--> Bob
        transfer(
            builder="A",
            source_wallet="Alice",
            destination_wallet="Bob",
            token_id=0,
        )

        # Fail: Alice --A1--> Bob
        with assert_run_failure(r'script reached FAILWITH instruction'):
            transfer(
                builder="A",
                source_wallet="Alice",
                destination_wallet="Bob",
                token_id=1,
            )

        # Bob --A0--> Bob
        transfer(
            builder="A",
            source_wallet="Bob",
            destination_wallet="Bob",
            token_id=0,
        )

        # Bob --A0-->
        burn(builder="A", wallet="Bob", token_id=0)

        # Bob --A1-->
        burn(builder="A", wallet="Bob", token_id=1)

        # Fail: Bob --B0-->
        with assert_run_failure(r'script reached FAILWITH instruction'):
            burn(builder="B", wallet="Bob", token_id=0)

        # Alice --B0-->
        burn(builder="B", wallet="Alice", token_id=0)


ORIGINATE_BIG_MAP_FILE = path.join(
    OPCODES_CONTRACT_PATH, 'originate_big_map.tz'
)


@pytest.mark.incremental
@pytest.mark.contract
@pytest.mark.regression
class TestContractBigMapOrigination:
    def test_big_map_origination_literal(self, client_regtest_scrubbed):
        client = client_regtest_scrubbed
        # originate a first version of the contract from a literal so
        # that a big_map with id 0 exists
        init_with_transfer(
            client,
            ORIGINATE_BIG_MAP_FILE,
            '{Elt 0 0}',
            1000,
            'bootstrap1',
            contract_name='originate_big_map_literal',
        )

    def test_big_map_origination_id(self, client_regtest_scrubbed):
        client = client_regtest_scrubbed
        # originate again the same script from the big-map id 0
        with assert_run_failure(r'Unexpected forged value'):
            init_with_transfer(
                client,
                ORIGINATE_BIG_MAP_FILE,
                '0',
                1000,
                'bootstrap1',
                contract_name='originate_big_map_id',
            )

    def test_big_map_origination_diff(self, client_regtest_scrubbed):
        client = client_regtest_scrubbed

        # originate again the same script from a big-diff
        with assert_run_failure(r'Unexpected forged value'):
            init_with_transfer(
                client,
                ORIGINATE_BIG_MAP_FILE,
                'Pair 0 {Elt 1 (Some 4)}',
                1000,
                'bootstrap1',
                contract_name='originate_big_map_diff',
            )

    def test_big_map_transfer_id(self, client_regtest_scrubbed):
        client = client_regtest_scrubbed
        # call the first contract, passing an id as parameter
        with assert_run_failure(r'Unexpected forged value'):
            client.call(
                source='bootstrap1',
                destination='originate_big_map_literal',
                args=['--arg', '0'],
            )

    def test_big_map_transfer_diff(self, client_regtest_scrubbed):
        client = client_regtest_scrubbed
        # call the first contract, passing a diff as parameter
        with assert_run_failure(r'Unexpected forged value'):
            client.call(
                source='bootstrap1',
                destination='originate_big_map_literal',
                args=['--arg', 'Pair 0 {Elt 1 (Some 4)}'],
            )


@pytest.mark.incremental
@pytest.mark.slow
@pytest.mark.contract
@pytest.mark.regression
class TestContractOnchainLevel:
    """Onchain tests for LEVEL."""

    # This test needs to be in a separate class to not depend on the number
    # of operations happening before

    def test_level(self, client_regtest_scrubbed: ClientRegression):
        client = client_regtest_scrubbed

        init_with_transfer(
            client,
            path.join(OPCODES_CONTRACT_PATH, 'level.tz'),
            '9999999',
            100,
            'bootstrap1',
        )
        bake(client)
        client.transfer(
            500, "bootstrap1", 'level', ['-arg', 'Unit', '--burn-cap', '10']
        )
        bake(client)
        level = client.get_level()
        slevel = str(level)
        assert_storage_contains(client, 'level', slevel)
        bake(client)
        bake(client)
        # checks the storage hasn't changed even though the current level has
        assert_storage_contains(client, 'level', slevel)
        # Run again to check the storage gets updated
        client.transfer(
            500, "bootstrap1", 'level', ['-arg', 'Unit', '--burn-cap', '10']
        )
        bake(client)
        assert_storage_contains(client, 'level', str(level + 3))