import binascii
from bip_utils import (
    MoneroEntropyBitLen, MoneroEntropyGenerator, MoneroLanguages, MoneroWordsNum,
    MoneroMnemonicEncoder, MoneroMnemonicGenerator
)

# Generate a random mnemonic string of 25 words with default language (English)
# A Mnemonic object will be returned
mnemonic = MoneroMnemonicGenerator().FromWordsNumber(MoneroWordsNum.WORDS_NUM_25)

# Get words count
print(mnemonic.WordsCount())
# Get as string
print(mnemonic.ToStr())
print(str(mnemonic))
# Get as list of strings
print(mnemonic.ToList())

# Generate a random mnemonic string of 13 words by specifying the language
mnemonic = MoneroMnemonicGenerator(MoneroLanguages.ITALIAN).FromWordsNumber(MoneroWordsNum.WORDS_NUM_13)

# Generate the mnemonic string from entropy bytes
entropy_bytes = binascii.unhexlify(b"00000000000000000000000000000000")
mnemonic = MoneroMnemonicGenerator().FromEntropyNoChecksum(entropy_bytes)
mnemonic = MoneroMnemonicGenerator(MoneroLanguages.FRENCH).FromEntropyWithChecksum(entropy_bytes)

# Generate mnemonic from random 256-bit entropy (with and without checksum)
entropy_bytes = MoneroEntropyGenerator(MoneroEntropyBitLen.BIT_LEN_256).Generate()
mnemonic = MoneroMnemonicGenerator().FromEntropyNoChecksum(entropy_bytes)
mnemonic = MoneroMnemonicGenerator().FromEntropyWithChecksum(entropy_bytes)

# Alternatively, the mnemonic can be generated from entropy using the encoder
mnemonic = MoneroMnemonicEncoder(MoneroLanguages.ENGLISH).EncodeNoChecksum(entropy_bytes)
mnemonic = MoneroMnemonicEncoder(MoneroLanguages.ENGLISH).EncodeWithChecksum(entropy_bytes)
mnemonic = MoneroMnemonicEncoder().EncodeNoChecksum(entropy_bytes)
mnemonic = MoneroMnemonicEncoder().EncodeWithChecksum(entropy_bytes)

from bip_utils import (
    MnemonicChecksumError, MoneroLanguages, MoneroWordsNum, MoneroMnemonic,
    MoneroMnemonicGenerator, MoneroMnemonicValidator, MoneroMnemonicDecoder
)

# Mnemonic can be generated with MoneroMnemonicGenerator
mnemonic = MoneroMnemonicGenerator().FromWordsNumber(MoneroWordsNum.WORDS_NUM_25)
# Or it can be a string
mnemonic = "vials licks gulp people reorder tulips acquire cool lunar upwards recipe against ambush february shelter textbook annoyed veered getting swagger paradise total dawn duets getting"
# Or from a list
mnemonic = MoneroMnemonic.FromList(mnemonic.split())

# Get if a mnemonic is valid with automatic language detection, return bool
is_valid = MoneroMnemonicValidator().IsValid(mnemonic)
# Same but specifying the language
is_valid = MoneroMnemonicValidator(MoneroLanguages.ENGLISH).IsValid(mnemonic)
# Validate a mnemonic, raise exceptions
try:
    MoneroMnemonicValidator().Validate(mnemonic)
    # Valid...
except MnemonicChecksumError:
    # Invalid checksum...
    pass
except ValueError:
    # Invalid length or language...
    pass

# Use MoneroMnemonicDecoder to get back the entropy bytes from a mnemonic, specifying the language
entropy_bytes = MoneroMnemonicDecoder(MoneroLanguages.ENGLISH).Decode(mnemonic)
# Like before with automatic language detection
entropy_bytes = MoneroMnemonicDecoder().Decode(mnemonic)

from bip_utils import MoneroLanguages, MoneroWordsNum, MoneroMnemonicGenerator, MoneroSeedGenerator

# Mnemonic can be generated with MoneroMnemonicGenerator
mnemonic = MoneroMnemonicGenerator().FromWordsNumber(MoneroWordsNum.WORDS_NUM_25)
# Or it can be a string
mnemonic = "ockhuizen essing brevet symboliek kart slordig hoeve olifant rodijk altsax creatie kneedbaar vetstaart exotherm laxeerpil lekdicht luikenaar bemiddeld oudachtig josua elburg kieviet escort dimbaar kieviet"

# Generate with automatic language detection
# Like before, the mnemonic can be a string or a Mnemonic object
seed_bytes = MoneroSeedGenerator(mnemonic).Generate()
# Generate specifying the language
seed_bytes = MoneroSeedGenerator(mnemonic, MoneroLanguages.DUTCH).Generate()

import binascii
import time
from bip_utils import (
    MoneroPolyseedLanguages, MoneroPolyseedCoins,
    MoneroPolyseedMnemonicGenerator, MoneroPolyseedMnemonicEncoder,
    MoneroPolyseedEntropyGenerator
)

# Generate a random Polyseed mnemonic with current time as birthday
mnemonic = MoneroPolyseedMnemonicGenerator().FromRandom(int(time.time()))
print(mnemonic.ToStr())
print(mnemonic.WordsCount())

# Generate from specific entropy bytes (19 bytes)
entropy = MoneroPolyseedEntropyGenerator().Generate()
mnemonic = MoneroPolyseedMnemonicGenerator().FromEntropy(entropy, int(time.time()))

# Use the encoder directly for more control
encoder = MoneroPolyseedMnemonicEncoder(MoneroPolyseedLanguages.ENGLISH)
mnemonic = encoder.EncodeWithData(
    entropy,
    birthday=int(time.time()),  # Unix timestamp
    features=0,                 # User feature flags (0-7)
    coin=MoneroPolyseedCoins.MONERO,
)

from bip_utils import (
    MnemonicChecksumError, MoneroPolyseedCoins,
    MoneroPolyseedMnemonicValidator, MoneroPolyseedMnemonicDecoder
)

mnemonic = "raven tail swear infant grief assist regular lamp duck valid someone little harsh puppy airport language"

# Validate
is_valid = MoneroPolyseedMnemonicValidator().IsValid(mnemonic)

# Decode to get just the secret bytes
secret = MoneroPolyseedMnemonicDecoder().Decode(mnemonic)

# Decode to get full data (secret, birthday, features, checksum)
data = MoneroPolyseedMnemonicDecoder().DecodeWithData(mnemonic)
print(f"Birthday timestamp: {data.birthday_timestamp}")
print(f"Is encrypted: {data.is_encrypted}")
print(f"User features: {data.user_features}")

from bip_utils import MoneroPolyseedCoins, MoneroPolyseedSeedGenerator

mnemonic = "raven tail swear infant grief assist regular lamp duck valid someone little harsh puppy airport language"

# Generate 32-byte seed via PBKDF2-HMAC-SHA256
seed_bytes = MoneroPolyseedSeedGenerator(mnemonic).Generate()

from bip_utils import (
    MoneroPolyseedCoins, MoneroPolyseedMnemonicDecoder,
    MoneroPolyseedMnemonicEncoder, MoneroPolyseedMnemonicEncrypter,
    MoneroPolyseedLanguages
)

mnemonic = "raven tail swear infant grief assist regular lamp duck valid someone little harsh puppy airport language"

# Decode the mnemonic
decoder = MoneroPolyseedMnemonicDecoder()
data = decoder.DecodeWithData(mnemonic)

# Encrypt with a password
encrypted_data = MoneroPolyseedMnemonicEncrypter.Crypt(data, "my_password")
print(f"Is encrypted: {encrypted_data.is_encrypted}")  # True

# Encode the encrypted data back to a mnemonic
encoder = MoneroPolyseedMnemonicEncoder(MoneroPolyseedLanguages.ENGLISH)
encrypted_mnemonic = encoder.EncodeData(encrypted_data)

# Decrypt: decode the encrypted mnemonic, then decrypt
enc_data = decoder.DecodeWithData(encrypted_mnemonic)
decrypted_data = MoneroPolyseedMnemonicEncrypter.Crypt(enc_data, "my_password")
print(f"Is encrypted: {decrypted_data.is_encrypted}")  # False