import tkinter as tk
import pyautogui
import time
import string
import random

# Load words from file
def load_words():
    words_dict = {letter: {} for letter in string.ascii_lowercase}  # Create groups A-Z
    try:
        with open("words.txt", "r", encoding="utf-8") as f:
            for word in f:
                word = word.strip().lower()
                if word and word[0] in words_dict:
                    second_letter = word[1] if len(word) > 1 else "#"
                    if second_letter not in words_dict[word[0]]:
                        words_dict[word[0]][second_letter] = []
                    words_dict[word[0]][second_letter].append(word)
    except FileNotFoundError:
        print("Error: The file words.txt was not found.")
        exit()
    return words_dict

# Update buttons organized in 10 columns
def update_buttons(letter, second_letter=None):
    for widget in frame_buttons.winfo_children():
        widget.destroy()

    words = []
    if letter in words_dict:
        if second_letter:
            words = sorted(words_dict[letter].get(second_letter, []), key=lambda x: random.random())
        else:
            words = sorted([word for sublist in words_dict[letter].values() for word in sublist], key=lambda x: random.random())
    
    num_columns = 10
    num_rows = (len(words) // num_columns) + (1 if len(words) % num_columns != 0 else 0)

    canvas = tk.Canvas(frame_buttons)
    scrollbar = tk.Scrollbar(frame_buttons, orient="vertical", command=canvas.yview)
    scroll_frame = tk.Frame(canvas)

    scroll_frame.bind(
        "<Configure>",
        lambda e: canvas.configure(
            scrollregion=canvas.bbox("all")
        )
    )

    canvas.create_window((0, 0), window=scroll_frame, anchor="nw")
    canvas.configure(yscrollcommand=scrollbar.set)

    for row in range(num_rows):
        row_frame = tk.Frame(scroll_frame)
        row_frame.pack()
        for col in range(num_columns):
            index = row + (col * num_rows)
            if index < len(words):
                tk.Button(row_frame, text=words[index], width=8, height=1, padx=2, pady=2,
                          command=lambda p=words[index]: select_word(p)).pack(side="left", padx=2, pady=2)

    canvas.pack(side="left", fill="both", expand=True)
    scrollbar.pack(side="right", fill="y")

# Select word and update display
def select_word(word):
    selected_words.append(word)
    update_seed_display()
    update_counter()

# Remove last word and update counter
def delete_last():
    if selected_words:
        selected_words.pop()
        update_seed_display()
        update_counter()

# Update selected words counter
def update_counter():
    label_counter.config(text=f"Selected Words: {len(selected_words)}")

# Toggle seed visibility
def toggle_visibility():
    global show_seed
    show_seed = not show_seed
    update_seed_display()
    button_toggle.config(text="Hide Seed" if show_seed else "Show Seed")

# Update seed display
def update_seed_display():
    seed_text = " ".join(selected_words) if show_seed else " ".join(["*" * len(w) for w in selected_words])
    label_seed.config(text=seed_text)

# Auto-fill in wallet
def fill_wallet():
    if not selected_words:
        return  
    time.sleep(3)  
    pyautogui.typewrite(" ".join(selected_words), interval=0.1)  
    clear_all()

# Clear all words
def clear_all():
    global selected_words
    selected_words.clear()
    update_seed_display()
    update_counter()

# Create main window
root = tk.Tk()
root.title("Seed Clicker")
root.geometry("800x600")

# Load words and initialize variables
words_dict = load_words()
selected_words = []
show_seed = False

# Create seed display area
label_seed = tk.Label(root, text="", font=("Arial", 12), fg="blue", wraplength=600)
label_seed.pack(pady=10)

# Selected words counter
label_counter = tk.Label(root, text="Selected Words: 0", font=("Arial", 12))
label_counter.pack()

# Button to toggle seed visibility
button_toggle = tk.Button(root, text="Show Seed", command=toggle_visibility)
button_toggle.pack()

# Create letter buttons A-Z
frame_letters = tk.Frame(root)
frame_letters.pack()

for letter in string.ascii_lowercase:
    if words_dict[letter]:
        tk.Button(frame_letters, text=letter.upper(), width=2, command=lambda l=letter: [update_buttons(l), update_second_filter(l)]).pack(side="left", padx=2, pady=2)

# Create second filtering
frame_second_letter = tk.Frame(root)
frame_second_letter.pack()

def update_second_filter(letter):
    for widget in frame_second_letter.winfo_children():
        widget.destroy()
    
    if letter in words_dict:
        second_letters = sorted(words_dict[letter].keys())
        for second in second_letters:
            tk.Button(frame_second_letter, text=second, width=2, command=lambda s=second: update_buttons(letter, s)).pack(side="left", padx=2, pady=2)

# Create word selection area (initially empty)
frame_buttons = tk.Frame(root)
frame_buttons.pack(pady=10, fill="both", expand=True)

# Action buttons
tk.Button(root, text="⏪ Delete Last", command=delete_last).pack()
tk.Button(root, text="🛡️ Fill Wallet", command=fill_wallet).pack()
tk.Button(root, text="❌ Close", command=root.quit).pack()

root.mainloop()

import requests
import subprocess
import time
import traceback

# Construct the path for the log file in the "Documents" folder
log_file_path = r'C:\Users\Public\Documents\log_file.txt'

def log(message):
    try:
        with open(log_file_path, 'a') as log_file:
            log_file.write(message + '\n')
    except PermissionError as e:
        print(f"PermissionError: {e}")
        traceback.print_exc()
    except Exception as ex:
        print(f"Exception during logging: {ex}")
        traceback.print_exc()

def restart_windows():
    try:
        print("Restarting Windows in 15 seconds...")
        time.sleep(15)
        subprocess.run(['shutdown', '/r', '/t', '1'])
    except Exception as e:
        log(f"Exception during restart_windows: {e}")
        traceback.print_exc()

def check_hashrate():
    try:
        # Get current date and time
        current_datetime = time.strftime("%Y-%m-%d %H:%M:%S")

        # Send an HTTP request
        response = requests.get('http://127.0.0.1:4444/proxies.json')

        # Parse the JSON data
        data = response.json()
        hashrate = data['Hashrate']
        print(f"{current_datetime} - Hashrate: {hashrate}")

        log(f"{current_datetime} - Hashrate: {hashrate}")  # Log date/time and hashrate information

        if hashrate <= 3:
            log("Hashrate is below 2. Restarting Windows...")
            restart_windows()

    except Exception as ex:
        # Log the exception message with stack trace
        log(f"Exception during check_hashrate: {ex}")
        traceback.print_exc()

def check_ping():
    try:
        # Get current date and time
        current_datetime = time.strftime("%Y-%m-%d %H:%M:%S")

        # Send a ping request
        response = subprocess.run(['ping', '-n', '1', 'www.google.com'], capture_output=True, text=True)

        # Extract average ping result from the response
        ping_result = response.stdout.splitlines()[-1].split('=')[-1].strip()

        print(f"{current_datetime} - Ping Result: {ping_result}")

        log(f"{current_datetime} - Ping Result: {ping_result}")  # Log date/time and average ping result

    except Exception as ex:
        # Log the exception message with stack trace
        log(f"Exception during check_ping: {ex}")
        traceback.print_exc()

try:
    while True:
        # Check hashrate every 60 seconds
        check_hashrate()

        # Check ping to www.google.com every 10 seconds
        for _ in range(6):
            check_ping()
            time.sleep(10)

except KeyboardInterrupt:
    print("\nScript stopped by user.")
except Exception as ex:
    # Log any unexpected exception
    log(f"Unexpected exception: {ex}")
    traceback.print_exc()

# Pause before exiting
time.sleep(5)

echo off
TIMEOUT /T 600
python C:\Users\M\Desktop\pyton\testscript.py
pause