gui_github.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import tkinter as tk
from tkinter import ttk, scrolledtext, messagebox, filedialog
import threading
import os
import json
from dotenv import load_dotenv, set_key
import requests
from requests.auth import HTTPBasicAuth
from time import sleep, time
from random import randint
import webbrowser
import sys

def resource_path(relative_path):
    """ Get absolute path to resource, works for dev and for PyInstaller """
    try:
        base_path = sys._MEIPASS
    except Exception:
        base_path = os.path.abspath(".")

    return os.path.join(base_path, relative_path)

try:
    from PIL import Image, ImageTk  # type: ignore
    PIL_AVAILABLE = True
except ImportError:
    PIL_AVAILABLE = False
    print("PIL/Pillow not available. Install it with: pip install Pillow")

if getattr(sys, 'frozen', False):
    APP_DIR = os.path.dirname(sys.executable)
else:
    APP_DIR = os.path.dirname(os.path.abspath(__file__))

ENV_PATH = os.path.join(APP_DIR, '.env')
load_dotenv(ENV_PATH)

TRANSLATIONS = {
    'es': {
        'app_title': 'GitHub Follower Manager',
        'credentials': 'Credenciales',
        'username': 'Usuario:',
        'token': 'Token:',
        'token_hint': 'ℹ️ ¿Dónde obtener el token?',
        'token_hint_text': 'Click para abrir: https://github.com/settings/tokens\n\nCrea un nuevo token con permisos:\n• user:follow\n• read:user',
        'save_credentials': '💾 Guardar Credenciales',
        'operations': 'Operaciones',
        'follow_users': '➕ Seguir Usuarios',
        'unfollow_non_followers': '➖ Dejar de Seguir (No me siguen)',
        'stop': '⏹ Detener',
        'progress': 'Progreso',
        'ready': 'Listo',
        'stats_total': 'Total: {0}',
        'stats_processed': 'Procesados: {0}',
        'stats_successful': 'Exitosos: {0}',
        'logs': 'Logs',
        'clear_logs': '🗑 Limpiar Logs',
        'language': 'Idioma:',
        'error': 'Error',
        'success': 'Éxito',
        'confirm': 'Confirmar',
        'error_credentials_required': 'Por favor, completa ambos campos (Usuario y Token)',
        'error_token_masked': 'Por favor, ingresa el token completo',
        'success_credentials_saved': 'Credenciales guardadas correctamente',
        'error_save_credentials': 'Error al guardar credenciales: {0}',
        'error_credentials_not_set': 'Por favor, configura tus credenciales de GitHub primero',
        'error_file_not_found': 'No se encontró el archivo static/usuarios.json\nPor favor, crea el archivo con la lista de usuarios a seguir.',
        'users_list': 'Lista de Usuarios',
        'paste_links': 'Pegar Enlaces/Texto',
        'load_json': 'Cargar JSON',
        'extract_users': 'Extraer Usuarios',
        'users_count': 'Usuarios: {0}',
        'no_users': 'No hay usuarios en la lista',
        'paste_placeholder': 'Pega enlaces de GitHub aquí (uno por línea o separados por espacios)...',
        'users_extracted': 'Se extrajeron {0} usuarios',
        'error_no_users': 'No hay usuarios en la lista. Agrega usuarios primero.',
        'clear_list': 'Limpiar Lista',
        'save_list': 'Guardar Lista',
        'load_list': 'Cargar Lista',
        'confirm_unfollow': '¿Estás seguro de que deseas dejar de seguir a todos los usuarios que no te siguen de vuelta?',
        'log_credentials_saved': 'Credenciales guardadas',
        'log_loading_users': 'Cargando lista de usuarios...',
        'log_no_users_found': 'No se encontraron usuarios para seguir',
        'log_users_found': 'Encontrados {0} usuarios para seguir',
        'log_operation_stopped': 'Operación detenida por el usuario',
        'log_already_following': 'Ya sigues a: {0}. Saltando...',
        'log_followed': 'Seguido: {0}',
        'log_not_found': 'No se encuentra: {0}',
        'log_rate_limit': 'Rate limit excedido. Esperando {0:.2f} minutos...',
        'log_error_follow': 'Error al seguir a {0}: código {1}',
        'log_error_user': 'Error con {0}: {1}',
        'log_failed_saved': 'Usuarios fallidos guardados: {0}',
        'log_completed': 'Proceso completado. Exitosos: {0}/{1}',
        'log_getting_following': 'Obteniendo lista de usuarios que estás siguiendo...',
        'log_getting_users': 'Obteniendo usuarios seguidos...',
        'log_no_following': 'No se encontraron usuarios seguidos',
        'log_following_found': 'Encontrados {0} usuarios seguidos',
        'log_checking_followers': 'Verificando cuáles no te siguen de vuelta...',
        'log_user_not_following': '{0} no te sigue',
        'log_user_following': '{0} te sigue ✓',
        'log_processed_users': 'Procesados {0} usuarios. Pausa de seguridad...',
        'log_all_following': '¡Todos los usuarios que sigues también te siguen de vuelta!',
        'log_non_followers_found': 'Encontrados {0} usuarios que no te siguen',
        'log_unfollowing': 'Dejando de seguir a {0} usuarios...',
        'log_unfollowed': 'Dejado de seguir: {0}',
        'log_unfollow_completed': 'Proceso completado. Dejados de seguir: {0}/{1}',
        'log_stopping': 'Deteniendo operación...',
        'progress_following': 'Siguiendo usuarios',
        'progress_checking': 'Verificando usuarios',
        'progress_unfollowing': 'Dejando de seguir',
        'credits': 'Hecho por E1DIGITAL',
    },
    'en': {
        'app_title': 'GitHub Follower Manager',
        'credentials': 'Credentials',
        'username': 'Username:',
        'token': 'Token:',
        'token_hint': 'ℹ️ Where to get the token?',
        'token_hint_text': 'Click to open: https://github.com/settings/tokens\n\nCreate a new token with permissions:\n• user:follow\n• read:user',
        'save_credentials': '💾 Save Credentials',
        'operations': 'Operations',
        'follow_users': '➕ Follow Users',
        'unfollow_non_followers': '➖ Unfollow (Not following back)',
        'stop': '⏹ Stop',
        'progress': 'Progress',
        'ready': 'Ready',
        'stats_total': 'Total: {0}',
        'stats_processed': 'Processed: {0}',
        'stats_successful': 'Successful: {0}',
        'logs': 'Logs',
        'clear_logs': '🗑 Clear Logs',
        'language': 'Language:',
        'error': 'Error',
        'success': 'Success',
        'confirm': 'Confirm',
        'error_credentials_required': 'Please complete both fields (Username and Token)',
        'error_token_masked': 'Please enter the complete token',
        'success_credentials_saved': 'Credentials saved successfully',
        'error_save_credentials': 'Error saving credentials: {0}',
        'error_credentials_not_set': 'Please configure your GitHub credentials first',
        'error_file_not_found': 'File static/usuarios.json not found\nPlease create the file with the list of users to follow.',
        'users_list': 'Users List',
        'paste_links': 'Paste Links/Text',
        'load_json': 'Load JSON',
        'extract_users': 'Extract Users',
        'users_count': 'Users: {0}',
        'no_users': 'No users in list',
        'paste_placeholder': 'Paste GitHub links here (one per line or separated by spaces)...',
        'users_extracted': 'Extracted {0} users',
        'error_no_users': 'No users in list. Add users first.',
        'clear_list': 'Clear List',
        'save_list': 'Save List',
        'load_list': 'Load List',
        'confirm_unfollow': 'Are you sure you want to unfollow all users who are not following you back?',
        'log_credentials_saved': 'Credentials saved',
        'log_loading_users': 'Loading user list...',
        'log_no_users_found': 'No users found to follow',
        'log_users_found': 'Found {0} users to follow',
        'log_operation_stopped': 'Operation stopped by user',
        'log_already_following': 'Already following: {0}. Skipping...',
        'log_followed': 'Followed: {0}',
        'log_not_found': 'Not found: {0}',
        'log_rate_limit': 'Rate limit exceeded. Waiting {0:.2f} minutes...',
        'log_error_follow': 'Error following {0}: code {1}',
        'log_error_user': 'Error with {0}: {1}',
        'log_failed_saved': 'Failed users saved: {0}',
        'log_completed': 'Process completed. Successful: {0}/{1}',
        'log_getting_following': 'Getting list of users you are following...',
        'log_getting_users': 'Getting followed users...',
        'log_no_following': 'No followed users found',
        'log_following_found': 'Found {0} followed users',
        'log_checking_followers': 'Checking which ones are not following you back...',
        'log_user_not_following': '{0} is not following you',
        'log_user_following': '{0} is following you ✓',
        'log_processed_users': 'Processed {0} users. Safety pause...',
        'log_all_following': 'Great! All users you follow are also following you back!',
        'log_non_followers_found': 'Found {0} users who are not following you',
        'log_unfollowing': 'Unfollowing {0} users...',
        'log_unfollowed': 'Unfollowed: {0}',
        'log_unfollow_completed': 'Process completed. Unfollowed: {0}/{1}',
        'log_stopping': 'Stopping operation...',
        'progress_following': 'Following users',
        'progress_checking': 'Checking users',
        'progress_unfollowing': 'Unfollowing',
        'credits': 'Made by E1DIGITAL',
    },
    'pt': {
        'app_title': 'GitHub Follower Manager',
        'credentials': 'Credenciais',
        'username': 'Usuário:',
        'token': 'Token:',
        'token_hint': 'ℹ️ Onde obter o token?',
        'token_hint_text': 'Clique para abrir: https://github.com/settings/tokens\n\nCrie um novo token com permissões:\n• user:follow\n• read:user',
        'save_credentials': '💾 Salvar Credenciais',
        'operations': 'Operações',
        'follow_users': '➕ Seguir Usuários',
        'unfollow_non_followers': '➖ Deixar de Seguir (Não me seguem)',
        'stop': '⏹ Parar',
        'progress': 'Progresso',
        'ready': 'Pronto',
        'stats_total': 'Total: {0}',
        'stats_processed': 'Processados: {0}',
        'stats_successful': 'Bem-sucedidos: {0}',
        'logs': 'Logs',
        'clear_logs': '🗑 Limpar Logs',
        'language': 'Idioma:',
        'error': 'Erro',
        'success': 'Sucesso',
        'confirm': 'Confirmar',
        'error_credentials_required': 'Por favor, preencha ambos os campos (Usuário e Token)',
        'error_token_masked': 'Por favor, insira o token completo',
        'success_credentials_saved': 'Credenciais salvas com sucesso',
        'error_save_credentials': 'Erro ao salvar credenciais: {0}',
        'error_credentials_not_set': 'Por favor, configure suas credenciais do GitHub primeiro',
        'error_file_not_found': 'Arquivo static/usuarios.json não encontrado\nPor favor, crie o arquivo com a lista de usuários para seguir.',
        'users_list': 'Lista de Usuários',
        'paste_links': 'Colar Links/Texto',
        'load_json': 'Carregar JSON',
        'extract_users': 'Extrair Usuários',
        'users_count': 'Usuários: {0}',
        'no_users': 'Não há usuários na lista',
        'paste_placeholder': 'Cole links do GitHub aqui (um por linha ou separados por espaços)...',
        'users_extracted': 'Foram extraídos {0} usuários',
        'error_no_users': 'Não há usuários na lista. Adicione usuários primeiro.',
        'clear_list': 'Limpar Lista',
        'save_list': 'Salvar Lista',
        'load_list': 'Carregar Lista',
        'confirm_unfollow': 'Tem certeza de que deseja deixar de seguir todos os usuários que não estão seguindo você de volta?',
        'log_credentials_saved': 'Credenciais salvas',
        'log_loading_users': 'Carregando lista de usuários...',
        'log_no_users_found': 'Nenhum usuário encontrado para seguir',
        'log_users_found': 'Encontrados {0} usuários para seguir',
        'log_operation_stopped': 'Operação interrompida pelo usuário',
        'log_already_following': 'Já está seguindo: {0}. Pulando...',
        'log_followed': 'Seguido: {0}',
        'log_not_found': 'Não encontrado: {0}',
        'log_rate_limit': 'Limite de taxa excedido. Aguardando {0:.2f} minutos...',
        'log_error_follow': 'Erro ao seguir {0}: código {1}',
        'log_error_user': 'Erro com {0}: {1}',
        'log_failed_saved': 'Usuários com falha salvos: {0}',
        'log_completed': 'Processo concluído. Bem-sucedidos: {0}/{1}',
        'log_getting_following': 'Obtendo lista de usuários que você está seguindo...',
        'log_getting_users': 'Obtendo usuários seguidos...',
        'log_no_following': 'Nenhum usuário seguido encontrado',
        'log_following_found': 'Encontrados {0} usuários seguidos',
        'log_checking_followers': 'Verificando quais não estão seguindo você de volta...',
        'log_user_not_following': '{0} não está seguindo você',
        'log_user_following': '{0} está seguindo você ✓',
        'log_processed_users': 'Processados {0} usuários. Pausa de segurança...',
        'log_all_following': 'Ótimo! Todos os usuários que você segue também estão seguindo você de volta!',
        'log_non_followers_found': 'Encontrados {0} usuários que não estão seguindo você',
        'log_unfollowing': 'Deixando de seguir {0} usuários...',
        'log_unfollowed': 'Deixado de seguir: {0}',
        'log_unfollow_completed': 'Processo concluído. Deixados de seguir: {0}/{1}',
        'log_stopping': 'Parando operação...',
        'progress_following': 'Seguindo usuários',
        'progress_checking': 'Verificando usuários',
        'progress_unfollowing': 'Deixando de seguir',
        'credits': 'Feito por E1DIGITAL',
    }
}

class Translator:
    def __init__(self, language='es'):
        self.language = language
        self.translations = TRANSLATIONS.get(language, TRANSLATIONS['es'])
    
    def t(self, key, *args):
        text = self.translations.get(key, key)
        if args:
            try:
                return text.format(*args)
            except:
                return text
        return text
    
    def set_language(self, language):
        self.language = language
        self.translations = TRANSLATIONS.get(language, TRANSLATIONS['es'])

class ToolTip:
    def __init__(self, widget, text):
        self.widget = widget
        self.text = text
        self.tipwindow = None
        self.id = None
        self.x = self.y = 0
        self.widget.bind('<Enter>', self.enter)
        self.widget.bind('<Leave>', self.leave)
        self.widget.bind('<ButtonPress>', self.leave)
    
    def update_text(self, new_text):
        self.text = new_text
    
    def enter(self, event=None):
        self.schedule()
    
    def leave(self, event=None):
        self.unschedule()
        self.hidetip()
    
    def schedule(self):
        self.unschedule()
        self.id = self.widget.after(500, self.showtip)
    
    def unschedule(self):
        id = self.id
        self.id = None
        if id:
            self.widget.after_cancel(id)
    
    def showtip(self):
        x, y, cx, cy = self.widget.bbox("insert") if hasattr(self.widget, 'bbox') else (0, 0, 0, 0)
        x += self.widget.winfo_rootx() + 25
        y += self.widget.winfo_rooty() + 20
        
        self.tipwindow = tw = tk.Toplevel(self.widget)
        tw.wm_overrideredirect(True)
        tw.wm_geometry("+%d+%d" % (x, y))
        
        label = tk.Label(tw, text=self.text, justify=tk.LEFT,
                        background="#ffffe0", relief=tk.SOLID, borderwidth=1,
                        font=("tahoma", "8", "normal"), wraplength=300)
        label.pack(ipadx=1)
    
    def hidetip(self):
        tw = self.tipwindow
        self.tipwindow = None
        if tw:
            tw.destroy()

class GitHubFollowerGUI:
    def __init__(self, root):
        self.root = root
        self.translator = Translator('es')
        self.root.title(self.translator.t('app_title'))
        self.root.geometry("900x950")
        self.root.resizable(True, True)
        
        self.load_window_icon()
        
        self.is_running = False
        self.stop_requested = False
        self.current_thread = None
        
        self.bg_color = "#f0f0f0"
        self.accent_color = "#238636"
        self.danger_color = "#da3633"
        self.text_color = "#24292f"
        
        self.ui_widgets = {}
        
        self.users_list = []
        
        self.setup_ui()
        self.load_credentials()
    
    def load_window_icon(self):
        if not PIL_AVAILABLE:
            return
        try:
            icon_path = resource_path(os.path.join('images', 'github-smol.png'))
            if os.path.exists(icon_path):
                img = Image.open(icon_path)
                photo = ImageTk.PhotoImage(img)
                self.root.iconphoto(False, photo)
                self.root.icon_image = photo
        except Exception as e:
            print(f"Could not load window icon: {e}")
        
    def setup_ui(self):
        main_frame = ttk.Frame(self.root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        self.root.columnconfigure(0, weight=1)
        self.root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=1)
        
        lang_frame = ttk.Frame(main_frame)
        lang_frame.grid(row=0, column=2, sticky=tk.NE, pady=(0, 10))
        self.language_label = ttk.Label(lang_frame, text=self.translator.t('language'))
        self.language_label.pack(side=tk.LEFT, padx=(0, 5))
        self.ui_widgets['language_label'] = self.language_label
        self.lang_var = tk.StringVar(value='es')
        lang_combo = ttk.Combobox(lang_frame, textvariable=self.lang_var, 
                                  values=['es', 'en', 'pt'], state='readonly', width=5)
        lang_combo.pack(side=tk.LEFT)
        lang_combo.bind('<<ComboboxSelected>>', self.change_language)
        self.ui_widgets['lang_combo'] = lang_combo
        
        title_frame = ttk.Frame(main_frame)
        title_frame.grid(row=0, column=0, columnspan=2, pady=(0, 20), sticky=tk.W)
        
        self.title_photo = None
        if PIL_AVAILABLE:
            try:
                img_path = resource_path(os.path.join('images', 'github-smol.png'))
                if os.path.exists(img_path):
                    img = Image.open(img_path)
                    img.thumbnail((40, 40), Image.Resampling.LANCZOS)
                    self.title_photo = ImageTk.PhotoImage(img)
                    title_img_label = tk.Label(title_frame, image=self.title_photo)
                    title_img_label.pack(side=tk.LEFT, padx=(0, 10))
            except Exception as e:
                print(f"Could not load title image: {e}")
        
        self.title_label = tk.Label(
            title_frame, 
            text=self.translator.t('app_title'), 
            font=("Arial", 18, "bold"),
            fg=self.text_color
        )
        self.title_label.pack(side=tk.LEFT)
        self.ui_widgets['title'] = self.title_label
        
        self.creds_frame = ttk.LabelFrame(main_frame, text=self.translator.t('credentials'), padding="10")
        self.creds_frame.grid(row=1, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
        self.creds_frame.columnconfigure(1, weight=1)
        self.ui_widgets['creds_frame'] = self.creds_frame
        self.username_label = ttk.Label(self.creds_frame, text=self.translator.t('username'))
        self.username_label.grid(row=0, column=0, sticky=tk.W, padx=(0, 5))
        self.ui_widgets['username_label'] = self.username_label
        self.username_var = tk.StringVar()
        username_entry = ttk.Entry(self.creds_frame, textvariable=self.username_var, width=30)
        username_entry.grid(row=0, column=1, sticky=(tk.W, tk.E), padx=(0, 10))
        
        token_label_frame = ttk.Frame(self.creds_frame)
        token_label_frame.grid(row=1, column=0, sticky=tk.W, pady=(5, 0))
        
        token_label = ttk.Label(token_label_frame, text=self.translator.t('token'))
        token_label.pack(side=tk.LEFT, padx=(0, 5))
        
        hint_icon = tk.Label(
            token_label_frame,
            text="ℹ️",
            font=("Arial", 10),
            cursor="hand2",
            fg="#0366d6"
        )
        hint_icon.pack(side=tk.LEFT, padx=(0, 0))
        hint_icon.bind("<Button-1>", lambda e: webbrowser.open('https://github.com/settings/tokens'))
        
        self.hint_tooltip = ToolTip(hint_icon, self.translator.t('token_hint_text'))
        self.ui_widgets['hint_tooltip'] = self.hint_tooltip
        
        self.token_var = tk.StringVar()
        token_entry = ttk.Entry(self.creds_frame, textvariable=self.token_var, width=30, show="*")
        token_entry.grid(row=1, column=1, sticky=(tk.W, tk.E), padx=(0, 10), pady=(5, 0))
        
        self.save_creds_btn = ttk.Button(
            self.creds_frame, 
            text=self.translator.t('save_credentials'), 
            command=self.save_credentials
        )
        self.save_creds_btn.grid(row=0, column=2, rowspan=2, padx=(10, 0))
        self.ui_widgets['save_creds_btn'] = self.save_creds_btn
        
        self.users_frame = ttk.LabelFrame(main_frame, text=self.translator.t('users_list'), padding="10")
        self.users_frame.grid(row=2, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
        self.users_frame.columnconfigure(0, weight=1)
        self.ui_widgets['users_frame'] = self.users_frame
        
        input_frame = ttk.Frame(self.users_frame)
        input_frame.grid(row=0, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
        input_frame.columnconfigure(0, weight=1)
        
        self.paste_links_label = ttk.Label(input_frame, text=self.translator.t('paste_links'))
        self.paste_links_label.grid(row=0, column=0, sticky=tk.W, pady=(0, 5))
        self.ui_widgets['paste_links_label'] = self.paste_links_label
        
        self.paste_text = scrolledtext.ScrolledText(
            input_frame,
            height=3,
            wrap=tk.WORD,
            font=("Consolas", 9)
        )
        self.paste_text.grid(row=1, column=0, sticky=(tk.W, tk.E), pady=(0, 5))
        self.paste_text.insert(1.0, self.translator.t('paste_placeholder'))
        self.paste_text.config(fg="gray")
        self.paste_text.bind("<FocusIn>", self.on_paste_focus_in)
        self.paste_text.bind("<FocusOut>", self.on_paste_focus_out)
        
        buttons_frame = ttk.Frame(self.users_frame)
        buttons_frame.grid(row=1, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
        
        self.extract_btn = ttk.Button(
            buttons_frame,
            text=self.translator.t('extract_users'),
            command=self.extract_users_from_text
        )
        self.extract_btn.pack(side=tk.LEFT, padx=(0, 5))
        self.ui_widgets['extract_btn'] = self.extract_btn
        
        self.load_json_btn = ttk.Button(
            buttons_frame,
            text=self.translator.t('load_json'),
            command=self.load_users_from_json
        )
        self.load_json_btn.pack(side=tk.LEFT, padx=(0, 5))
        self.ui_widgets['load_json_btn'] = self.load_json_btn
        
        self.save_list_btn = ttk.Button(
            buttons_frame,
            text=self.translator.t('save_list'),
            command=self.save_users_list
        )
        self.save_list_btn.pack(side=tk.LEFT, padx=(0, 5))
        self.ui_widgets['save_list_btn'] = self.save_list_btn
        
        self.clear_list_btn = ttk.Button(
            buttons_frame,
            text=self.translator.t('clear_list'),
            command=self.clear_users_list
        )
        self.clear_list_btn.pack(side=tk.LEFT)
        self.ui_widgets['clear_list_btn'] = self.clear_list_btn
        
        count_frame = ttk.Frame(self.users_frame)
        count_frame.grid(row=2, column=0, columnspan=3, sticky=(tk.W, tk.E))
        count_frame.columnconfigure(0, weight=1)
        
        self.users_count_var = tk.StringVar(value=self.translator.t('users_count', 0))
        ttk.Label(count_frame, textvariable=self.users_count_var, font=("Arial", 10, "bold")).grid(row=0, column=0, sticky=tk.W)
        
        list_frame = ttk.Frame(self.users_frame)
        list_frame.grid(row=3, column=0, columnspan=3, sticky=(tk.W, tk.E, tk.N, tk.S), pady=(5, 0))
        list_frame.columnconfigure(0, weight=1)
        list_frame.rowconfigure(0, weight=1)
        self.users_frame.rowconfigure(3, weight=1)
        
        self.users_listbox = tk.Listbox(
            list_frame,
            height=5,
            font=("Consolas", 9)
        )
        self.users_listbox.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        scrollbar = ttk.Scrollbar(list_frame, orient=tk.VERTICAL, command=self.users_listbox.yview)
        scrollbar.grid(row=0, column=1, sticky=(tk.N, tk.S))
        self.users_listbox.config(yscrollcommand=scrollbar.set)
        
        self.ops_frame = ttk.LabelFrame(main_frame, text=self.translator.t('operations'), padding="10")
        self.ops_frame.grid(row=3, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
        self.ops_frame.columnconfigure(0, weight=1)
        self.ops_frame.columnconfigure(1, weight=1)
        self.ui_widgets['ops_frame'] = self.ops_frame
        
        self.follow_btn = ttk.Button(
            self.ops_frame,
            text=self.translator.t('follow_users'),
            command=self.start_follow_users,
            style="Accent.TButton"
        )
        self.follow_btn.grid(row=0, column=0, padx=(0, 5), sticky=(tk.W, tk.E))
        self.ui_widgets['follow_btn'] = self.follow_btn
        
        self.unfollow_btn = ttk.Button(
            self.ops_frame,
            text=self.translator.t('unfollow_non_followers'),
            command=self.start_unfollow_non_followers
        )
        self.unfollow_btn.grid(row=0, column=1, padx=(5, 0), sticky=(tk.W, tk.E))
        self.ui_widgets['unfollow_btn'] = self.unfollow_btn
        
        self.stop_btn = ttk.Button(
            self.ops_frame,
            text=self.translator.t('stop'),
            command=self.stop_operation,
            state=tk.DISABLED
        )
        self.stop_btn.grid(row=1, column=0, columnspan=2, pady=(10, 0), sticky=(tk.W, tk.E))
        self.ui_widgets['stop_btn'] = self.stop_btn
        
        self.progress_frame = ttk.LabelFrame(main_frame, text=self.translator.t('progress'), padding="10")
        self.progress_frame.grid(row=4, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(0, 10))
        self.progress_frame.columnconfigure(0, weight=1)
        self.ui_widgets['progress_frame'] = self.progress_frame
        
        self.progress_var = tk.StringVar(value=self.translator.t('ready'))
        ttk.Label(self.progress_frame, textvariable=self.progress_var).grid(row=0, column=0, sticky=tk.W)
        
        self.progress_bar = ttk.Progressbar(
            self.progress_frame, 
            mode='indeterminate' if True else 'determinate',
            length=400
        )
        self.progress_bar.grid(row=1, column=0, sticky=(tk.W, tk.E), pady=(5, 0))
        
        stats_frame = ttk.Frame(self.progress_frame)
        stats_frame.grid(row=2, column=0, sticky=(tk.W, tk.E), pady=(10, 0))
        stats_frame.columnconfigure(0, weight=1)
        stats_frame.columnconfigure(1, weight=1)
        stats_frame.columnconfigure(2, weight=1)
        
        self.stats_vars = {
            'total': tk.StringVar(value=self.translator.t('stats_total', 0)),
            'procesados': tk.StringVar(value=self.translator.t('stats_processed', 0)),
            'exitosos': tk.StringVar(value=self.translator.t('stats_successful', 0))
        }
        
        for i, (key, var) in enumerate(self.stats_vars.items()):
            ttk.Label(stats_frame, textvariable=var, font=("Arial", 10)).grid(
                row=0, column=i, padx=10
            )
        
        self.logs_frame = ttk.LabelFrame(main_frame, text=self.translator.t('logs'), padding="10")
        self.logs_frame.grid(row=5, column=0, columnspan=3, sticky=(tk.W, tk.E, tk.N, tk.S), pady=(0, 10))
        self.logs_frame.columnconfigure(0, weight=1)
        self.logs_frame.rowconfigure(0, weight=1)
        main_frame.rowconfigure(5, weight=1)
        self.ui_widgets['logs_frame'] = self.logs_frame
        
        self.log_text = scrolledtext.ScrolledText(
            self.logs_frame,
            height=10,
            wrap=tk.WORD,
            font=("Consolas", 9),
            bg="#1e1e1e",
            fg="#d4d4d4",
            insertbackground="#d4d4d4"
        )
        self.log_text.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        self.clear_logs_btn = ttk.Button(
            self.logs_frame,
            text=self.translator.t('clear_logs'),
            command=self.clear_logs
        )
        self.clear_logs_btn.grid(row=1, column=0, pady=(5, 0))
        self.ui_widgets['clear_logs_btn'] = self.clear_logs_btn
        
        footer_frame = ttk.Frame(main_frame)
        footer_frame.grid(row=6, column=0, columnspan=3, sticky=(tk.W, tk.E), pady=(10, 0))
        footer_frame.columnconfigure(0, weight=1)
        
        credits_label = tk.Label(
            footer_frame,
            text=self.translator.t('credits'),
            font=("Arial", 9),
            fg="#586069",
            cursor="hand2"
        )
        credits_label.pack()
        credits_label.bind("<Button-1>", lambda e: webbrowser.open('https://e1digital.xyz'))
        credits_label.bind("<Enter>", lambda e: credits_label.config(fg="#0366d6", font=("Arial", 9, "underline")))
        credits_label.bind("<Leave>", lambda e: credits_label.config(fg="#586069", font=("Arial", 9)))
        self.ui_widgets['credits_label'] = credits_label
    
    
    def change_language(self, event=None):
        lang = self.lang_var.get()
        self.translator.set_language(lang)
        
        self.root.title(self.translator.t('app_title'))
        self.title_label.config(text=self.translator.t('app_title'))
        self.creds_frame.config(text=self.translator.t('credentials'))
        self.users_frame.config(text=self.translator.t('users_list'))
        self.ops_frame.config(text=self.translator.t('operations'))
        self.progress_frame.config(text=self.translator.t('progress'))
        self.logs_frame.config(text=self.translator.t('logs'))
        
        self.save_creds_btn.config(text=self.translator.t('save_credentials'))
        self.follow_btn.config(text=self.translator.t('follow_users'))
        self.unfollow_btn.config(text=self.translator.t('unfollow_non_followers'))
        self.stop_btn.config(text=self.translator.t('stop'))
        self.clear_logs_btn.config(text=self.translator.t('clear_logs'))
        
        if 'username_label' in self.ui_widgets:
            self.ui_widgets['username_label'].config(text=self.translator.t('username'))
        if 'language_label' in self.ui_widgets:
            self.ui_widgets['language_label'].config(text=self.translator.t('language'))
        if 'paste_links_label' in self.ui_widgets:
            self.ui_widgets['paste_links_label'].config(text=self.translator.t('paste_links'))
        if 'extract_btn' in self.ui_widgets:
            self.ui_widgets['extract_btn'].config(text=self.translator.t('extract_users'))
        if 'load_json_btn' in self.ui_widgets:
            self.ui_widgets['load_json_btn'].config(text=self.translator.t('load_json'))
        if 'save_list_btn' in self.ui_widgets:
            self.ui_widgets['save_list_btn'].config(text=self.translator.t('save_list'))
        if 'clear_list_btn' in self.ui_widgets:
            self.ui_widgets['clear_list_btn'].config(text=self.translator.t('clear_list'))
        
        self.progress_var.set(self.translator.t('ready'))
        self.update_stats(0, 0, 0)
        self.update_users_listbox()
        
        if 'hint_tooltip' in self.ui_widgets:
            self.ui_widgets['hint_tooltip'].update_text(self.translator.t('token_hint_text'))
        
        current_text = self.paste_text.get(1.0, tk.END).strip()
        if not current_text or current_text == self.translator.t('paste_placeholder'):
            self.paste_text.delete(1.0, tk.END)
            self.paste_text.insert(1.0, self.translator.t('paste_placeholder'))
            self.paste_text.config(fg="gray")
        
        if 'credits_label' in self.ui_widgets:
            self.ui_widgets['credits_label'].config(text=self.translator.t('credits'))
        
    def log(self, message, level="INFO"):
        colors = {
            "INFO": "#d4d4d4",
            "SUCCESS": "#4ec9b0",
            "WARNING": "#dcdcaa",
            "ERROR": "#f48771"
        }
        
        timestamp = time()
        time_str = f"[{int(timestamp)}]"
        
        self.log_text.insert(tk.END, f"{time_str} ", "timestamp")
        self.log_text.insert(tk.END, f"[{level}] ", level.lower())
        self.log_text.insert(tk.END, f"{message}\n", level.lower())
        
        self.log_text.tag_config("timestamp", foreground="#808080")
        self.log_text.tag_config("info", foreground=colors.get("INFO", "#d4d4d4"))
        self.log_text.tag_config("success", foreground=colors.get("SUCCESS", "#4ec9b0"))
        self.log_text.tag_config("warning", foreground=colors.get("WARNING", "#dcdcaa"))
        self.log_text.tag_config("error", foreground=colors.get("ERROR", "#f48771"))
        
        self.log_text.see(tk.END)
        self.root.update_idletasks()
        
    def clear_logs(self):
        self.log_text.delete(1.0, tk.END)
        
    def update_progress(self, message, current=0, total=0):
        if total > 0:
            self.progress_var.set(f"{message} ({current}/{total})")
            self.progress_bar['maximum'] = total
            self.progress_bar['value'] = current
            self.progress_bar['mode'] = 'determinate'
        else:
            self.progress_var.set(message)
            self.progress_bar['mode'] = 'indeterminate'
            self.progress_bar.start()
        
        self.root.update_idletasks()
        
    def update_stats(self, total=0, procesados=0, exitosos=0):
        self.stats_vars['total'].set(self.translator.t('stats_total', total))
        self.stats_vars['procesados'].set(self.translator.t('stats_processed', procesados))
        self.stats_vars['exitosos'].set(self.translator.t('stats_successful', exitosos))
        self.root.update_idletasks()
        
    def load_credentials(self):
        username = os.getenv('GITHUB_USERNAME', '')
        token = os.getenv('GITHUB_TOKEN', '')
        
        if username:
            self.username_var.set(username)
        
        if token:
            self.real_token = token
            masked_token = '*' * (len(token) - 4) + token[-4:] if len(token) > 4 else '*' * len(token)
            self.token_var.set(masked_token)
        else:
            self.real_token = ''

    def save_credentials(self):
        username = self.username_var.get().strip()
        token = self.token_var.get().strip()
        
        if not username or not token:
            messagebox.showerror(
                self.translator.t('error'), 
                self.translator.t('error_credentials_required')
            )
            return
        
        try:
            if token.startswith('*'):
                if hasattr(self, 'real_token') and self.real_token:
                    token = self.real_token
                else:
                    token = os.getenv('GITHUB_TOKEN', '')
                    if not token:
                        messagebox.showerror(
                            self.translator.t('error'), 
                            self.translator.t('error_token_masked')
                        )
                        return
            
            set_key(ENV_PATH, 'GITHUB_USERNAME', username)
            set_key(ENV_PATH, 'GITHUB_TOKEN', token)
            
            self.real_token = token
            masked_token = '*' * (len(token) - 4) + token[-4:] if len(token) > 4 else '*' * len(token)
            self.token_var.set(masked_token)
            
            messagebox.showinfo(
                self.translator.t('success'), 
                self.translator.t('success_credentials_saved')
            )
            self.log(self.translator.t('log_credentials_saved'), "SUCCESS")
        except Exception as e:
            messagebox.showerror(
                self.translator.t('error'), 
                self.translator.t('error_save_credentials', str(e))
            )
            self.log(self.translator.t('error_save_credentials', str(e)), "ERROR")
    
    def get_credentials(self):
        username = self.username_var.get().strip()
        token = self.token_var.get().strip()
        
        if token.startswith('*'):
            if hasattr(self, 'real_token') and self.real_token:
                token = self.real_token
            else:
                token = os.getenv('GITHUB_TOKEN', '')
        
        return username, token
    
    def check_credentials(self):
        username, token = self.get_credentials()
        
        if not username or not token:
            messagebox.showerror(
                self.translator.t('error'),
                self.translator.t('error_credentials_not_set')
            )
            return False
        return True
    
    def set_ui_state(self, running):
        self.is_running = running
        state = tk.DISABLED if running else tk.NORMAL
        
        self.follow_btn.config(state=state)
        self.unfollow_btn.config(state=state)
        self.stop_btn.config(state=tk.NORMAL if running else tk.DISABLED)
        
        if not running:
            self.progress_bar.stop()
            self.progress_bar['value'] = 0
            self.progress_bar['mode'] = 'determinate'
    
    def stop_operation(self):
        self.stop_requested = True
        self.log(self.translator.t('log_stopping'), "WARNING")
        self.set_ui_state(False)
    
    def on_paste_focus_in(self, event):
        if self.paste_text.get(1.0, tk.END).strip() == self.translator.t('paste_placeholder'):
            self.paste_text.delete(1.0, tk.END)
            self.paste_text.config(fg="black")
    
    def on_paste_focus_out(self, event):
        if not self.paste_text.get(1.0, tk.END).strip():
            self.paste_text.insert(1.0, self.translator.t('paste_placeholder'))
            self.paste_text.config(fg="gray")
    
    def extract_users_from_text(self):
        text = self.paste_text.get(1.0, tk.END).strip()
        
        if not text or text == self.translator.t('paste_placeholder'):
            messagebox.showwarning(
                self.translator.t('error'),
                self.translator.t('paste_placeholder')
            )
            return
        
        import re
        usernames = set()
        
        repo_pattern = r'https?://github\.com/([a-zA-Z0-9_-]+)/([a-zA-Z0-9_.-]+)'
        repo_matches = re.findall(repo_pattern, text)
        
        for owner, repo in repo_matches:
            usernames.add(owner)
            
            try:
                self.log(f"Getting README of {owner}/{repo}...", "INFO")
                readme_url = f'https://raw.githubusercontent.com/{owner}/{repo}/main/README.md'
                response = requests.get(readme_url, timeout=10)
                
                if response.status_code == 404:
                    readme_url = f'https://raw.githubusercontent.com/{owner}/{repo}/master/README.md'
                    response = requests.get(readme_url, timeout=10)
                
                if response.status_code == 200:
                    readme_content = response.text
                    readme_users = self._extract_usernames_from_text(readme_content)
                    usernames.update(readme_users)
                    self.log(f"Extracted {len(readme_users)} users from README", "SUCCESS")
            except Exception as e:
                self.log(f"Error getting README: {str(e)}", "WARNING")
        
        text_users = self._extract_usernames_from_text(text)
        usernames.update(text_users)
        
        excluded = {'github', 'raw', 'api', 'www', 'gist', 'help', 'docs', 'blog', 
                   'status', 'support', 'about', 'pricing', 'enterprise', 'marketplace',
                   'topics', 'trending', 'collections', 'sponsors', 'settings', 'security',
                   'tree', 'blob', 'issues', 'pull', 'commits', 'releases', 'tags',
                   'branches', 'compare', 'search', 'pulls', 'actions', 'projects',
                   'wiki', 'security', 'insights', 'pulse', 'graphs', 'network',
                   'settings', 'notifications', 'stars', 'watching', 'forks', 'releases',
                   'packages', 'people', 'teams', 'discussions', 'codespaces', 'copilot'}
        
        usernames = {u for u in usernames if u.lower() not in excluded and len(u) > 0}
        unique_usernames = sorted(usernames)
        
        if not unique_usernames:
            messagebox.showwarning(
                self.translator.t('error'),
                'No users of GitHub were found in the text'
            )
            return
        
        new_users = [u for u in unique_usernames if u not in self.users_list]
        self.users_list.extend(new_users)
        self.users_list = sorted(set(self.users_list))
        
        self.update_users_listbox()
        messagebox.showinfo(
            self.translator.t('success'),
            self.translator.t('users_extracted', len(unique_usernames))
        )
        
        self.paste_text.delete(1.0, tk.END)
        self.paste_text.insert(1.0, self.translator.t('paste_placeholder'))
        self.paste_text.config(fg="gray")
    
    def _extract_usernames_from_text(self, text):
        import re
        usernames = set()
        
        pattern1 = r'github\.com/([a-zA-Z0-9_-]+)(?:/|$|\?|#)'
        matches1 = re.findall(pattern1, text)
        usernames.update(matches1)
        
        pattern2 = r'@([a-zA-Z0-9_-]+)'
        matches2 = re.findall(pattern2, text)
        usernames.update(matches2)
        
        pattern3 = r'\[([a-zA-Z0-9_-]+)\]\(https?://github\.com/\1'
        matches3 = re.findall(pattern3, text)
        usernames.update(matches3)
        
        pattern4 = r'github\.com/([a-zA-Z0-9_-]+)/(?!tree|blob|issues|pull|commits|releases|tags|branches|compare|search|pulls|actions|projects|wiki|security|insights|pulse|graphs|network|settings|notifications|stars|watching|forks|releases|packages|people|teams|discussions|codespaces|copilot)([a-zA-Z0-9_.-]+)'
        matches4 = re.findall(pattern4, text)
        for owner, repo in matches4:
            usernames.add(owner)
        
        pattern5 = r'\[.*?\]\(https?://github\.com/([a-zA-Z0-9_-]+)(?:/|\)|$)'
        matches5 = re.findall(pattern5, text)
        usernames.update(matches5)
        
        return usernames
    
    def load_users_from_json(self):
        file_path = filedialog.askopenfilename(
            title=self.translator.t('load_json'),
            filetypes=[("JSON files", "*.json"), ("All files", "*.*")]
        )
        
        if not file_path:
            return
        
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                data = json.load(f)
            
            if isinstance(data, list):
                users = data
            elif isinstance(data, dict):
                users = data.get('usuarios', data.get('users', []))
            else:
                users = []
            
            if not users:
                messagebox.showwarning(
                    self.translator.t('error'),
                    'No se encontraron usuarios en el archivo'
                )
                return
            
            new_users = [u for u in users if u not in self.users_list]
            self.users_list.extend(new_users)
            self.users_list = sorted(set(self.users_list))
            
            self.update_users_listbox()
            messagebox.showinfo(
                self.translator.t('success'),
                f'{len(users)} users were loaded'
            )
        except Exception as e:
            messagebox.showerror(
                self.translator.t('error'),
                f'Error loading the file: {str(e)}'
            )
    
    def save_users_list(self):
        if not self.users_list:
            messagebox.showwarning(
                self.translator.t('error'),
                self.translator.t('no_users')
            )
            return
        
        file_path = filedialog.asksaveasfilename(
            title=self.translator.t('save_list'),
            defaultextension=".json",
            filetypes=[("JSON files", "*.json"), ("All files", "*.*")]
        )
        
        if not file_path:
            return
        
        try:
            data = {"usuarios": self.users_list}
            with open(file_path, 'w', encoding='utf-8') as f:
                json.dump(data, f, indent=2, ensure_ascii=False)
            
            messagebox.showinfo(
                self.translator.t('success'),
                f'List saved: {len(self.users_list)} users'
            )
        except Exception as e:
            messagebox.showerror(
                self.translator.t('error'),
                f'Error saving: {str(e)}'
            )
    
    def clear_users_list(self):
        if not self.users_list:
            return
        
        respuesta = messagebox.askyesno(
            self.translator.t('confirm'),
            f'Are you sure you want to clear the list? ({len(self.users_list)} users)'
        )
        
        if respuesta:
            self.users_list = []
            self.update_users_listbox()
    
    def update_users_listbox(self):
        self.users_listbox.delete(0, tk.END)
        
        for user in self.users_list:
            self.users_listbox.insert(tk.END, user)
        
        self.users_count_var.set(self.translator.t('users_count', len(self.users_list)))
    
    def start_follow_users(self):
        if not self.check_credentials():
            return
        
        if not self.users_list:
            messagebox.showerror(
                self.translator.t('error'),
                self.translator.t('error_no_users')
            )
            return
        
        self.set_ui_state(True)
        self.stop_requested = False
        self.clear_logs()
        
        thread = threading.Thread(target=self.follow_users_thread, daemon=True)
        thread.start()
        self.current_thread = thread
    
    def start_unfollow_non_followers(self):
        if not self.check_credentials():
            return
        
        respuesta = messagebox.askyesno(
            self.translator.t('confirm'),
            self.translator.t('confirm_unfollow')
        )
        
        if not respuesta:
            return
        
        self.set_ui_state(True)
        self.stop_requested = False
        self.clear_logs()
        
        thread = threading.Thread(target=self.unfollow_non_followers_thread, daemon=True)
        thread.start()
        self.current_thread = thread
    
    def follow_users_thread(self):
        try:
            username, token = self.get_credentials()
            
            from follow_github import load_users, follow_user, save_failed_users
            
            import follow_github
            follow_github.USERNAME = username
            follow_github.TOKEN = token
            
            self.log(self.translator.t('log_loading_users'), "INFO")
            users_to_follow = self.users_list.copy()
            
            if not users_to_follow:
                self.log(self.translator.t('log_no_users_found'), "WARNING")
                self.set_ui_state(False)
                return
            
            total = len(users_to_follow)
            self.update_stats(total=total, procesados=0, exitosos=0)
            self.log(self.translator.t('log_users_found', total), "INFO")
            
            failed_users = []
            exitosos = 0
            
            for i, user in enumerate(users_to_follow, 1):
                if self.stop_requested:
                    self.log(self.translator.t('log_operation_stopped'), "WARNING")
                    break
                
                self.update_progress(self.translator.t('progress_following'), i, total)
                
                url_check = f'https://api.github.com/user/following/{user}'
                response_check = requests.get(url_check, auth=HTTPBasicAuth(username, token))
                
                if response_check.status_code == 204:
                    self.log(self.translator.t('log_already_following', user), "INFO")
                    exitosos += 1
                else:
                    url = f'https://api.github.com/user/following/{user}'
                    try:
                        response = requests.put(url, auth=HTTPBasicAuth(username, token))
                        if response.status_code == 204:
                            exitosos += 1
                            self.log(self.translator.t('log_followed', user), "SUCCESS")
                        elif response.status_code == 404:
                            self.log(self.translator.t('log_not_found', user), "WARNING")
                            failed_users.append(user)
                        elif response.status_code in [403, 429]:
                            rate_limit_reset = int(response.headers.get('X-RateLimit-Reset', 0))
                            wait_time = max(0, rate_limit_reset - time())
                            self.log(self.translator.t('log_rate_limit', wait_time / 60), "WARNING")
                            sleep(wait_time)
                            failed_users.append(user)
                        else:
                            self.log(self.translator.t('log_error_follow', user, response.status_code), "ERROR")
                            failed_users.append(user)
                    except Exception as e:
                        self.log(self.translator.t('log_error_user', user, str(e)), "ERROR")
                        failed_users.append(user)
                
                self.update_stats(total=total, procesados=i, exitosos=exitosos)
                sleep(randint(1, 3))
            
            if failed_users:
                save_failed_users(failed_users)
                self.log(self.translator.t('log_failed_saved', len(failed_users)), "WARNING")
            
            self.log(self.translator.t('log_completed', exitosos, total), "SUCCESS")
            self.update_stats(total=total, procesados=total, exitosos=exitosos)
            
        except Exception as e:
            self.log(self.translator.t('log_error_user', 'System', str(e)), "ERROR")
            messagebox.showerror(self.translator.t('error'), f"{self.translator.t('error')}: {str(e)}")
        finally:
            self.set_ui_state(False)
    
    def unfollow_non_followers_thread(self):
        try:
            username, token = self.get_credentials()
            
            from follow_github import (
                get_following_users, does_user_follow_me, 
                unfollow_user, save_failed_users, check_rate_limit
            )
            
            import follow_github
            follow_github.USERNAME = username
            follow_github.TOKEN = token
            
            self.log(self.translator.t('log_getting_following'), "INFO")
            self.update_progress(self.translator.t('log_getting_users'))
            
            following_users = get_following_users()
            
            if not following_users:
                self.log(self.translator.t('log_no_following'), "WARNING")
                self.set_ui_state(False)
                return
            
            total_following = len(following_users)
            self.log(self.translator.t('log_following_found', total_following), "INFO")
            self.log(self.translator.t('log_checking_followers'), "INFO")
            
            non_followers = []
            failed_users = []
            
            for i, user in enumerate(following_users, 1):
                if self.stop_requested:
                    self.log(self.translator.t('log_operation_stopped'), "WARNING")
                    break
                
                self.update_progress(self.translator.t('progress_checking'), i, total_following)
                self.update_stats(
                    total=total_following, 
                    procesados=i, 
                    exitosos=len(non_followers)
                )
                
                if not does_user_follow_me(user, check_rate=False):
                    non_followers.append(user)
                    self.log(self.translator.t('log_user_not_following', user), "INFO")
                else:
                    self.log(self.translator.t('log_user_following', user), "SUCCESS")
                
                sleep(randint(300, 700) / 1000)
                
                if i % 50 == 0:
                    self.log(self.translator.t('log_processed_users', i), "INFO")
                    sleep(randint(1, 2))
            
            if not non_followers:
                self.log(self.translator.t('log_all_following'), "SUCCESS")
                self.set_ui_state(False)
                return
            
            self.log(self.translator.t('log_non_followers_found', len(non_followers)), "WARNING")
            
            self.log(self.translator.t('log_unfollowing', len(non_followers)), "INFO")
            exitosos = 0
            
            for i, user in enumerate(non_followers, 1):
                if self.stop_requested:
                    self.log(self.translator.t('log_operation_stopped'), "WARNING")
                    break
                
                self.update_progress(self.translator.t('progress_unfollowing'), i, len(non_followers))
                
                url = f'https://api.github.com/user/following/{user}'
                try:
                    response = requests.delete(url, auth=HTTPBasicAuth(username, token))
                    check_rate_limit(response)
                    
                    if response.status_code == 204:
                        exitosos += 1
                        self.log(self.translator.t('log_unfollowed', user), "SUCCESS")
                    elif response.status_code == 404:
                        self.log(self.translator.t('log_not_found', user), "WARNING")
                    elif response.status_code in [403, 429]:
                        rate_limit_reset = int(response.headers.get('X-RateLimit-Reset', 0))
                        wait_time = max(0, rate_limit_reset - time())
                        self.log(self.translator.t('log_rate_limit', wait_time / 60), "WARNING")
                        sleep(wait_time)
                        failed_users.append(user)
                    else:
                        failed_users.append(user)
                        self.log(self.translator.t('log_error_follow', user, response.status_code), "ERROR")
                except Exception as e:
                    failed_users.append(user)
                    self.log(self.translator.t('log_error_user', user, str(e)), "ERROR")
                
                self.update_stats(
                    total=len(non_followers),
                    procesados=i,
                    exitosos=exitosos
                )
                
                sleep(randint(500, 1000) / 1000)
                
                if i % 30 == 0:
                    self.log(self.translator.t('log_processed_users', i), "INFO")
                    sleep(randint(1, 2))
            
            if failed_users:
                save_failed_users(failed_users)
                self.log(self.translator.t('log_failed_saved', len(failed_users)), "WARNING")
            
            self.log(
                self.translator.t('log_unfollow_completed', exitosos, len(non_followers)), 
                "SUCCESS"
            )
            self.update_stats(
                total=len(non_followers),
                procesados=len(non_followers),
                exitosos=exitosos
            )
            
        except Exception as e:
            self.log(self.translator.t('log_error_user', 'System', str(e)), "ERROR")
            messagebox.showerror(self.translator.t('error'), f"{self.translator.t('error')}: {str(e)}")
        finally:
            self.set_ui_state(False)


def main():
    root = tk.Tk()
    app = GitHubFollowerGUI(root)
    root.mainloop()


if __name__ == "__main__":
    main()