package main

import (
    "crypto/ecdsa"
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "math/big"
    "time"

    "github.com/ethereum/go-ethereum/crypto"
)

// Block represents each 'item' in the blockchain
type Block struct {
    Timestamp     int64
    Data          []byte
    PrevBlockHash []byte
    Hash          []byte
    Validator     []byte
}

// Blockchain is a series of validated Blocks
type Blockchain struct {
    blocks []*Block
}

var validators = make(map[string]int)

// NewBlock creates and returns Block
func NewBlock(data string, prevBlockHash []byte, validator []byte) *Block {
    block := &Block{time.Now().Unix(), []byte(data), prevBlockHash, []byte{}, validator}
    block.Hash = block.calculateHash()
    return block
}

// calculateHash calculates and returns Block's hash
func (b *Block) calculateHash() []byte {
    record := string(b.Timestamp) + string(b.Data) + string(b.PrevBlockHash) + string(b.Validator)
    h := sha256.New()
    h.Write([]byte(record))
    hashed := h.Sum(nil)
    return hashed
}

// AddBlock saves the block into the blockchain
func (bc *Blockchain) AddBlock(data string, validator []byte) {
    prevBlock := bc.blocks[len(bc.blocks)-1]
    newBlock := NewBlock(data, prevBlock.Hash, validator)
    if validateBlock(newBlock, prevBlock) {
        bc.blocks = append(bc.blocks, newBlock)
        validators[string(validator)] += 1
    }
}

// validateBlock checks if block's hash is valid
func validateBlock(newBlock, prevBlock *Block) bool {
    if string(newBlock.PrevBlockHash) != string(prevBlock.Hash) {
        return false
    }

    if !isValidValidator(newBlock.Validator) {
        return false
    }

    return true
}

// isValidValidator checks if the validator is authorized
func isValidValidator(validator []byte) bool {
    _, ok := validators[string(validator)]
    return ok
}

// NewBlockchain creates a new Blockchain with genesis Block
func NewBlockchain() *Blockchain {
    return &Blockchain{[]*Block{NewBlock("Genesis Block", []byte{}, []byte("Genesis Validator"))}}
}

func main() {
    // Create a new Blockchain instance
    bc := NewBlockchain()

    // Generate a new validator key
    privateKey, err := crypto.GenerateKey()
    if err != nil {
        fmt.Println(err)
        return
    }
    publicKey := privateKey.Public().(*ecdsa.PublicKey)
    validator := crypto.FromECDSAPub(publicKey)

    // Add validator to the list
    validators[hex.EncodeToString(validator)] = 0

    // Add a new block
    bc.AddBlock("First Block Data", validator)

    for _, block := range bc.blocks {
        fmt.Printf("Prev. hash: %xn", block.PrevBlockHash)
        fmt.Printf("Data: %sn", block.Data)
        fmt.Printf("Hash: %xn", block.Hash)
        fmt.Printf("Validator: %xnn", block.Validator)
    }
}