import hashlib

PBKDF2_ROUNDS = 2048

def mnemonic_to_seed(mnemonic_words: list, passphrase: str = "") -> bytes:
    """
    Convert a mnemonic phrase into a seed.

    :param mnemonic_words: List of mnemonic words.
    :param passphrase: An optional passphrase to enhance security.
    :return: A 64-byte seed.
    """
    mnemonic_str = " ".join(mnemonic_words).strip()
    print(f"mnemonic_str: {mnemonic_str}")
    salt = "mnemonic" + passphrase.strip()
    print(f"salt: {salt}")

    # Generate the seed using PBKDF2-HMAC-SHA512 (password-based key derivation function 2)
    seed = hashlib.pbkdf2_hmac(
        "sha512", mnemonic_str.encode("utf-8"), salt.encode("utf-8"), PBKDF2_ROUNDS
    )
    return seed

# Example usage
mnemonic_list = ['bring', 'boil', 'cattle', 'dawn', 'off', 'buyer', 'weird', 'plug', 'summer', 'federal', 'misery', 'ship']
passphrase = ""
seed = mnemonic_to_seed(mnemonic_list, passphrase)
print(f"Generated seed: {seed.hex()} ({len(seed)} bytes)")

import hmac

def derive_master_key(seed: bytes) -> tuple[bytes, bytes]:
    """
    Derive the master key and chain code from the seed.

    :param seed: A 64-byte seed.
    :return: A tuple containing the master private key and chain code.
    """
    key = b"Bitcoin seed"
    h = hmac.new(key, seed, hashlib.sha512).digest()
    master_key = h[:32]
    chain_code = h[32:]
    return master_key, chain_code

# Example usage
print(f"Generate master key using seed {seed.hex()} ({len(seed)} bytes)")
master_key, chain_code = derive_master_key(seed)
print(f"Master Key: {master_key.hex()} ({len(master_key)} bytes)")
print(f"Chain Code: {chain_code.hex()} ({len(chain_code)} bytes)")

from ecdsa.util import string_to_number
from ecdsa import SigningKey, VerifyingKey, SECP256k1
import hashlib
import hmac

def derive_child_key(
    parent_key: bytes,
    parent_chain_code: bytes,
    index: int
) -> tuple[bytes, bytes, bytes]:
    """
    Derive a child key from a parent key and chain code.

    :param parent_key: The parent private key (32 bytes).
    :param parent_chain_code: The parent chain code.
    :param index: The child index (use hardened index for added security).
    :return: A tuple containing the child private key, chain code, and public key.
    """
    # Convert index to 4-byte big-endian
    hdi = index.to_bytes(4, "big")
    print(f"Index (4 bytes): {hdi.hex()}")

    if index & 0x80000000:  # Hardened derivation
        # Hardened: Use private key
        data = b"\x00" + parent_key + hdi
    else:  # Normal derivation
        parent_pub_key = derive_public_key_from_private_key(parent_key)
        data = parent_pub_key + hdi
    
    print(f"HMAC input data: {data.hex()}")

    # Perform HMAC-SHA512
    h = hmac.new(parent_chain_code, data, hashlib.sha512).digest()
    child_tweak = string_to_number(h[:32])  # First 32 bytes
    child_chain_code = h[32:]  # Last 32 bytes

    print(f"Child tweak: {h[:32].hex()}, Child chain code: {child_chain_code.hex()}")

    # SECP256k1's curve order
    n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

    # Compute child private key
    parent_int = string_to_number(parent_key)
    child_private_key = (parent_int + child_tweak) % n
    if child_private_key == 0:
        raise ValueError("Derived child private key is invalid (zero).")

    child_private_key_bytes = child_private_key.to_bytes(32, "big")
    print(f"Derived child private key: {child_private_key_bytes.hex()}")

    # Compute child public key from private key
    child_pub_key = derive_public_key_from_private_key(child_private_key_bytes)

    return child_private_key_bytes, child_chain_code, child_pub_key

def derive_public_key_from_private_key(private_key: bytes) -> bytes:
    """
    Derive the public key from the private key.

    :param private_key: The private key (32 bytes).
    :return: The compressed public key (33 bytes).
    """
    sk = SigningKey.from_string(private_key, curve=SECP256k1)
    vk = sk.verifying_key
    x = vk.pubkey.point.x()
    prefix = b"\x02" if vk.pubkey.point.y() % 2 == 0 else b"\x03"
    return prefix + x.to_bytes(32, "big")

def derive_from_path(
    master_key: bytes,
    chain_code: bytes,
    path: str
) -> tuple[bytes, bytes, bytes]:
    """
    Derive a key from a given derivation path.

    :param master_key: The master private key.
    :param chain_code: The master chain code.
    :param path: The derivation path (e.g., "m/44'/60'/0'/0/0").
    :return: The derived private key, chain code, and public key.
    """
    levels = path.split("/")[1:]  # Skip "m"
    key, code = master_key, chain_code

    for level in levels:
        if "'" in level:  # Hardened key
            index = 0x80000000 | int(level[:-1])
        else:  # Normal key
            index = int(level)

        print(f"Processing index: {index} (Hardened: {'Yes' if index & 0x80000000 else 'No'})")
        key, code, pub_key = derive_child_key(key, code, index)

        # Log the current state
        print(f"Derived private key: {key.hex()}")
        print(f"Derived chain code: {code.hex()}")
        print(f"Derived public key: {pub_key.hex()}")

    return key, code, pub_key
    
# Example usage
path = "m/44'/60'/0'/0/0" # Compare with Metamask
derived_key, derived_chain_code, derived_pub_key = derive_from_path(master_key, chain_code, path)
print(f"Derived Private Key: {derived_key.hex() if derived_key else None}")
print(f"Derived Chain Code: {derived_chain_code.hex()}")
print(f"Derived Public Key: {derived_pub_key.hex()}")

func TestPrivateKey(t *testing.T) {
	privateKey, err := crypto.GenerateKey()
	require.NoError(t, err)

	// Parameters of the secp256k1 curve which is used in Ethereum
	curveParams := privateKey.Params()
	t.Logf("P: %x\n", curveParams.P)
	t.Logf("N: %x\n", curveParams.N)
	t.Logf("B: %x\n", curveParams.B)
	t.Logf("Gx: %x\n", curveParams.Gx)
	t.Logf("Gy: %x\n", curveParams.Gy)
	t.Logf("BitSize: %v\n", curveParams.BitSize)
	t.Logf("Name: %v\n", curveParams.Name)

	// The private key is just a random number
	t.Logf("D: %x\n", privateKey.D)

	// The public key is a point on the curve calculated by (Gx, Gy) * D
	t.Logf("X: %x\n", privateKey.PublicKey.X)
	t.Logf("Y: %x\n", privateKey.PublicKey.Y)

	// Uncomprseed public key = 04 + X + Y
	t.Logf("Uncompressed Public Key: %x\n", crypto.FromECDSAPub(&privateKey.PublicKey))

	// Compressed public key = 02 or 03 + X
	t.Logf("Compressed Public Key: %x\n", crypto.CompressPubkey(&privateKey.PublicKey))

	// Sign a message
	message := []byte("Hello, world!")
	messageHash := crypto.Keccak256Hash(message)
	signature, err := crypto.Sign(messageHash[:], privateKey)
	require.NoError(t, err)
	t.Logf("Signature: %x\n", signature)

	// Verify the signature
	crypto.VerifySignature(crypto.FromECDSAPub(&privateKey.PublicKey), messageHash[:], signature)
}