import tkinter as tk
from tkinter import messagebox, scrolledtext
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from webdriver_manager.chrome import ChromeDriverManager
from datetime import datetime
import time
import threading
import os
import signal
import sys

class BinanceGridBotApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Binance Futures Grid Bot Otomasyonu")
        self.root.geometry("600x500")
        self.root.resizable(True, True)
        
        self.is_running = False
        self.emergency_stop = False
        self.driver = None
        self.thread = None
        
        # GUI Bileşenleri
        self.create_widgets()
        
        # Acil durdurma için olay
        self.stop_event = threading.Event()
        
        # Uygulama kapatıldığında temizlik yapmak için
        self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
        
    def create_widgets(self):
        # Kontrol butonları
        control_frame = tk.Frame(self.root)
        control_frame.pack(pady=10, fill=tk.X)
        
        self.start_button = tk.Button(control_frame, text="Başlat", command=self.start_bot,
                                      bg="green", fg="white", width=15, height=2)
        self.start_button.pack(side=tk.LEFT, padx=10)
        
        self.stop_button = tk.Button(control_frame, text="DURDUR", command=self.emergency_stop_bot,
                                     bg="red", fg="white", width=15, height=2, state=tk.DISABLED)
        self.stop_button.pack(side=tk.LEFT, padx=10)
        
        # Log alanı
        log_frame = tk.Frame(self.root)
        log_frame.pack(pady=10, fill=tk.BOTH, expand=True)
        
        log_label = tk.Label(log_frame, text="İşlem Günlüğü:")
        log_label.pack(anchor=tk.W)
        
        self.log_area = scrolledtext.ScrolledText(log_frame, width=70, height=20)
        self.log_area.pack(fill=tk.BOTH, expand=True, padx=10)
        
        # Durum çubuğu
        self.status_var = tk.StringVar()
        self.status_var.set("Durum: Hazır")
        status_bar = tk.Label(self.root, textvariable=self.status_var, bd=1, relief=tk.SUNKEN, anchor=tk.W)
        status_bar.pack(side=tk.BOTTOM, fill=tk.X)
        
    def log(self, message):
        timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3] # Milisaniye hassasiyeti
        log_message = f"[{timestamp}] {message}"
        self.root.after(0, lambda: self.log_area.insert(tk.END, log_message + "\n"))
        self.root.after(0, lambda: self.log_area.see(tk.END))
        print(log_message)
    
    def update_status(self, message):
        self.root.after(0, lambda: self.status_var.set(f"Durum: {message}"))
        
    def start_bot(self):
        if self.is_running:
            return
            
        self.is_running = True
        self.emergency_stop = False
        self.stop_event.clear()
        
        self.start_button.config(state=tk.DISABLED)
        self.stop_button.config(state=tk.NORMAL)
        
        self.log("Bot başlatılıyor...")
        self.update_status("Çalışıyor")
        
        # Bot işlemini ayrı bir thread'de başlat
        self.thread = threading.Thread(target=self.run_bot)
        self.thread.daemon = True
        self.thread.start()
    
    def stop_bot(self):
        if not self.is_running:
            return
            
        self.is_running = False
        self.stop_event.set()
        self.log("Bot durduruluyor...")
        self.update_status("Durduruluyor")
        
        # Tarayıcıyı kapat
        if self.driver:
            try:
                self.log("Tarayıcı kapatılıyor...")
                self.driver.quit()
                self.driver = None
                self.log("Tarayıcı kapatıldı.")
            except Exception as e:
                self.log(f"Tarayıcı kapatılırken hata: {str(e)}")
        
        self.start_button.config(state=tk.NORMAL)
        self.stop_button.config(state=tk.DISABLED)
        self.update_status("Durduruldu")
    
    def emergency_stop_bot(self):
        """Acil durdurma: Milisaniye hassasiyetinde durması için optimize edilmiş"""
        self.log("ACİL DURDURMA İSTEĞİ ALINDI!")
        self.emergency_stop = True
        self.stop_event.set()
        self.is_running = False
        
        # Tarayıcıyı hemen sonlandır
        if self.driver:
            try:
                # Tarayıcı sürecini doğrudan sonlandır
                self.log("Tarayıcı süreci anında sonlandırılıyor...")
                if hasattr(self.driver, 'service') and hasattr(self.driver.service, 'process'):
                    if self.driver.service.process:
                        pid = self.driver.service.process.pid
                        try:
                            if sys.platform == 'win32':
                                import ctypes
                                PROCESS_TERMINATE = 1
                                handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, pid)
                                ctypes.windll.kernel32.TerminateProcess(handle, 0)
                                ctypes.windll.kernel32.CloseHandle(handle)
                            else:
                                os.kill(pid, signal.SIGKILL)
                            self.log(f"Tarayıcı süreci (PID: {pid}) anında sonlandırıldı!")
                        except Exception as e:
                            self.log(f"Süreç sonlandırma hatası: {str(e)}")
                self.driver = None
            except Exception as e:
                self.log(f"Acil tarayıcı kapatma hatası: {str(e)}")
        
        # GUI'yi hemen güncelle
        self.start_button.config(state=tk.NORMAL)
        self.stop_button.config(state=tk.DISABLED)
        self.update_status("ACİL DURDURULDU!")
        
        # Aktif işlemleri iptal et
        if hasattr(self, 'active_orders') and self.active_orders:
            self.log("Aktif işlemler iptal ediliyor...")
            # İşlem iptali için gerekli kodlar burada yer alacak
            
        self.log("Tüm işlemler durduruldu!")
    
    def on_closing(self):
        """Uygulama kapatıldığında çağrılır"""
        if self.is_running:
            self.emergency_stop_bot()
        self.root.destroy()
    
    def check_stop_signal(self):
        """Durdurma sinyalini kontrol eder - tüm döngülerde çağrılmalıdır"""
        if self.stop_event.is_set() or self.emergency_stop or not self.is_running:
            raise Exception("Durdurma sinyali alındı")
        return False
    
    def run_bot(self):
        try:
            # Tarayıcı ayarlarını yapılandır
            self.log("Tarayıcı başlatılıyor...")
            chrome_options = Options()
            chrome_options.add_argument("--start-maximized")
            # chrome_options.add_argument("--headless") # Başsız modda çalıştırmak istiyorsanız bu satırı açın
            chrome_options.add_experimental_option("detach", False) # Tarayıcının ayrı süreç olarak çalışmasını engelle
            
            service = Service(ChromeDriverManager().install())
            self.driver = webdriver.Chrome(service=service, options=chrome_options)
            
            # Ana işlem döngüsü
            while self.is_running:
                self.check_stop_signal() # Her döngü başında durdurma sinyalini kontrol et
                self.execute_trading_cycle()
                
                # 2 dakika boyunca bekle veya Take Profit gerçekleşene kadar
                self.log("İşlem 2 dakika boyunca izleniyor...")
                wait_time = 120 # 2 dakika
                start_time = time.time()
                
                # Daha sık kontrol ile durdurma sinyaline hızlı yanıt ver
                while self.is_running and (time.time() - start_time) < wait_time:
                    self.check_stop_signal() # Her döngüde kontrol et
                    
                    # Take Profit durumunu kontrol et
                    try:
                        if self.check_take_profit():
                            self.log("Take Profit gerçekleşti. Yeni işlem başlatılıyor.")
                            break
                    except Exception as e:
                        if "Durdurma sinyali alındı" in str(e):
                            raise
                        self.log(f"Take Profit kontrolü sırasında hata: {str(e)}")
                    
                    # Daha kısa aralıklarla kontrol et (0.1 saniye)
                    for _ in range(10): # 1 saniyeyi 10 parçaya böl
                        self.check_stop_signal()
                        time.sleep(0.1)
                
        except Exception as e:
            if "Durdurma sinyali alındı" in str(e):
                self.log("Bot kontrollü şekilde durduruldu.")
            else:
                self.log(f"Bot çalışması sırasında hata: {str(e)}")
        finally:
            # Bot thread tamamlandığında GUI'yi güncelle
            if self.is_running:
                self.root.after(0, self.stop_bot)
    
    def execute_trading_cycle(self):
        try:
            # 1. Binance Futures Grid Bot sayfasına giriş yap
            self.log("Binance Futures Grid Bot sayfasına giriş yapılıyor...")
            self.check_stop_signal()
            self.driver.get("https://www.binance.com/en/futures/trading-bot")
            
            # Sayfanın yüklenmesi için bekle
            for _ in range(30): # 30 saniye timeout
                self.check_stop_signal()
                try:
                    if self.driver.find_element(By.XPATH, "//div[contains(text(), 'Grid Bot')]"):
                        break
                except:
                    pass
                time.sleep(1)
            
            self.log("Sayfa başarıyla yüklendi.")
            
            # 2. x50 kaldıraçlı ve maksimum 25$ giriş miktarı olan botları filtrele
            self.log("Filtreler uygulanıyor...")
            self.check_stop_signal()
            
            # Filtre butonlarını bul ve tıkla
            for _ in range(10): # 10 saniye timeout
                self.check_stop_signal()
                try:
                    filter_btn = self.driver.find_element(By.XPATH, "//button[contains(text(), 'Filter')]")
                    filter_btn.click()
                    break
                except:
                    time.sleep(0.5)
            
            # Kaldıraç filtresini ayarla
            self.check_stop_signal()
            for _ in range(10):
                try:
                    leverage_filter = self.driver.find_element(By.XPATH, "//div[contains(text(), 'Leverage')]/following-sibling::div//input")
                    leverage_filter.clear()
                    leverage_filter.send_keys("50")
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
            
            # Maksimum giriş miktarı filtresini ayarla
            self.check_stop_signal()
            for _ in range(10):
                try:
                    amount_filter = self.driver.find_element(By.XPATH, "//div[contains(text(), 'Max Investment')]/following-sibling::div//input")
                    amount_filter.clear()
                    amount_filter.send_keys("25")
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
            
            # Filtre uygula butonuna tıkla
            self.check_stop_signal()
            for _ in range(10):
                try:
                    apply_btn = self.driver.find_element(By.XPATH, "//button[contains(text(), 'Apply')]")
                    apply_btn.click()
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
                    
            self.log("Filtreler başarıyla uygulandı.")
            
            # 3. PNL'si en yüksek olan botu seç ve "Copy" yap
            self.log("PNL'si en yüksek olan bot seçiliyor...")
            self.check_stop_signal()
            
            # Botları PNL'ye göre sırala
            for _ in range(10):
                try:
                    sort_btn = self.driver.find_element(By.XPATH, "//div[contains(text(), 'PNL')]")
                    sort_btn.click()
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
                    
            time.sleep(1) # Sıralamanın uygulanması için kısa bekle
            self.check_stop_signal()
            
            # En üstteki botu (en yüksek PNL) seç
            for _ in range(10):
                try:
                    top_bot = self.driver.find_element(By.XPATH, "(//button[contains(text(), 'Copy')])[1]")
                    top_bot.click()
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
                    
            self.log("PNL'si en yüksek bot seçildi.")
            
            # 4. Tekrar "Copy" butonuna basarak işlemi onayla
            self.log("İşlem onaylanıyor...")
            self.check_stop_signal()
            
            for _ in range(10):
                try:
                    confirm_copy = self.driver.find_element(By.XPATH, "//button[contains(text(), 'Copy')]")
                    confirm_copy.click()
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
            
            # 5. Investment, Stop Loss ve Take Profit değerlerini ayarla
            self.log("Parametreler ayarlanıyor...")
            self.check_stop_signal()
            
            # Investment miktarını ayarla
            for _ in range(10):
                try:
                    investment_input = self.driver.find_element(By.XPATH, "//label[contains(text(), 'Investment')]/following-sibling::div//input")
                    investment_input.clear()
                    investment_input.send_keys("25")
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
            
            # Stop Loss değerini ayarla
            self.check_stop_signal()
            for _ in range(10):
                try:
                    stop_loss_input = self.driver.find_element(By.XPATH, "//label[contains(text(), 'Stop Loss')]/following-sibling::div//input")
                    stop_loss_input.clear()
                    stop_loss_input.send_keys("1")
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
            
            # Take Profit değerini ayarla
            self.check_stop_signal()
            for _ in range(10):
                try:
                    take_profit_input = self.driver.find_element(By.XPATH, "//label[contains(text(), 'Take Profit')]/following-sibling::div//input")
                    take_profit_input.clear()
                    take_profit_input.send_keys("0.50")
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
                    
            self.log("Parametreler başarıyla ayarlandı.")
            
            # 6. "Create" butonuna basarak işlemi başlat
            self.log("İşlem başlatılıyor...")
            self.check_stop_signal()
            
            for _ in range(10):
                try:
                    create_btn = self.driver.find_element(By.XPATH, "//button[contains(text(), 'Create')]")
                    create_btn.click()
                    break
                except:
                    self.check_stop_signal()
                    time.sleep(0.5)
            
            # İşlemin başlatıldığını doğrula
            successful = False
            for _ in range(20): # 10 saniye timeout
                self.check_stop_signal()
                try:
                    self.driver.find_element(By.XPATH, "//div[contains(text(), 'Bot Created Successfully')]")
                    successful = True
                    break
                except:
                    time.sleep(0.5)
                    
            if successful:
                self.log("İşlem başarıyla başlatıldı.")
            else:
                self.log("İşlem başlatma onayı alınamadı, ama devam ediliyor.")
            
        except Exception as e:
            if "Durdurma sinyali alındı" in str(e):
                raise
            self.log(f"İşlem döngüsü sırasında hata: {str(e)}")
            raise
    
    def check_take_profit(self):
        try:
            self.check_stop_signal()
            # Bu fonksiyon Take Profit'in gerçekleşip gerçekleşmediğini kontrol eder
            profit_element = self.driver.find_element(By.XPATH, "//div[contains(@class, 'profit-value')]")
            profit_text = profit_element.text
            
            # Profit değerini al ve Take Profit değeriyle karşılaştır
            profit_value = float(profit_text.replace("$", "").strip())
            take_profit_value = 0.50
            
            return profit_value >= take_profit_value
            
        except Exception as e:
            if "Durdurma sinyali alındı" in str(e):
                raise
            self.log(f"Take Profit kontrolü sırasında hata: {str(e)}")
            return False

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

if __name__ == "__main__":
    main()

import time
import threading
import tkinter as tk
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from webdriver_manager.chrome import ChromeDriverManager

# Botun çalışıp çalışmadığını kontrol eden değişken
bot_running = False

# Tarayıcı başlatma fonksiyonu
def start_browser():
    global driver
    options = webdriver.ChromeOptions()
    options.add_argument("--start-maximized")
    driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)

# Binance Grid Bot işlemlerini yapan fonksiyon
def run_bot():
    global bot_running
    start_browser()
    
    driver.get("https://www.binance.com/en/futures/grid-trading")
    time.sleep(3)

    while bot_running:
        try:
            # **Filtreleme**: x50 kaldıraç ve max 25$ yatırım miktarı
            filter_button = driver.find_element(By.XPATH, "//button[contains(text(), 'Filter')]")
            filter_button.click()
            time.sleep(1)

            leverage_option = driver.find_element(By.XPATH, "//option[contains(text(), 'x50')]")
            leverage_option.click()
            time.sleep(1)

            investment_filter = driver.find_element(By.XPATH, "//input[@placeholder='Max Investment']")
            investment_filter.send_keys(Keys.CONTROL + "a") # Önce var olanı temizle
            investment_filter.send_keys("25")
            investment_filter.send_keys(Keys.RETURN)
            time.sleep(2)

            # **PNL'si en yüksek olan botu seç ve 'Copy' yap**
            top_bot = driver.find_element(By.XPATH, "(//button[contains(text(), 'Copy')])[1]")
            top_bot.click()
            time.sleep(1)

            copy_confirm = driver.find_element(By.XPATH, "//button[contains(text(), 'Copy')]")
            copy_confirm.click()
            time.sleep(2)

            # **Ayarları yap**
            investment_input = driver.find_element(By.XPATH, "//input[@name='investment']")
            investment_input.send_keys(Keys.CONTROL + "a")
            investment_input.send_keys("25")

            stop_loss_input = driver.find_element(By.XPATH, "//input[@name='stopLoss']")
            stop_loss_input.send_keys(Keys.CONTROL + "a")
            stop_loss_input.send_keys("1")

            take_profit_input = driver.find_element(By.XPATH, "//input[@name='takeProfit']")
            take_profit_input.send_keys(Keys.CONTROL + "a")
            take_profit_input.send_keys("0.50")

            # **"Create" butonuna basarak işlemi başlat**
            create_button = driver.find_element(By.XPATH, "//button[contains(text(), 'Create')]")
            create_button.click()
            time.sleep(2)

            # **İşlemi 2 dakika bekleyip kontrol et**
            time.sleep(120)
            driver.refresh()
            time.sleep(3)

            # **Take Profit gerçekleştiyse yeni işlem aç**
            try:
                profit_status = driver.find_element(By.XPATH, "//span[contains(text(), 'Take Profit')]")
                print("✅ Kâr alındı, yeni işlem başlatılıyor...")
                driver.get("https://www.binance.com/en/futures/grid-trading")
            except:
                print("⏳ İşlem devam ediyor...")

        except Exception as e:
            print(f"⚠️ Hata oluştu: {e}")
            break

    driver.quit()

# **Botu başlatma fonksiyonu**
def start_bot():
    global bot_running
    if not bot_running:
        bot_running = True
        threading.Thread(target=run_bot).start()

# **Botu durdurma fonksiyonu**
def stop_bot():
    global bot_running
    bot_running = False

# **GUI Arayüzü**
root = tk.Tk()
root.title("Binance Futures Grid Bot")
root.geometry("300x200")

start_button = tk.Button(root, text="Başlat", command=start_bot, bg="green", fg="white", font=("Arial", 12))
start_button.pack(pady=20)

stop_button = tk.Button(root, text="Dur
dur", command=stop_bot, bg="red", fg="white", font=("Arial", 12))
stop_button.pack(pady=20)

root.mainloop()