import socket,platform,subprocess,re
import json
import os
import sys
import logging
import base64
import time
import zlib
import gc,ssl
import gzip
import uuid
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    datefmt='%H:%M:%S'
)
def is_json(data):
    """Gelen string geçerli bir JSON mı?"""
    try:
        json.loads(data)
        return True
    except:
        return False
def measure_data(data):
    """Verinin ağda kaplayacağı tahmini boyutu (byte/kb) hesaplar."""
    size_bytes = sys.getsizeof(data)
    if size_bytes < 1024:
        return f"{size_bytes} Bytes"
    return f"{round(size_bytes / 1024, 2)} KB"
def guess_os(ip):
    """Ping atarak dönen TTL değerinden OS tahmini yapar."""
    ping_res = get_real_ping(ip)
    if isinstance(ping_res, int) and ping_res > 0:
        # Standart TTL değerleri: Windows=128, Linux=64, Cisco/Network=255
        # (Not: Router geçtikçe bu değer azalır, en yakına yuvarlıyoruz)
        if ping_res > 128: return "Cisco / Network Device"
        elif ping_res > 64: return "Windows OS"
        else: return "Linux / Unix / MacOS"
    return "OS Detection Failed"
def get_server_banner(host, port=80):
    """Sitenin hangi sunucu yazılımını kullandığını (Server Header) söyler."""
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.settimeout(1.5)
            s.connect((host, port))
            # Sadece header bilgilerini istemek için HEAD metodunu kullanıyoruz
            s.sendall(f"HEAD / HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\n\r\n".encode())
            response = s.recv(2048).decode(errors='ignore')
            for line in response.split('\r\n'):
                if line.lower().startswith("server:"):
                    return line
        return "Server header not found."
    except Exception as e:
        return f"Banner Error: {e}"
def tryfaster():
    gc.disable() # Gereksiz temizliği durdur, hıza odaklan
    return "Garbage collector disabled."
# Orijinal socket metodunu bir kenara saklayalım
_original_socket = socket.socket
print("-" * 35)
print("[bestsockett] v1.0.8")
print("-" * 35)
# Kütüphane versiyonunu burada da belirtebilirsin (isteğe bağlı)
__version__ = "1.0.8"
__author__ = "eykturkishyapimcisi on pypi"
_PANIC_UNTIL = 0

def get_ssl_expiry(host, port=443):
    """Sitenin SSL sertifikasının bitiş tarihini döndürür."""
    context = ssl.create_default_context()
    with socket.create_connection((host, port)) as sock:
        with context.wrap_socket(sock, server_hostname=host) as ssock:
            cert = ssock.getpeercert()
            return cert.get('notAfter')

def http_get(host, path="/", port=80, user_agent=None,timeout=2):
    global __version__
    """
    HTTP GET request with Gzip/Zlib compression support only.
    """
    if user_agent is None:
        user_agent = f"BestSockett/{__version__}"

    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.settimeout(timeout)
            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
            s.connect((host, port))

            request = (
                f"GET {path} HTTP/1.1\r\n"
                f"Host: {host}\r\n"
                f"User-Agent: {user_agent}\r\n"
                f"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n"
                f"Accept-Language: tr-TR,tr;q=0.9,en;q=0.8\r\n"
                f"Accept-Encoding: gzip, deflate\r\n"
                f"Connection: close\r\n"
                f"Upgrade-Insecure-Requests: 1\r\n"
                f"Cache-Control: max-age=0\r\n"
                f"\r\n"
            )
            s.sendall(request.encode('utf-8'))

            response = b""
            while True:
                chunk = s.recv(4096)
                if not chunk: break
                response += chunk

            parts = response.split(b"\r\n\r\n", 1)
            header = parts[0].decode('utf-8', errors='ignore')
            body = parts[1] if len(parts) > 1 else b""

            header_lower = header.lower()

            if "content-encoding: gzip" in header_lower:
                # Gzip: Genelde web sitelerinin %90'ı bunu kullanır
                body = gzip.decompress(body)
            elif "content-encoding: deflate" in header_lower:
                # Deflate (Zlib): Daha eski ama hala kullanılan bir standart
                body = zlib.decompress(body)
            # Eğer başka bir encoding yoksa (raw html), doğrudan devam eder.

            # Son hamle: Byte verisini karakterlere (string) dönüştür
            # 'errors=ignore' sayesinde bozuk karakterler programı çökertmez.
            return body.decode('utf-8', errors='ignore')
    except Exception as e:
        logging.error(f"HTTP GET Error: {e}")  # Daha açıklayıcı log
        return "<!DOCTYPE html><html><head><title>Error</title></head><body><h1>HTTP GET Error</h1></body></html>"
def arp_scan():
    """
    Yerel ağdaki aktif cihazları (IP ve MAC) tarar ve liste olarak döndürür.
    Dış kütüphane gerektirmez! 😎
    """
    system = platform.system().lower()
    devices = []

    try:
        # 1. Önce ağdaki cihazları 'uyandırmak' için bir ping fırlatıyoruz (opsiyonel ama iyidir)
        # Windows'ta 'arp -a' komutu sistemin kendi ARP tablosunu okur.
        output = subprocess.check_output(["arp", "-a"]).decode('cp857' if system == "windows" else 'utf-8')

        # 2. Regex ile IP ve MAC adreslerini cımbızla çekiyoruz
        # Örnek satır: 192.168.1.1      00-11-22-33-44-55     dinamik
        pattern = r"(\d+\.\d+\.\d+\.\d+)\s+([0-9a-fA-F:-]{17})"
        matches = re.findall(pattern, output)

        for ip, mac in matches:
            # Kendi IP'mizi veya broadcast adreslerini elemek istersen filtre koyabilirsin
            devices.append({"ip": ip, "mac": mac})

        return devices
    except Exception as e:
        return f"ARP Scan Error: {e}"

def panic_lock(seconds):
    """Locks the system for X seconds and replies with [panic] to everyone."""
    global _PANIC_UNTIL
    _PANIC_UNTIL = time.time() + seconds
    print(f"[bestsockett] 🚨 PANIC MODE ACTIVATED for {seconds}s!")


def waitdata(port=5050, buffer=4524):
    """
    Sadece BİR paket bekler ve döner. (Sonsuz döngü YOK)
    Kullanım: veri = waitdata()
    """
    port = int(port)
    # socket.socket(AF_INET, SOCK_STREAM) -> TCP Bağlantısı
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        try:
            sock.bind(('0.0.0.0', port))
            sock.listen(1)
            conn, addr = sock.accept()
            with conn:
                data = conn.recv(buffer).decode('utf-8')
                # Panic modu kontrolü
                if time.time() < _PANIC_UNTIL:
                    conn.send("[panic]".encode('utf-8'))
                    return "[panic]"

                # JSON veya Metin döndür
                try:
                    return json.loads(data)
                except:
                    return data
        except Exception as e:
            return f"Error: {e}"


def send_data(data, port=5050, ip='127.0.0.1'):
    """Veriyi (metin veya dict) hedefe gönderir."""
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client.connect((ip, port))

    # Eğer veri bir sözlükse JSON'a çevir
    if isinstance(data, dict):
        data = json.dumps(data)

    client.send(str(data).encode('utf-8'))
    return "done"

def get_my_ip():
    """Bilgisayarın o anki yerel ağ IP adresini döndürür."""
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        # Gerçek bir internet çıkışına bağlanıyormuş gibi yapıp yerel IP'yi öğrenir
        s.connect(('8.8.8.8', 80))
        ip = s.getsockname()[0]
    except Exception:
        ip = '127.0.0.1'
    finally:
        s.close()
    return ip

# 58. Güvenli ve Zarif Kapatma (Graceful Shutdown)
def close_safe(sock_obj):
    """
    Soketi önce veri akışına kapatır (shutdown),
    sonra tamamen serbest bırakır. En temiz yöntem budur! B)
    """
    try:
        # socket.SHUT_RDWR: Hem okumayı hem yazmayı durdurur
        sock_obj.shutdown(socket.SHUT_RDWR)
        sock_obj.close()
        return True
    except:
        # Eğer zaten kapalıysa veya hata verirse zorla kapatmayı dene
        return force_close(sock_obj)

# 59. Toplu Bağlantı Temizleyici
def close_all(sock_list):
    """
    Verilen listedeki tüm soketleri tek hamlede kapatır.
    Özellikle Multi-Connection sunucular için hayat kurtarır! 🧹
    """
    closed_count = 0
    for s in sock_list:
        if close_safe(s):
            closed_count += 1
    return f"{closed_count} sockets closed successfully."
def check_internet(timeout=1.5):
    """Sistemin dış dünyaya (internet) erişimi olup olmadığını kontrol eder."""
    try:
        socket.setdefaulttimeout(timeout)
        socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect(("8.8.8.8", 53))
        return True
    except socket.error:
        return False
def get_my_mac():
    """Bilgisayarın fiziksel (MAC) adresini döndürür."""
    return ':'.join(re.findall('..', '%012x' % uuid.getnode()))


# 4. Portun Boş Olup Olmadığını Kontrol Etme
def is_port_open(port, ip='127.0.0.1'):
    """Bir portun açık olup olmadığını test eder."""
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.settimeout(1)
    result = s.connect_ex((ip, port))
    s.close()
    return result == 0

# 5. Bağlantıyı Güvenli Kapatma
def force_close(sock_obj):
    """Verilen soket objesini zorla kapatır."""
    try:
        sock_obj.close()
        return True
    except:
        return False

# 6. Sunucu Banner Gösterimi
def get_real_ping(ip="8.8.8.8"):
    """
    Sends a real ICMP ping using Windows/Linux system commands.
    No Admin privileges required! B)
    """
    # OS Check: Windows uses '-n', others use '-c'
    param = '-n' if platform.system().lower() == 'windows' else '-c'
    command = ['ping', param, '1', ip]

    try:
        # Run the command and grab the output
        # shell=True is sometimes needed on Windows to avoid popup windows
        output = subprocess.check_output(command, stderr=subprocess.STDOUT, universal_newlines=True, shell=True)

        # Regex (Düzenli İfadeler) ile çıktının içinden ms değerini cımbızla çekiyoruz
        # Windows format: "Average = 15ms" veya "time=15ms"
        ms_search = re.search(r"(\d+)ms", output) or re.search(r"time=(\d+)", output)

        if ms_search:
            return int(ms_search.group(1))  # Sadece sayı olarak döndür (örn: 15)
        else:
            return -1  # Ping ulaştı ama ms değerini okuyamadık

    except subprocess.CalledProcessError:
        return -2  # Hedefe ulaşılamadı (Timeout / Offline)
    except Exception as e:
        return f"Error: {e}"
# 🚨 DÜZELTME: get_latency artık OOP değil, bağımsız çalışır
def get_latency(ip, port=5050):
    """Karşı tarafın cevap hızını ölçer."""
    start_time = time.time()
    try:
        # Minik bir TCP el sıkışması
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.settimeout(2)
        s.connect((ip, port))
        s.close()
        return round((time.time() - start_time) * 1000, 2)
    except:
        return -1


def fastsend(data, ip='127.0.0.1', port=5050):
    """
    Işık hızında gönderim!
    Nagle algoritmasını devre dışı bırakır (TCP_NODELAY).
    """
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:
        # 🚨 THE FAST MAGIC: Veriyi bekletmeden anında fırlat!
        client.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        client.settimeout(2.0)

        try:
            client.connect((ip, int(port)))

            # Sözlük gelirse JSON yap
            if isinstance(data, dict):
                data = json.dumps(data)

            client.sendall(str(data).encode('utf-8'))
            return True
        except:
            return False
def smart_send(data, ip, port, retries=3):
    """
    Bağlantı koparsa pes etmez, 3 kere tekrar dener.
    Gazlıgöl'ün meşhur lagına karşı birebir!
    """
    for i in range(retries):
        result = safe_send(data, ip, port)
        if result:
            return True
        print(f"[bestsockett] Retry {i+1}...")
        time.sleep(0.25)
    return False


def encrypt_send(data, ip='127.0.0.1', port=5050, key=410):
    """
    Veriyi önce şifreler, sonra Base64 ile paketler ve
    güvenli bir şekilde karşıya fırlatır. B)
    """
    try:
        # 1. Veri sözlükse JSON'a çevir
        if isinstance(data, dict):
            data = json.dumps(data)

        # 2. Senin 'basic_encrypt' metodunla kaydır
        encrypted_text = "".join(chr(ord(c) + key) for c in str(data))

        # 3. Güvenlik için Base64 zırhı (Ağda karakterler bozulmasın)
        b64_data = base64.b64encode(encrypted_text.encode('utf-8')).decode('utf-8')

        # 4. Çat diye yolla! (send_data_all mantığıyla güvenli gönderim)
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:
            client.settimeout(7.0)  # Güvenirlik için süreyi uzun tuttuk
            client.connect((ip, int(port)))
            client.sendall(b64_data.encode('utf-8'))

        return True
    except Exception as e:
        print(f"[bestsockett] Encrypt Send Error: {e}")
        return False


def smart_receive(port=5050, key=410, buffer=8192):
    """
    Gelen veriyi analiz eder.
    Şifreliyse çözer, düzse direkt verir. B)
    """
    raw_data = waitdata(port, buffer)  # Senin meşhur waitdata'nı çağırır

    if not raw_data or raw_data == "[panic]":
        return raw_data

    # ÇAKALLIK TESTİ: Bu veri bizim şifreleme formatımızda mı?
    try:
        # Önce Base64 zırhını soyuyoruz
        decoded_bytes = base64.b64decode(raw_data)
        decoded_text = decoded_bytes.decode('utf-8')

        # Sonra senin 'basic_decrypt' (key kaydırma) işlemini yapıyoruz
        decrypted_final = "".join(chr(ord(c) - key) for c in decoded_text)

        # Eğer içinden JSON çıkarsa sözlüğe çevir, yoksa metin olarak ver
        try:
            return json.loads(decrypted_final)
        except:
            return decrypted_final

    except:
        # Eğer yukarıdaki işlemler patlarsa (yani veri şifreli değilse)
        # adam direkt düz metin yollamıştır, onu döndür.
        return raw_data
def help_bestsockett():
    """Explains all the 'pro moves' and features in Bestsockett. B)"""
    h = f"""
    [BESTSOCKETT v{__version__}] - OFFICIAL HELP MENU 🚀
    -------------------------------------------
    1.  waitdata(port=5050)          : Camps out until data arrives, then returns it 
    2.  fetch_now(port=5050)         : Peeks at the port; returns None if empty. Zero FPS drop!
    3.  fastsend(data, ip, port)     : Disables Nagle's algorithm. Fires data at light speed (Nitro). ⚡
    4.  encrypt_send(data, ip, port) : Encrypts + Base64 wraps data. Looks like gibberish to hackers. 🔐
    5.  smart_receive(port)          : Auto-detects if data is encrypted and decrypts it instantly. 🧠
    6.  start_slow_beacon(port)      : Shouts 'I am here' every 3s across the network (UDP Broadcast). 🛰️
    7.  find_server(port)            : Radar that finds the Beacon and returns the Server's IP. 📡
    8.  panic_lock(seconds)          : Locks the system for X seconds; replies to everyone with [panic]. 🚨
    9.  send_compressed_json(dict)   : Compresses data with zlib. A true speed demon! 🏎️
    10. get_real_ping(ip)            : Extracts the exact 'ms' value from Windows/Linux ping commands. 📶
    11. get_my_ip()                  : Instantly identifies your local network IP address. 💻
    12. scan_ports(ip, start, end)   : Scans for open 'doors' (ports) on a target IP. 🔍
    -------------------------------------------
    Pro Tip: Use 'data = waitdata()' to assign incoming info directly to a variable!
    """
    print(h)
    return "Help displayed successfully. B)"
def find_server(port=5051, secret_key="hello", timeout=10):
    """Ağdaki Ezytim Beacon sinyalini yakalar ve IP'yi döndürür."""
    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
        sock.bind(('', port))
        sock.settimeout(timeout)
        try:
            while True:
                data, addr = sock.recvfrom(1024)
                if data.decode('utf-8') == secret_key:
                    return addr[0]
        except socket.timeout:
            return None
# 7. Zaman Aşımlı Bağlantı Testi (Ping gibi)
def try_server(ip, port=53, timeout=2.0):
    """Sunucuya ulaşılabiliyor mu kontrol eder."""
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.settimeout(timeout)
    try:
        s.connect((ip, port))
        return True
    except:
        return False
    finally:
        s.close()


def start_slow_beacon(port=5051, secret_key="hello"):
    """
    Ağa her 5 saniyede bir 'Ben buradayım' sinyali fırlatır.
    """
    # UDP soketi (Broadcast için şart!)
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

    # Kendi IP'mizi de mesaja ekleyelim mi? (Opsiyonel çakallık)
    print(f"[bestsockett] Beacon active! Sending signals every 5s on port {port}...")

    try:
        while True:
            # Sinyali fırlat!
            message = f"{secret_key}"
            sock.sendto(message.encode('utf-8'), ('255.255.255.255', port))

            # İşte senin istediğin o 5 saniyelik mola
            time.sleep(2.9)

    except KeyboardInterrupt:
        print("\n[bestsockett] Beacon stopped by user.")
    except Exception as e:
        print(f"Beacon Error: {e}")
    finally:
        sock.close()
# 8. Host Adından IP Bulma (DNS)
def get_ip_by_name(hostname):
    """Örn: 'google.com' yazınca IP döndürür."""
    try:
        return socket.gethostbyname(hostname)
    except:
        return None

# 9. Socket Timeout Ayarlama
def set_global_timeout(sock, seconds):
    """Soketin bekleme süresini ayarlar."""
    sock.settimeout(seconds)

# 10. Basit Mesaj Alıcı (Start Server'ın devamı)
def quick_receive(conn, buffer=4000):
    """Bağlantıdan veriyi okur ve stringe çevirir."""
    data = conn.recv(buffer).decode('utf-8')
    return data

# 11. Sözlüğü JSON olarak Gönder
def send_json(data_dict, ip, port="5050"):
    """Python sözlüğünü (dict) JSON'a çevirip gönderir."""
    json_data = json.dumps(data_dict)
    send_data(json_data, ip, port) # Daha önce yazdığımız send_data'yı kullandık

# 12. Gelen Veriyi JSON Olarak Al
def receive_json(conn, buffer=4000):
    """Gelen byte verisini sözlük yapısına geri çevirir."""
    raw_data = quick_receive(conn, buffer)
    return json.loads(raw_data)

# 13. Verinin JSON Olup Olmadığını Sorgula

# 14. Mesajı Dosyaya Yazdır
def save_to_file(data, filename="received_data.txt"):
    """Gelen veriyi anlık olarak bir dosyaya kaydeder."""
    with open(filename, "a", encoding="utf-8") as f:
        f.write(data + "\n")

# 15. JSON Ayar Dosyası Oluştur (OOP yerine Ayar Yönetimi)
def create_config(ip, port, filename="config.json"):
    """Bağlantı ayarlarını JSON dosyasına kaydeder."""
    config = {"ip": ip, "port": port}
    with open(filename, "w") as f:
        json.dump(config, f)

# 16. JSON Ayar Dosyasını Oku
def load_config(filename="config.json"):
    """Ayarları dosyadan geri okur."""
    if os.path.exists(filename):
        with open(filename, "r") as f:
            return json.load(f)
    return None

# 17. Basit Metin Şifreleme (Sezar Kaydırma gibi)
def basic_encrypt(text, key=410):
    """Mesajı ağda okunmasın diye basitçe kaydırır."""
    return "".join(chr(ord(c) + key) for c in text)

# 18. Şifre Çözücü
def basic_decrypt(text, key=410):
    """Şifreli mesajı eski haline getirir."""
    return "".join(chr(ord(c) - key) for c in text)

# 19. Büyük Veriyi Parçalara Böl (Chunking)
def split_data(data, chunk_size=1024):
    """Veriyi gönderilmeden önce küçük parçalara ayırır."""
    return [data[i:i+chunk_size] for i in range(0, len(data), chunk_size)]

# 20. Dosya Boyutu Kontrolü
def get_file_size(filepath):
    """Gönderilecek dosyanın kaç byte olduğunu söyler."""
    return os.path.getsize(filepath)




# 31. Veriyi Sıkıştır (Compress)
def compress_data(data):
    """Veriyi zlib ile sıkıştırır ve base64 formatına çevirir."""
    if isinstance(data, str):
        data = data.encode('utf-8')
    compressed = zlib.compress(data)
    # Ağda sorun çıkmaması için base64 ile metne çeviriyoruz
    return base64.b64encode(compressed).decode('utf-8')

# 32. Sıkıştırılmış Veriyi Aç (Decompress)
def decompress_data(compressed_string):
    """Sıkıştırılmış base64 veriyi orijinal haline geri döndürür."""
    decoded = base64.b64decode(compressed_string)
    decompressed = zlib.decompress(decoded)
    return decompressed.decode('utf-8')

# 33. Sıkıştırılmış JSON Gönder
def send_compressed_json(data_dict, ip, port="5050"):
    """Sözlüğü JSON yapıp sıkıştırarak gönderir. (Tam bir hız canavarı! :D)"""
    json_data = json.dumps(data_dict)
    compressed = compress_data(json_data)
    send_data(compressed, ip, port)

# 34. Sıkıştırılmış JSON Al
def receive_compressed_json(conn, buffer=8000):
    """Gelen sıkıştırılmış veriyi açar ve JSON (dict) olarak döndürür."""
    raw_data = quick_receive(conn, buffer)
    decompressed = decompress_data(raw_data)
    return json.loads(decompressed)

# 35. Sıkıştırma Oranı Hesapla
def get_compression_ratio(original, compressed):
    """Verinin yüzde kaç küçüldüğünü hesaplar."""
    original_size = len(original)
    compressed_size = len(compressed)
    ratio = (1 - (compressed_size / original_size)) * 100
    return f"%{ratio:.2f} kazanç sağlandı! :D"

# 37. Yerel Ağ Tarayıcısı (Port Scanner)
def scan_ports(ip, start_port, end_port):
    """Belirli bir aralıktaki açık portları bulur."""
    open_ports = []
    for port in range(start_port, end_port + 1):
        if is_port_open(port, ip):
            open_ports.append(port)
    return open_ports


# 39. Otomatik Port Seçici
def find_free_port(start=5000):
    """Boş olan ilk portu bulur ve döndürür."""
    port = start
    while is_port_open(port):
        port += 1
    return port

# 40. Mesaj Zaman Damgası (Timestamp)
def add_timestamp(message):
    """Mesajın başına o anki saati ekler."""
    current_time = time.strftime("%H:%M:%S")
    return f"[{current_time}] {message}"




def socketquickack(enable=True):
    """
    Python'un tüm socket sistemini temelinden modifiye eder.
    Artık hangi kütüphaneyi kullanırsan kullan, her socket turbo başlar! 😎
    """
    if enable:
        # Python'un socket oluşturma fonksiyonunu 'hack'liyoruz
        def turbo_socket(*args, **kwargs):
            sock = _original_socket(*args, **kwargs)
            # Sadece TCP socketler için (AF_INET ve SOCK_STREAM)
            if sock.type == socket.SOCK_STREAM:
                sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
                try:
                    # Windows/Linux QuickACK (12 numara)
                    sock.setsockopt(socket.IPPROTO_TCP, 12, 1)
                except:
                    pass
            return sock

        socket.socket = turbo_socket  # Orijinali bizimkiyle değiştirdik!
        print("[bestsockett] 🚀 SYSTEM-WIDE TURBO: ENGAGED")
    else:
        socket.socket = _original_socket
        print("[bestsockett] 🐢 SYSTEM-WIDE TURBO: DISABLED")
# 41. Log Dosyası Başlatıcı
# 42. Güvenli Gönderim (Hata Yakalamalı)
# 42. Güvenli Gönderim (Hata Yakalamalı)
def safe_send(data, ip, port):
    """Bağlantı kopsa bile programın çökmesini engeller."""
    try:
        # SIRALAMAYI DÜZELTTİK: data, sonra port, sonra ip
        send_data(data, port=port, ip=ip)
        return True
    except Exception as e:
        # Buradaki e sana "str, bytes or bytearray expected" diyordu
        print(f"Critical Error: {e} :(")
        return False
# 43. IP Adresi Doğrulayıcı
def is_valid_ip(ip):
    """Girilen IP adresi format olarak doğru mu kontrol eder."""
    parts = ip.split(".")
    if len(parts) != 4: return False
    try:
        return all(0 <= int(part) <= 255 for part in parts)
    except:
        return False

# 44. Python Versiyon Kontrolü
def check_python_version():
    """Kütüphanenin çalışması için gereken minimum sürümü denetler."""
    if sys.version_info < (3, 6):
        print("Warning: Please use python 3.7 or newer versions.")
        return False
    return True


def send_data_all(data, port=5050, ip='127.0.0.1'):
    """
    Veriyi (metin veya dict) sendall ile kayıpsız şekilde gönderir.
    Performance 2 için en güvenli gönderim metodudur! B) :D
    """
    # socket.AF_INET (IPv4), socket.SOCK_STREAM (TCP)
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    try:
        # Bağlantı için 5 saniye bekleme süresi
        client.settimeout(5.0)
        client.connect((ip, port))

        # Sözlük gelirse JSON'a çevir
        if isinstance(data, dict):
            data = json.dumps(data)

        # Veriyi byte formatına çevir
        encoded_data = str(data).encode('utf-8')

        # sendall: Veri bitene kadar döngüde kalır ve hepsini gönderir.
        client.sendall(encoded_data)

        return "done"
    except Exception as e:
        print(f"Bestsockett Error (send_data_all): {e}")
        return "failed"
    finally:
        # İş bittiğinde kapıyı kilitlemeyi unutma! :D
        client.close()
# 46. Bağlantı Bilgisi Yazdırıcı (Debug Mode)
def debug_connection(conn):
    """Bağlı olan istemcinin tüm teknik detaylarını ekrana basar."""
    info = conn.getpeername()
    print(f"DEBUG: Connected ip: {info[0]}, Port: {info[1]}")

# 47. Veri Tipi Kontrolü
def get_data_type(data):
    """Gelen verinin JSON mı, Metin mi olduğunu söyler."""
    if isinstance(data, dict): return "JSON/Sözlük"
    if is_json(data): return "JSON/String"
    return "Düz Metin"

# 48. Otomatik Buffer Hesaplayıcı
def suggest_buffer(data_size):
    """Veri boyutuna göre ideal buffer (tampon) boyutunu önerir."""
    if data_size < 1024: return 1024
    if data_size < 8192: return 8192
    return 16384

# 49. Kütüphane Bilgisi (About)
def about():
    """Kütüphane hakkındaki bilgileri ve sloganı yazdırır."""
    print("easysocket - This is a lib that makes socket easy to coding.")


# 50. Basit Kapatma Komutu
def kill_process():
    """Kütüphaneyi ve bağlı işlemleri tamamen durdurur."""
    print("Goodbye :(")
    sys.exit()

    # 51. Çoklu Bağlantı Dinleyici (Multi-Connection)


    # 52. Gelen Mesaja Otomatik Yanıt (Auto-Responder)
def auto_reply(conn, expected_msg, reply_msg):
        """Belirli bir kelime gelirse otomatik cevap döner."""
        data = quick_receive(conn)
        if data == expected_msg:
            conn.send(reply_msg.encode('utf-8'))
            return True
        return False

    # 53. Sunucu Durum Raporu (Server Health)
def get_server_stats(sock):
        """Sunucunun bağlı olduğu IP, Port ve protokol bilgilerini verir."""
        return {
            "address": sock.getsockname()[0],
            "port": sock.getsockname()[1],
            "family": "IPv4" if sock.family == 2 else "Diğer"
        }

    # 54. Gelen Veri Filtresi (Whitelisting)
def is_trusted_client(addr, trusted_ips):
        """Sadece listedeki IP'lerin bağlanmasına izin verir."""
        return addr[0] in trusted_ips

    # 55. Sunucu "Heartbeat" (Yaşam Sinyali)
def send_heartbeat(conn):
        """Bağlantının hala kopmadığını anlamak için minik bir 'ping' atar."""
        try:
            conn.send(b"HEARTBEAT")
            return True
        except:
            return False

    # 56. Gelen Veriyi Kategorize Et (JSON vs String)
def auto_parse_server(conn):
        """Veriyi alır; JSON ise dict, değilse string olarak döndürür."""
        raw = quick_receive(conn)
        try:
            return json.loads(raw), "JSON"
        except:
            return raw, "TEXT"

    # 57. Sunucu Log Temizleyici
def clear_server_logs(filename="easysocket.log"):
        """Sunucu şişmesin diye log dosyasını sıfırlar."""
        with open(filename, "w") as f:
            f.write("")
def fetch_now(port=5050):
    """Portu meşgul etmeden hızlıca kontrol eder."""
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        sock.setblocking(False)
        try:
            sock.bind(('0.0.0.0', port))
            sock.listen(1)
            conn, addr = sock.accept()
            with conn:
                data = conn.recv(4096).decode('utf-8')
                return json.loads(data) if is_json(data) else data
        except:
            return None