import os
import time
from collections import OrderedDict
from typing import Any, MutableMapping

import nacl.signing

from rainbowadn.chain.blockchain import BlockChainFactory
from rainbowadn.chain.chaincollectioninterface import ChainCollectionInterface
from rainbowadn.chain.reduction.reductionchainmetafactory import ReductionChainMetaFactory
from rainbowadn.data.atomic.integer import Integer
from rainbowadn.data.atomic.plain import Plain
from rainbowadn.data.collection.array.array import Array
from rainbowadn.data.collection.trees.binary.activebinarytree import ActiveBinaryTree
from rainbowadn.data.collection.trees.binary.avl import AVLBTBP
from rainbowadn.data.collection.trees.comparison.comparator import Replace
from rainbowadn.data.collection.trees.comparison.plaincomparator import PlainComparator
from rainbowadn.hashing.hashmentionable import HashMentionable
from rainbowadn.hashing.hashpoint import HashPoint
from rainbowadn.hashing.hashresolver import HashResolver
from rainbowadn.hashing.nullability.notnull import NotNull
from rainbowadn.hashing.recursivementionable import RecursiveMentionable
from rainbowadn.v13.algo import MINT_CONST
from rainbowadn.v13.bankchain import BankChain
from rainbowadn.v13.subject import Subject
from rainbowadn.v13.transaction import CoinData, Transaction
from rainbowadn.wrisbt.wrisbtchainprotocol import WrisbtChainProtocol
from rainbowadn.wrisbt.wrisbtparametres import WrisbtParametres
from rainbowadn.wrisbt.wrisbtroot import WrisbtRoot


class DumbResolver(HashResolver):
    def __init__(self):
        self.table: MutableMapping[bytes, bytes] = OrderedDict()

    def _resolve(self, point: bytes) -> bytes:
        assert isinstance(point, bytes)
        return self.table[point]

    def save(self, hash_point: HashPoint) -> None:
        assert isinstance(hash_point, HashPoint)
        if hash_point.point in self.table:
            pass
        elif isinstance(hash_point.value, NotNull):
            value: HashMentionable = hash_point.value.value
            self.table[hash_point.point] = HashPoint.bytes_of_mentioned(value)
            if isinstance(value, RecursiveMentionable):
                for hash_point in value.points():
                    self.save(hash_point)
        else:
            raise TypeError


def main0():
    dr = DumbResolver()
    bank = BankChain.empty(ReductionChainMetaFactory(), dr)
    key_0 = nacl.signing.SigningKey.generate()
    transaction_0 = Transaction.make(
        [],
        [CoinData.of(Subject(key_0.verify_key), 1_000_000)],
        []
    )
    coin_0, coin_1 = transaction_0.coins(dr, MINT_CONST, NotNull(HashPoint.of(Subject(key_0.verify_key))))
    bank = bank.adds(
        [
            transaction_0,
            Transaction.make(
                [coin_1],
                [CoinData.of(Subject(nacl.signing.SigningKey.generate().verify_key), 10_000)],
                [key_0]
            ),
        ]
    )
    bank = bank.adds(
        []
    )
    print(bank)
    print(bank.verify())
    dr.save(HashPoint.of(bank.reference))
    bank = BankChain.from_reference(ReductionChainMetaFactory(), dr.resolve(HashPoint.of(bank.reference).loose()), dr)
    print(bank)
    print(bank.verify())
    # for key, value in dr.table.items():
    #     print(key.hex(), value.hex())


def main1():
    stoptime = time.process_time()

    def measure(message: str):
        nonlocal stoptime
        now = time.process_time()
        print(message, now - stoptime)
        stoptime = now

    dr = DumbResolver()
    btree = WrisbtRoot.empty(WrisbtParametres(1, 5))
    measure('init')
    for _ in range(10000):
        key = os.urandom(5)
        assert not btree.contains(dr, key)
        btree = btree.add(dr, key)
        assert btree.contains(dr, key)
    measure('add')
    dr.save(HashPoint.of(btree))
    measure('save')
    btree = dr.resolve(HashPoint.of(btree).loose())
    print(btree.height)
    measure('resolve')


def main2():
    dr = DumbResolver()
    chain: ChainCollectionInterface[Any, Plain, Array[WrisbtRoot]] = BlockChainFactory(
        WrisbtChainProtocol(dr, Plain.factory(), 2).loose()
    ).loose().empty().loose()
    for _ in range(1000):
        chain = chain.add(HashPoint.of(Plain(os.urandom(16))))

    assert chain
    # noinspection PyUnresolvedReferences
    print(dr.resolve(chain.actual_state().reference.value).height)


def main():
    dr = DumbResolver()
    tree: ActiveBinaryTree[Plain, Integer] = ActiveBinaryTree.empty(
        AVLBTBP(PlainComparator(dr, Replace())), Plain.factory()
    )
    for i in range(26):
        tree = tree.add(HashPoint.of(Plain(bytes([ord('A') + i]))))
    print(tree.reference.str(dr, 0))


if __name__ == '__main__':
    main1()