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.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.hashing.resolvermetaorigin import ResolverMetaOrigin
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_bytes(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
        else:
            value: HashMentionable = hash_point.resolve()
            assert isinstance(value, HashMentionable)
            self.table[hash_point.point] = HashPoint.bytes_of_mentioned(value)
            if isinstance(value, RecursiveMentionable):
                for hash_point in value.points():
                    self.save(hash_point)


def main0():
    dr = DumbResolver()
    bank = BankChain.empty(ReductionChainMetaFactory())
    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(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(), ResolverMetaOrigin(dr).migrate(HashPoint.of(bank.reference)).resolve()
    )
    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) -> float:
        nonlocal stoptime
        now = time.process_time()
        delta = now - stoptime
        print(message, delta)
        stoptime = now
        return delta

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


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

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


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


if __name__ == '__main__':
    main0()