#!/usr/bin/env python

# encoding: utf-8

'''

我们要创建一个 Blockchain 类 ，他的构造函数创建了一个初始化的空列表（要存储我们的区块链），并且另一个存储交易。

我们的 Blockchain 类负责管理链式数据，它会存储交易并且还有添加新的区块到链式数据的Method。

'''

import hashlib

import json

import time

from textwrap import dedent

from uuid import uuid4

from flask import Flask,jsonify,request

class Blockchain(object):

    def __init__(self):

        self.chain=[]

        self.current_transations=[]

        ## 创建创世区块，源区块，第一个区块前面没了。

        self.new_block(previous_hash=1,proof=100)

    def new_block(self,previous_hash,proof):

        '''

        创建一个新的区块到区块链

        :param previous_hash:前一个区块的hash值

        :param proof: 由工作量证明（PoW）算法生成的证明

        :return: 返回新的区块

        '''

        block={

            'index':len(self.chain)+1,

            'timestamp':time.time(),

            'transactions':self.current_transations,

            'proof':proof,

            'previous_hash':previous_hash or self.hash(self.chain[-1])

        }

        #重置当前交易记录

        self.current_transations=[]

        self.chain.append(block)

        return block

    def new_transation(self,sender,recipient,amount):

        # Adds a new transaction to the list of transactions

        '''

        创建一笔新的交易到下一个被挖掘的区块中

        :param sender: 发送者

        :param recipient: 接收方

        :param amount: 发送数量

        :return: 返回将被添加到的区块的索引

        '''

        self.current_transations.append({

            'sender':sender,

            'recipient':recipient,

            'amount':amount,

             })

        return self.last_block['index']+1

    @staticmethod

    def hash(block):

        '''

        给一个区块生成SHA-256值

        :param block: Block

        :return: 返回hash值

        '''

        #我们相比下确保这个字典（区块）是经过排序的，否则我们将会得到不一致的散列

        block_string=json.dumps(block,sort_keys=True).encode()

        return hashlib.sha256(block_string).hexdigest()

    #@property装饰器就是负责把一个方法变成属性调用的

    @property

    def last_block(self):

        # Returns the last Block in the chain

        return self.chain[-1]

    #每个块都有一个 索引，一个 时间戳（Unix时间戳），一个事务列表， 一个 校验(稍后详述) 和 前一个块的散列 。

    """

   实现工作量证明

   让我们来实现一个相似 PoW 算法。规则类似上面的例子：

   找到一个数字 P ，使得它与前一个区块的 proof 拼接成的字符串的 Hash 值以 4 个零开头。

   衡量算法复杂度的办法是修改零开头的个数。使用 4 个来用于演示，你会发现多一个零都会大大增加计算出结果所需的时间。

   """

    def proof_of_work(self,last_proof):

        '''

        :param last_proof:

        :return:

        '''

        proof=0

        while self.valid_proof(last_proof,proof) is False:

            proof+=1

        return proof

    @staticmethod

    def valid_proof(last_proof,proof):

        '''

        :param last_proof: 上一个pow算法

        :param proof: 现在的pow算法

        :return:

        '''

        guess=f'{last_proof}{proof}'.encode()

        guess_hash=hashlib.sha256(guess).hexdigest()

        return guess_hash[:4]=="0000"

app=Flask(__name__)

node_identity=str(uuid4()).replace('-','')

blockchain=Blockchain()

@app.route('/')

@app.route('/mine',methods=['GET'])

def mine():

     # 挖矿

     # 挖矿正是神奇所在，它很简单，做了一下三件事：

     #

     # 计算工作量证明 PoW

     # 通过新增一个交易授予矿工（自己）一个币

     # 构造新区块并将其添加到链中

     # We run the proof of work algorithm to get the next proof...

     last_block=blockchain.last_block

     last_proof=last_block['proof']

     proof=blockchain.proof_of_work(last_proof)

     # We must receive a reward for finding the proof.

     # The sender is "0" to signify that this node has mined a new coin.

     blockchain.new_transation(

         sender="0",

         recipient=node_identity,

         amount=1,

     )

    # Forge the new Block by adding it to the chain

     previous_hash=blockchain.hash(last_block)

     block=blockchain.new_block(proof,previous_hash)

     response={

         'message': "New Block Forged",

         'index': block['index'],

         'transactions': block['transactions'],

         'proof': block['proof'],

         'previous_hash': block['previous_hash'],

     }

     return jsonify(response),200

@app.route('/transactions/new',methods=['POST'])

def new_transaction():

    '''

    我们将添加一个新的事务处理

    :return:

    '''

    values=request.get_json()

    required=['sender','recipient','amount']

    if not all(k in values for k in required):

        return "Missing values", 400

    #创建一个新的事务

    index=blockchain.new_transation(values['sender'],values['recipient'],values['amount'])

    response={'message':f'在区块上添加事务{index}'}

    return jsonify(response),201

@app.route('/chain',methods=['GET'])

def full_chain():

    a_chain=blockchain.chain

    response={

        'chain':a_chain,

        'length':len(a_chain),

    }

    return jsonify(response),200

if __name__=="__main__":

    app.run(debug=True)

# 注意交易的接收者是我们自己的服务器节点，我们做的大部分工作都只是围绕 Blockchain 类方法进行交互。

# 到此，我们的区块链就算完成了，我们来实际运行下.