# standard imports
import random
import os
import logging
import tempfile

# external imports
from chainlib.chain import ChainSpec
from chainlib.eth.unittest.ethtester import EthTesterCase
from chainlib.eth.tx import (
        Tx,
        receipt,
        )
from chainlib.eth.gas import OverrideGasOracle
from chainlib.eth.nonce import RPCNonceOracle
from hexathon import (
        add_0x,
        strip_0x,
        )
from funga.eth.keystore.dict import DictKeystore
from eth_address_declarator.declarator import AddressDeclarator
from okota.token_index.index import TokenUniqueSymbolIndexAddressDeclarator
from cic_contracts.writer import CICWriter

# local imports
from cic.ext.eth import CICEth
from cic.writers import KVWriter
from cic.contract.processor import ContractProcessor
from cic.contract.components.proof import Proof
from cic.contract.components.attachment import Attachment


# test imports
from tests.base_cic import test_data_dir

logg = logging.getLogger(__name__)


class TestCICEthBase(EthTesterCase):

    def setUp(self):
        super(TestCICEthBase, self).setUp()
        random.seed(42)

        f = open('/dev/urandom', 'rb')
        initial_description_bytes = f.read(32)
        self.initial_description = add_0x(initial_description_bytes.hex())
        token_address_bytes = f.read(20)
        self.token_address = add_0x(token_address_bytes.hex())
        f.close()

        addresses = self.keystore.list()

        nonce_oracle = RPCNonceOracle(addresses[2], self.rpc)
        gas_oracle = OverrideGasOracle(limit=AddressDeclarator.gas(), conn=self.rpc)
        c = AddressDeclarator(self.chain_spec, self.signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
        (tx_hash_hex, o) = c.constructor(addresses[2], self.initial_description)
        r = self.rpc.do(o)
        o = receipt(r)
        r = self.rpc.do(o)
        Tx.src_normalize(r)
        self.assertEqual(r['status'], 1)
        self.address_declarator_address = r['contract_address']
        logg.debug('address declarator deployed at {}'.format(self.address_declarator_address))

        nonce_oracle = RPCNonceOracle(addresses[1], self.rpc)
        gas_oracle = OverrideGasOracle(limit=TokenUniqueSymbolIndexAddressDeclarator.gas(), conn=self.rpc)
        c = TokenUniqueSymbolIndexAddressDeclarator(self.chain_spec, self.signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
        (tx_hash_hex, o) = c.constructor(addresses[1], self.address_declarator_address)
        r = self.rpc.do(o)
        o = receipt(r)
        r = self.rpc.do(o)
        Tx.src_normalize(r)
        self.assertEqual(r['status'], 1)
        self.token_index_address = r['contract_address']
        logg.debug('token index deployed at {}'.format(self.token_index_address))

        c = CICWriter(self.chain_spec, self.signer, nonce_oracle=nonce_oracle, gas_oracle=gas_oracle)
        (tx_hash_hex, o) = c.add_writer(self.token_index_address, addresses[1], addresses[1])
        r = self.rpc.do(o)
        o = receipt(r)
        r = self.rpc.do(o)
        Tx.src_normalize(r)
        self.assertEqual(r['status'], 1)

        self.resources = {
            'token': {
                'reference': self.token_address,
                'key_account': addresses[0],
                },
            'token_index': {
                'reference': self.token_index_address,
                'key_account': addresses[1],
                },
            'address_declarator': {
                'reference': self.address_declarator_address,
                'key_account': addresses[2],
                },
        }
        self.chain_spec_dict = {
                'arch': 'evm',
                'fork': 'byzantine',
                'network_id': 42,
                'common_name': 'foo',
            }
        proof_dir = os.path.join(test_data_dir, 'proof')
        attach = Attachment(path=proof_dir)
        attach.load()
        self.proofs = Proof(proof_dir, attachments=attach)
        self.proofs.load()

        logg.debug('proofs {}'.format(self.proofs.attachments))

        self.outputs_dir = tempfile.mkdtemp()
        self.outputs_writer = KVWriter(self.outputs_dir)


class TestCICEthTokenBase(TestCICEthBase):

    def setUp(self):
        super(TestCICEthTokenBase, self).setUp()

        self.resources['token']['reference'] = None
        self.adapter = CICEth(self.chain_spec, self.resources, self.proofs, outputs_writer=self.outputs_writer)
        self.token_name = 'FOotoken'
        self.token_symbol = 'FOO'
        self.token_precision = 8
        self.token_supply = 1073741824

        self.core_processor = ContractProcessor(outputs_writer=self.outputs_writer, extensions=[self.adapter])