class BlockChain():
    def __init__(self):
        self.transactions = []
        self.block_chain = []   # ブロックチェーンデータ

    def _create_block(self, nonce, pre_hash):
        # ブロックに情報を格納しチェーンへ追加
        block = OrderedDict()
        block = {
            "timestamp": time.time(),
            "transactions": self.transactions,
            "nonce": nonce,
            "pre_hash": pre_hash,
        }
        self.block_chain.append(block)
        self.transactions = []
        return block

    def _get_block_hash(self, block):
        # ブロックデータをSHA-256によりハッシュ化し返す
        sorted_block = json.dumps(block, sort_keys=True)
        return hashlib.sha256(sorted_block.encode()).hexdigest()

    def sample_connect_block(self):
        # ブロック生成
        self._create_block(nonce, pre_hash=self._get_block_hash(self.block_chain[-1]))

    def _check_block_valid(
        self, transactions, pre_hash, nonce, difficulty=MINING_DIFFICULTY
    ):
        # ブロックのnonceがdifficultyの条件を満たす妥当なものか確認
        guess_block = OrderedDict()
        guess_block = {
            "transactions": transactions,
            "nonce": nonce,
            "pre_hash": pre_hash,
        }
        guess_hash = self._get_block_hash(guess_block)
        return guess_hash[:difficulty] == "0" * difficulty

    def _proof_of_work(self):
        # 適当なnonceが発見されるまで総当たりで計算
        transactions = self.transactions.copy()
        pre_hash = self._get_block_hash(self.block_chain[-1])
        nonce = 0
        while self._check_block_valid(transactions, pre_hash, nonce) is False:
            nonce += 1
        print("SUCCESS MINING")
        return nonce

    def _mining(self):
        # マイナーへの報酬を取引履歴に加えマイニング
        self._add_transaction(
            sender_address=MINING_SENDER,
            recipient_address=self.blockchain_address,
            value=MINING_REWARD,
        )
        nonce = self._proof_of_work()
        pre_hash = self._get_block_hash(self.block_chain[-1])
        self._create_block(nonce, pre_hash)
        return True

class Wallet():
    def __init__(self):
        self._private_key = SigningKey.generate(curve=NIST256p)
        self._public_key = self._private_key.get_verifying_key()
        self._blockchain_address = self._generate_blockchain_address()

    def _generate_blockchain_address(self):
        public_key_bytes = self._public_key.to_string()
        # 公開鍵をハッシュ関数SHA-256に通す
        sha256_bpk = hashlib.sha256(public_key_bytes)
        sha256_bpk_digest = sha256_bpk.digest()

        # ハッシュ関数RIPEMED-160に通す
        ripemed160_bpk = hashlib.new("ripemd160")
        ripemed160_bpk.update(sha256_bpk_digest)
        ripemed160_bpk_digest = ripemed160_bpk.digest()
        ripemed160_bpk_hex = codecs.encode(ripemed160_bpk_digest, "hex")

        # 先頭にプレフィックスとして00を加える
        network_byte = b"00"
        network_bitcoin_public_key = network_byte + ripemed160_bpk_hex
        network_bitcoin_public_key_bytes = codecs.decode(
            network_bitcoin_public_key, "hex"
        )

        # ハッシュ関数SHA-256pに2回通す
        sha256_bpk = hashlib.sha256(network_bitcoin_public_key_bytes)
        sha256_bpk_digest = sha256_bpk.digest()
        sha256_2_nbpk = hashlib.sha256(sha256_bpk_digest)
        sha256_2_nbpk_digest = sha256_2_nbpk.digest()
        sha256_hex = codecs.encode(sha256_2_nbpk_digest, "hex")

        # 4bytesのチェックサムを後ろに加える
        checksum = sha256_hex[:8]
        address_hex = (network_bitcoin_public_key + checksum).decode("utf-8")

        # Base58でエンコード
        blockchain_address = base58.b58encode(address_hex).decode("utf-8")
        return blockchain_address

class Transaction():
    def __init__(
        self,
        sender_private_key,
        sender_public_key,
        sender_address,
        recipient_address,
        value,
    ):
        self.sender_private_key = sender_private_key
        self.sender_public_key = sender_public_key
        self.sender_address = sender_address
        self.recipient_address = recipient_address
        self.value = value

    def generate_signature(self):
        # 取引情報に秘密鍵を用いて署名を行う
        sha256 = hashlib.sha256()
        transaction = OrderedDict()
        transaction = {
            "sender_address": self.sender_address,
            "recipient_address": self.recipient_address,
            "value": float(self.value),
        }
        sha256.update(str(transaction).encode("utf-8"))
        message = sha256.digest()
        private_key = SigningKey.from_string(
            bytes().fromhex(self.sender_private_key), curve=NIST256p
        )
        private_key_sign = private_key.sign(message)
        signature = private_key_sign.hex()
        return signature

    def _verify_signature(self, sender_public_key, signature, transaction):
        # 取引情報の署名を公開鍵で検証
        sha256 = hashlib.sha256()
        sha256.update(str(transaction).encode("utf-8"))
        message = sha256.digest()
        signature_bytes = bytes().fromhex(signature)
        verifying_key = VerifyingKey.from_string(
            bytes().fromhex(sender_public_key), curve=NIST256p
        )
        verified_key = verifying_key.verify(signature_bytes, message)
        return verified_key

    def _add_transaction(
        self,
        sender_address,
        recipient_address,
        value,
        sender_public_key=None,
        signature=None,
    ):
        transaction = OrderedDict()
        transaction = {
            "sender_address": sender_address,
            "recipient_address": recipient_address,
            "value": float(value),
        }
        if sender_address == MINING_SENDER:
            # マイニング報酬は署名検証無視
            self.transactions.append(transaction)
            return True
        if self._verify_signature(sender_public_key, signature, transaction):
            # 署名検証が正しい場合は取引情報を取引情報プールへ追加
            if self.calculate_total_amount(sender_address) < float(value):
                # 残高不足は取引不成立
                return False
            self.transactions.append(transaction)
            return True
        return False

    def _valid_chain(self, chain):
        # nonceが正しいものであるかを確認しチェーンの正当性を検証
        pre_block = chain[0]
        current_index = 1
        while current_index < len(chain):
            block = chain[current_index]
            if block["pre_hash"] != self._get_block_hash(pre_block):
                return False
            if not self._check_block_valid(
                block["transactions"],
                block["pre_hash"],
                block["nonce"],
                MINING_DIFFICULTY,
            ):
                return False
            pre_block = block
            current_index += 1
        return True

    def resolve_conflicts(self):
        # 正当なチェーンでかつ自身が持つものより長ければ追加
        longest_chain = None
        max_length = len(self.block_chain)
        for node in self.neighbours:
            response = requests.get(f"{node}/viewchain")
            if response.status_code == 200:
                response_json = response.json()
                chain = response_json["chain"]
                chain_length = len(chain)
                if chain_length > max_length and self._valid_chain(chain):
                    max_length = chain_length
                    longest_chain = chain
        if longest_chain:
            self.block_chain = longest_chain
            print("find other longest chain, replaced")
            return True
        return False

def check_internet(url, timeout=5):
    # 稼働し正常なレスポンスがあるかの確認
    try:
        response = urllib.request.urlopen(url).getcode()
        if response == 200:
            return True
        return False
    except urllib.error.HTTPError as ex:
        print(ex)
        return False

def find_neighbours():
    # 稼働しているノードをピアとして追加
    neighbours = []
    candidate_address_list = node_sheet.NODE_LIST
    host_name = node_sheet.MY_NODE
    print("find neighbour node process in ", host_name)
    for guess_address in candidate_address_list:
        if guess_address == host_name:
            continue
        if check_internet(guess_address):
            neighbours.append(guess_address)
    return neighbours