// TestDoubleSHA256 tests the Bitcoin-specific double SHA-256 hashing.
//
// Double SHA-256 is the core hashing algorithm used in Bitcoin:
//   - Block hashes
//   - Transaction IDs (TXID)
//   - Merkle tree nodes
//
// Formula: DoubleSHA256(x) = SHA-256(SHA-256(x))
func TestDoubleSHA256(t *testing.T) {
	tests := []struct {
		name     string
		input    string // hex encoded input
		expected string // hex encoded hash
	}{
		{
			name:     "empty_bytes",
			input:    "",
			expected: "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456",
		},
		{
			name:     "hello",
			input:    "68656c6c6f", // "hello" in hex
			expected: "9595c9df90075148eb06860365df33584b75bff782a510c6cd4883a419833d50",
		},
		{
			name:     "genesis_block_header",
			// Genesis block header (80 bytes)
			// Version(4) + PrevHash(32) + MerkleRoot(32) + Timestamp(4) + Bits(4) + Nonce(4)
			input: "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c",
			// Expected: Internal format (little-endian)
			expected: "6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			input, _ := hex.DecodeString(tt.input)
			result := DoubleSHA256(input)  // ← 아직 없는 함수!

			got := hex.EncodeToString(result)
			if got != tt.expected {
				t.Errorf("DoubleSHA256(%s):\nexpected: %s\ngot:      %s",
					tt.input[:min(len(tt.input), 40)], tt.expected, got)
			}
		})
	}
}

// TestHash160 tests the Bitcoin address hashing function.
//
// Hash160 is used to generate Bitcoin addresses from public keys:
//   Formula: Hash160(x) = RIPEMD-160(SHA-256(x))
func TestHash160(t *testing.T) {
	tests := []struct {
		name     string
		input    string // hex encoded input
		expected string // hex encoded hash (20 bytes)
	}{
		{
			name:     "empty_bytes",
			input:    "",
			expected: "b472a266d0bd89c13706a4132ccfb16f7c3b9fcb",
		},
		{
			name:     "hello",
			input:    "68656c6c6f",
			expected: "b6a9c8c230722b7c748331a8b450f05566dc7d0f",
		},
		{
			name: "satoshi_pubkey",
			// Genesis block coinbase output public key (uncompressed, 65 bytes)
			input:    "0496b538e853519c726a2c91e61ec11600ae1390813a627c66fb8be7947be63c52da7589379515d4e0a604f8141781e62294721166bf621e73a82cbf2342c858ee",
			expected: "119b098e2e980a229e139a9ed01a469e518e6f26",
			// → After Base58Check: 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			input, _ := hex.DecodeString(tt.input)
			result := Hash160(input)  // ← 아직 없는 함수!

			got := hex.EncodeToString(result)
			if got != tt.expected {
				t.Errorf("Hash160: expected %s, got %s", tt.expected, got)
			}

			// Verify hash length is always 20 bytes
			if len(result) != 20 {
				t.Errorf("Hash160 length: expected 20, got %d", len(result))
			}
		})
	}
}

// TestReverseBytes tests byte order reversal for display formatting.
func TestReverseBytes(t *testing.T) {
	tests := []struct {
		name     string
		input    string
		expected string
	}{
		{
			name:     "empty",
			input:    "",
			expected: "",
		},
		{
			name:     "single_byte",
			input:    "01",
			expected: "01",
		},
		{
			name:     "simple_sequence",
			input:    "0102030405",
			expected: "0504030201",
		},
		{
			name: "genesis_block_hash_internal_to_display",
			// Internal format (little-endian)
			input: "6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000",
			// Display format (big-endian) - what you see on block explorers
			expected: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			input, _ := hex.DecodeString(tt.input)
			result := ReverseBytes(input)  // ← 아직 없는 함수!

			got := hex.EncodeToString(result)
			if got != tt.expected {
				t.Errorf("ReverseBytes: expected %s, got %s", tt.expected, got)
			}
		})
	}
}

// TestGenesisBlockHash is a comprehensive integration test.
//
// This verifies that our cryptographic functions correctly implement
// Bitcoin's protocol by reproducing the exact Genesis Block hash.
//
// Genesis Block details:
//   - Block Height: 0
//   - Date: 2009-01-03 18:15:05 UTC
//   - Block Hash: 000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
//   - Coinbase message: "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks"
func TestGenesisBlockHash(t *testing.T) {
	// Genesis block header (80 bytes)
	headerHex := "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c"
	header, _ := hex.DecodeString(headerHex)

	// Step 1: Compute double SHA-256 hash (internal format)
	hashInternal := DoubleSHA256(header)
	expectedInternal := "6fe28c0ab6f1b372c1a6a246ae63f74f931e8365e15a089c68d6190000000000"
	gotInternal := hex.EncodeToString(hashInternal)

	if gotInternal != expectedInternal {
		t.Errorf("Genesis block hash (internal):\nexpected: %s\ngot:      %s",
			expectedInternal, gotInternal)
	}

	// Step 2: Reverse bytes for display format
	hashDisplay := ReverseBytes(hashInternal)
	expectedDisplay := "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
	gotDisplay := hex.EncodeToString(hashDisplay)

	if gotDisplay != expectedDisplay {
		t.Errorf("Genesis block hash (display):\nexpected: %s\ngot:      %s",
			expectedDisplay, gotDisplay)
	}

	t.Logf("✓ Genesis Block Hash verified!")
	t.Logf("  Internal: %s", gotInternal)
	t.Logf("  Display:  %s", gotDisplay)
}

// DoubleSHA256 computes SHA-256(SHA-256(data)), the core hash function in Bitcoin.
//
// Double SHA-256 is Bitcoin's primary hashing algorithm, used for:
//   - Block hashes: Proof-of-Work validation
//   - Transaction IDs (TXID): Unique transaction identifiers
//   - Merkle tree construction: Aggregating transaction hashes
//
// Why double hashing?
//  1. Defense against length extension attacks on SHA-256
//  2. Additional layer of security (defense in depth)
//  3. Historical consistency with Bitcoin's original design
//
// Returns: 32-byte hash value
//
// Reference:
//   - https://en.bitcoin.it/wiki/Block_hashing_algorithm
func DoubleSHA256(data []byte) []byte {
	// First SHA-256
	firstHash := sha256.Sum256(data)

	// Second SHA-256 on the result of the first
	secondHash := sha256.Sum256(firstHash[:])

	return secondHash[:]
}

import (
	"crypto/sha256"
	"golang.org/x/crypto/ripemd160"
)

// Hash160 computes RIPEMD-160(SHA-256(data)), used for Bitcoin address generation.
//
// Formula: Hash160(x) = RIPEMD-160(SHA-256(x))
//
// Returns: 20-byte hash value
//
// Reference:
//   - https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses
func Hash160(data []byte) []byte {
	// Step 1: SHA-256
	sha := sha256.Sum256(data)

	// Step 2: RIPEMD-160
	ripe := ripemd160.New()
	ripe.Write(sha[:])

	return ripe.Sum(nil)
}

// ReverseBytes reverses the byte order of a byte slice.
//
// This function is essential for converting between Bitcoin's internal
// representation (little-endian) and the display format (big-endian).
//
// Returns: A new byte slice with reversed byte order
func ReverseBytes(data []byte) []byte {
	// Create a new slice with the same length
	result := make([]byte, len(data))

	// Copy bytes in reverse order
	for i := range data {
		result[i] = data[len(data)-1-i]
	}

	return result
}