pub struct Block {
    pub timestamp: i64,
    pub prev_block_hash: BigUint,
    pub data: Vec<u8>,
    pub hash: BigUint,//大数
    pub nonce: u64 //是一个随机值，找到这个随机值，就是循环了几次找到的hash
}

pub struct BlockChain {
    pub blocks: Vec<Box<Block>>,
}

pub struct ProofOfWork{
    pub block:Box<Block>,//要进行工作的区块
    pub target:BigUint,//目标值
}

pub fn leading_zero_to_string(str:String,width:u32) -> String{
    let mut leading_zero = width - (str.len() as u32);
    let mut leading_zero_str = String::new();

    loop {
        if leading_zero != 0 {
            leading_zero = leading_zero - 1;

            leading_zero_str.push_str("0");
        } else { break; }
    }

    leading_zero_str.push_str(str.as_str());
    leading_zero_str
}

#[derive(Debug,Deserialize,Serialize)]
pub struct BlockChain {
    pub blocks: Vec<Box<Block>>,
}

#[derive(Debug, Clone,Deserialize,Serialize)]
pub struct Block {
    pub timestamp: i64,
    pub prev_block_hash: Vec<u8>,//还是不能用BigUint，考虑到序列化问题，这个结构没有实现Deserialize,Serialize
    pub data: Vec<u8>,
    pub hash: Vec<u8>,//大数
    pub nonce: u64 //是一个随机值，找到这个随机值，就是循环了几次找到的hash
}

    pub async fn serialize(&self) -> Vec<u8>{
        let block_chain_str = serde_json::to_string(self).expect("block to string err.");
        block_chain_str.into_bytes()
    }

impl Block {

    pub async fn serializer(&self) -> Vec<u8>{
        let block_chain_str = serde_json::to_string(self).expect("block to string err.");
        block_chain_str.into_bytes()
    }

    pub async fn to_doc(&self) -> bson::Document{
        let mut doc = bson::Document::new();
        let block_serialize = self.serializer().await;
        let block_hash = BigUint::from_bytes_be(self.hash.as_slice()).to_str_radix(16);

        // let b = bson::to_bson(block_serialize.as_slice()).expect("[u8] to bson err");
        let mut b = bson::Binary{ subtype: spec::BinarySubtype::Generic, bytes:  block_serialize };
        doc.insert("key",block_hash);
        doc.insert("value",b);
        doc
    }
}

pub struct BlockChain {
    // pub blocks: Vec<Box<Block>>,
    pub tip:String,//最后一个区块的hash，即vec<u8> to hex string
}

///创建区块链，带有创世区块
pub async fn new_block_chain() -> Box<BlockChain> {
    //创造创世区块
    let block = new_genesis_block().await;

    //获取mongodb，collection
    let mongodb_client = super::MONGODB_INSTANCE.get().unwrap();
    let db = mongodb_client.database(super::DATA_BASE);
    let collection = db.collection(super::DATA_COLLECTION);

    //插入创世区块
    collection.insert_one(block.to_doc().await,InsertOneOptions::default());

    //生成创世区块
    let block_hash = BigUint::from_bytes_be(block.hash.as_slice()).to_str_radix(16);
    
    let block_chain = BlockChain{ tip: block_hash.to_string() };
    Box::new(block_chain)
}

    pub async fn add_block(mut self, data: String) -> Box<BlockChain> {
        //获取mongodb collection
        let mongodb_client = super::MONGODB_INSTANCE.get().unwrap();
        let db = mongodb_client.database(super::DATA_BASE);
        let collection = db.collection(super::DATA_COLLECTION);

        //获取区块的bytes
        let mut doc = bson::Document::new();
        doc.insert("key",self.tip.clone());

        //这里知识界解包了，会出错，找不到会有none
        let find_doc:bson::Document = collection.find_one(doc,FindOneOptions::default()).unwrap().unwrap();

        //解析，反序列化
        let bs = find_doc.get("value").cloned().unwrap();
        let binary = bson::from_bson::<bson::Binary>(bs).unwrap();
        let prev_block = serde_json::from_slice::<Block>(binary.bytes.as_slice()).expect("Deserialize block err");

        //生成新区快
        let mut block = new_block(data,prev_block.hash).await;

        //工作量证明
        let pow = new_proof_of_work(*block).await;
        block = pow.run().await;

        //存新块到库中
        collection.insert_one(block.to_doc().await,InsertOneOptions::default());
        //计算新区快的hash [u8] to hex
        let block_hash = BigUint::from_bytes_be(block.hash.as_slice()).to_str_radix(16);

        //替换blockchain中的最后区块的hash
        self.tip = block_hash;

        //返回一个blockchain的指针
        Box::new(self)
    }

impl Iterator for BlockChain{
    //饭会的类型是Block
    //在这里使用的是内联？我记得是叫类型内联把，我也记不清了
    //代替了泛型，内置一个返回的type，这个type具体什么类型，自己定义
    //可能我学的还不深，内在的哲学我没get到
    type Item = Block;

    fn next(&mut self) -> Option<Self::Item> {
        
        //连接mongodb
        let mongodb_cli = super::MONGODB_INSTANCE.get().unwrap();
        let db = mongodb_cli.database(super::DATA_BASE);
        let collection = db.collection(super::DATA_COLLECTION);

        //获取blockchain的hash来从库中找寻block
        let hash = self.tip.as_str();
        let op :Option<bson::Document> = collection.find_one(doc!["key":hash], FindOneOptions::default()).unwrap();

        //找不到直接返回none，迭代结束
        return match op {
            None =>Option::None,
            Some(find_doc)=>{
                //解析bytes
                let bs = find_doc.get("value").cloned().unwrap();
                let binary = bson::from_bson::<bson::Binary>(bs).unwrap();
                let block = serde_json::from_slice::<Block>(binary.bytes.as_slice()).expect("Deserialize block err");
                Option::Some(block)
            }
        }

    }

}

//这里是遍历的过程，写的很搓，后面再重构吧（当码农的乐趣不就是重构么[捂脸]）
let mut iter = *block_chain.clone().into_iter();
loop {
	match iter.next(){
		None => break,
		Some(b) => {
			println!("{}",b);
			let mut blc = *block_chain.clone();
			blc.tip = BigUint::from_bytes_be(b.prev_block_hash.as_slice()).to_str_radix(16);
			iter = blc.into_iter();
		}
	}

}

let binary = bson::from_bson::<bson::Binary>(bs).unwrap();

fn main() {
    //接收参数
    let args: Vec<String> = env::args().collect();
    //这里用了一个全局单例，要不args无法传入到异步块中，应该是我太菜，找不到好的方法，就用了这个方法
    ARGS_INSTANCE.set(args);
    //初始化数据库
    db::mongodb_con();

    let runtime = tokio::runtime::Runtime::new().unwrap();

    runtime.spawn(async {
        let args = ARGS_INSTANCE.get().unwrap();
        
        //cli命令行的功能
        match args.len() {
            //从1开始 是因为启动的那串字符也算参数
            1 =>{ // 没有参数
                let mut var = String::new();
                if cfg!(target_os = "windows"){
                    var = "block-chain-rust.exe".to_string();
                } else if cfg!(target_os = "linux"){
                    var = "./block-chain-rust".to_string();
                }
                println!("please input:");
                println!("createBlockChain: {} createBlockChain",var);
                println!("createBlockChain: {} printBlockChain",var);
                println!("addBlock: {} addBlock \"data\"",var);
            },
            2 =>{ // 一个参数
                match args[1].as_str() {
                    "createBlockChain" => {
                        match blc::block_chain::new_block_chain().await {
                            None => {println!("the block chain is exist!")}
                            Some(blc) => {println!("create block chain success")}
                        }

                    }
                    "printBlockChain" => {
                        BlockChain::print_block_chain().await;
                    }
                    &_ => {}
                }
            },
            3 =>{ // 两个参数
                match args[1].as_str() {
                    "addBlock" => {
                        let data = &args[2];

                        match BlockChain::add_block(data.to_string()).await{
                            None => println!("the database not exist"),
                            Some(_) => println!("add block to chain true"),
                            _ => {}
                        }
                    }
                    &_ => {}
                }
            }
            _ => {}
        }

    });

}

	pub async fn print_block_chain(){
        let mongodb_cli = super::MONGODB_INSTANCE.get().unwrap();
        let db = mongodb_cli.database(super::DATA_BASE);
        let collection = db.collection(super::DATA_COLLECTION);

        let find_cursor = collection.find(None,FindOptions::default()).unwrap();
        let mut vec_doc: Vec<mongodb::error::Result<bson::Document>> = find_cursor.collect();

        if vec_doc.is_empty() {
            println!("the database is empty");
        } else {
            // 遍历区块链
            vec_doc.reverse();
            for result in vec_doc {
                let doc = result.unwrap();
                let bs = doc.get("value").cloned().unwrap();
                let binary = bson::from_bson::<bson::Binary>(bs).unwrap();
                let block = serde_json::from_slice::<Block>(binary.bytes.as_slice()).expect("Deserialize block err");
                println!("{}",block);
            }
        }
    }