package main

import (
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"time"
)

const rewardValue = 500 // Reward value for miners in ZUA

// Define the block structure
type Block struct {
	Name          string      // Name of the block (e.g., "zua")
	ParentHash    []byte
	Timestamp     int64
	Transactions  [][]byte
	Nonce         uint64
	CoinbaseValue uint64 // Value of coins created in this block
}

func main() {
	// Initialize the blockchain with the Genesis block
	genesisBlock := createGenesisBlock()
	blockchain := []*Block{genesisBlock}

	// Print the details of the Genesis block
	printBlockDetails("Genesis Block", genesisBlock)

	// Start mining new blocks at a fixed interval of 1 second
	for {
		time.Sleep(time.Second) // Wait for 1 second

		// Create a new block
		newBlock := mineBlock(blockchain[len(blockchain)-1])
		blockchain = append(blockchain, newBlock)

		// Print the details of the new block
		printBlockDetails("New Block", newBlock)

		// Break the loop after reaching the desired number of blocks (for demonstration)
		if len(blockchain) >= 10 {
			break
		}
	}
}

// Function to create the Genesis block
func createGenesisBlock() *Block {
	// Define the timestamp for the genesis block (January 5th, 2024)
	genesisTimestamp := time.Date(2024, time.January, 5, 0, 0, 0, 0, time.UTC).Unix()

	// Define the parent hash for the genesis block
	genesisParentHash, _ := hex.DecodeString("7c380ae690f9eaa64f300451d5e466371113c38b96ed96fe3f1e934869355ffa")

	return &Block{
		Name:          "zua",
		ParentHash:    genesisParentHash,
		Timestamp:     genesisTimestamp,
		Transactions:  [][]byte{[]byte("First Transaction")}, // Include a sample transaction
		Nonce:         0,
		CoinbaseValue: 28_000_000_000, // 28 billion coins
	}
}

// Function to mine a new block
func mineBlock(previousBlock *Block) *Block {
	// Increment the nonce until a valid block hash is found
	nonce := uint64(0)
	for {
		// Create a new block with the incremented nonce
		newBlock := &Block{
			Name:          fmt.Sprintf("%s-%d", previousBlock.Name, nonce),
			ParentHash:    calculateBlockHash(previousBlock),
			Timestamp:     time.Now().Unix(),
			Transactions:  [][]byte{createCoinbaseTransaction()}, // Include reward transaction
			Nonce:         nonce,
			CoinbaseValue: rewardValue, // Set the reward value for miners
		}

		// Calculate the block hash
		blockHash := calculateBlockHash(newBlock)

		// Check if the block hash meets the difficulty target (e.g., starts with a certain number of zeros)
		if isBlockHashValid(blockHash) {
			return newBlock // Return the mined block
		}

		// Increment the nonce for the next iteration
		nonce++
	}
}

// Function to create the Coinbase transaction for the reward
func createCoinbaseTransaction() []byte {
	return []byte(fmt.Sprintf("Coinbase Transaction: %d ZUA", rewardValue))
}

// Function to print block details
func printBlockDetails(title string, block *Block) {
	fmt.Println(title + ":")
	fmt.Println("  Name:", block.Name)
	fmt.Println("  Timestamp:", block.Timestamp)
	fmt.Println("  Nonce:", block.Nonce)
	fmt.Println("  Coinbase Value:", block.CoinbaseValue, "ZUA")
	fmt.Println("  Block Hash:", hex.EncodeToString(calculateBlockHash(block)))
	fmt.Println("  Parent Hash:", hex.EncodeToString(block.ParentHash))
	fmt.Println("  Transactions:")
	for _, tx := range block.Transactions {
		fmt.Println("    -", string(tx))
	}
	fmt.Println("")
}

// Function to calculate the hash of a block
func calculateBlockHash(block *Block) []byte {
	header := fmt.Sprintf("%s-%d-%d-%x", block.Name, block.Timestamp, block.Nonce, block.Transactions)
	hash := sha256.Sum256([]byte(header))
	return hash[:]
}

// Function to check if a block hash meets the difficulty target (placeholder implementation)
func isBlockHashValid(hash []byte) bool {
	// Placeholder implementation: Check if the hash starts with a certain number of zeros
	return hash[0] == 0 && hash[1] == 0 // Example: Difficulty target is 2 leading zeros
}