server.py

import socket
import threading
import re
import sys
import os
from datetime import datetime
import time

# [INOVASI] Cross-Platform Import
# Import select untuk Linux/Mac agar input non-blocking bisa berjalan di kedua OS
try:
    import select
except ImportError:
    pass

# --- KONFIGURASI WARNA ---
# [INOVASI] Estetika Visual (User Experience)
# Menggunakan library colorama untuk membedakan pesan sistem, user, dan admin.
try:
    from colorama import init, Fore, Style
    init(autoreset=True)
    H_MERAH = Fore.RED
    H_HIJAU = Fore.GREEN
    H_KUNING = Fore.YELLOW
    H_BIRU = Fore.CYAN
    RESET = Style.RESET_ALL
except ImportError:
    H_MERAH = H_HIJAU = H_KUNING = H_BIRU = RESET = ""
    
# --- DETEKSI OS UNTUK GETCH (INPUT MANUAL) ---
# [INOVASI] Kompatibilitas Sistem Operasi
# Mendeteksi apakah server berjalan di Windows ('nt') atau Unix/Linux.
if os.name == 'nt': # Windows
    import msvcrt
    def get_char():
        return msvcrt.getwch()
    def input_available():
        return msvcrt.kbhit()
else: # Linux / Mac
    import tty, termios
    def get_char():
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch
    
    def input_available():
        # Pastikan select diimport di atas
        return select.select([sys.stdin], [], [], 0)[0] != []

# KONFIGURASI SERVER
HOST = '0.0.0.0' # [KONSEP JARINGAN] Listen to All Interfaces
PORT = 12345     # Port komunikasi
KATA_KASAR = ["bodoh", "jelek", "goblok", "anjing", "anjir", "babi", "bego"]
list_kata_sensor = ", ".join(KATA_KASAR).upper()

# --- GLOBAL VARIABLES ---
# [KONSEP JARINGAN] Socket Initialization
# AF_INET = IPv4, SOCK_STREAM = TCP Protocol (Reliable connection)
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

# [KONSEP JARINGAN] Binding
# Mengikat socket ke alamat dan port tertentu agar bisa diakses client.
server.bind((HOST, PORT))
server.listen()

clients = []
nicknames = []

# Buffer untuk menyimpan ketikan Admin
admin_buffer = []

# [ALUR] Thread Locking
# Mencegah "Race Condition" saat beberapa thread mencoba nge-print ke layar secara bersamaan.
print_lock = threading.RLock()

def refresh_admin_line():
    """Menggambar ulang prompt Admin dan teks yang sedang diketik"""
    # [INOVASI] Full Duplex UI Logic
    # Teknik manipulasi kursor terminal:
    # \r = Kembalikan kursor ke awal baris
    # \033[K = Hapus semua teks di baris tersebut
    # Ini memastikan input admin tidak "pecah" saat ada pesan masuk dari user.
    current_input = "".join(admin_buffer)
    sys.stdout.write(f"\r\033[K{H_KUNING}Admin (Ketik pesan): {RESET}{current_input}")
    sys.stdout.flush()

def sensor_text(text):
    """Sensor menggunakan REGEX agar menangkap semua variasi huruf besar/kecil"""
    # [INOVASI] Advanced Filtering (Regex Loop)
    # Menggunakan Regular Expression dengan flag IGNORECASE.
    # Contoh: "BoDoH" tetap terdeteksi meski huruf besar kecil dicampur.
    for kata in KATA_KASAR:
        pattern = re.compile(re.escape(kata), re.IGNORECASE)
        text = pattern.sub('*' * len(kata), text)
    return text

def broadcast(message):
    """Kirim pesan ke semua client"""
    # [ALUR] Broadcasting / Fan-Out
    # Server bertindak sebagai hub: menerima 1 pesan, menyebarkan ke N client.
    for client in clients:
        try:
            client.send(message)
        except:
            pass
        
def start_server():
    welcome_message_server = (
        f"{H_HIJAU}============ SERVER BERJALAN DI PORT {PORT} ============{RESET}\n"
        f"Sensor aktif untuk kata:\n"
        f"{H_KUNING}{list_kata_sensor}{RESET}\n"
        f"Ketik {H_MERAH}'EXIT'{RESET} atau tekan {H_MERAH}Ctrl+C{RESET} untuk mematikan server.\n"
        f"{H_HIJAU}========================================================{RESET}\n"
    )
    
    print (welcome_message_server)
    
    # [ALUR] Input Admin Paralel
    # Menjalankan fungsi write_admin di thread terpisah agar server bisa 
    # menerima input admin SEMENTARA tetap menerima koneksi client (Non-blocking).
    threading.Thread(target=write_admin).start()
    
    while True:
        try:
            # [KONSEP JARINGAN] Accepting Connection (Blocking Call)
            # Server menunggu sampai ada client yang connect.
            client, address = server.accept()
            
            # [ALUR] Handshake Protocol
            # Langkah awal pertukaran data: Server minta NICK -> Client kirim NICK.
            client.send('NICK'.encode('utf-8'))
            nickname = client.recv(1024).decode('utf-8')
            nickname = sensor_text(nickname)
            
            nicknames.append(nickname)
            clients.append(client)

            # Broadcast info join
            msg_join = f"\n{H_BIRU}[+] {nickname} bergabung dari {str(address)}{RESET}\n"
            
            # [INOVASI] UI Update dengan Lock
            # Menggunakan Lock agar print info join tidak menimpa ketikan admin.
            with print_lock:
                sys.stdout.write("\r\033[K") # Hapus baris admin yang sedang aktif
                print(msg_join)              # Print info join
                refresh_admin_line()         # Gambar ulang prompt admin
            
            # Broadcast ke user lain
            broadcast(f"\n{H_BIRU}SERVER: {nickname} bergabung ke chat!{RESET}".encode('utf-8'))
            
            # Balikin prompt admin biar rapi
            refresh_admin_line()
            
            # WELCOME MESSAGE & LIST SENSOR
            welcome_message_client = (
                f"\n{H_HIJAU}===== SELAMAT DATANG DI RUANG OBROLAN PORT {PORT}! ======{RESET}\n"
                f"Halo {H_BIRU}{nickname}{RESET}!\n"
                f"Dilarang menggunakan kata kasar:\n"
                f"{H_KUNING}{list_kata_sensor}{RESET}\n"
                f"Ketik {H_MERAH}'EXIT'{RESET} jika ingin keluar dari ruang obrolan\n"
                f"Tekan {H_MERAH}Ctrl+C{RESET} jika ingin keluar aplikasi.\n"
                f"{H_HIJAU}===========================================================\n{RESET}"
            )
            
            # Kirim pesan sambutan HANYA ke client yang baru join
            client.send(welcome_message_client.encode('utf-8'))

            # [KONSEP JARINGAN] Multithreading
            # Membuat thread baru khusus untuk melayani client ini.
            # Agar Server bisa kembali ke atas loop (while True) untuk menerima client lain.
            thread = threading.Thread(target=handle, args=(client,))
            thread.start()
        except OSError:
            break
        except KeyboardInterrupt:
            sys.stdout.write(f"\r\033[K")
            shutdown_server()
            break
        
def shutdown_server():
    """Matikan server dan tendang semua client"""
    with print_lock:
        print(f"\n{H_MERAH}[!] Server dimatikan.{RESET}")
        
    broadcast(f"{H_MERAH}SERVER: Server dimatikan oleh Admin. Dadah!{RESET}".encode('utf-8'))
    
    # [ALUR] Cleanup
    # Menutup semua socket client untuk membebaskan resource.
    for client in clients:
        client.close()
    
    # Tutup socket server
    server.close()
    
    # Matikan program server
    sys.exit(0)

def handle(client):
    """Fungsi utama untuk menangani pesan dari SATU client spesifik"""
    while True:
        try:
            # [KONSEP JARINGAN] Receiving Data
            message = client.recv(1024)
            if not message: 
                raise Exception("Client Disconnected")
            
            message_str = message.decode('utf-8')
            # Sensor dan Broadcast
            message_clean = sensor_text(message_str)
            broadcast(message_clean.encode('utf-8'))
            
            # Tampilkan di Server
            with print_lock:
                # [INOVASI] Full Duplex Display Logic
                # 1. Hapus baris input Admin saat ini (\r\033[K)
                sys.stdout.write("\r\033[K")
                
                # 2. Tampilkan pesan dari client
                sys.stdout.write(f"{message_clean}\n")
                
                # 3. Gambar ulang ketikan Admin yang tadi tertimpa
                refresh_admin_line()
            
        except:
            # [ALUR] Error Handling / Disconnect
            # Jika koneksi putus, hapus client dari list agar tidak error saat broadcast.
            if client in clients:
                index = clients.index(client)
                clients.remove(client)
                client.close()
                nickname = nicknames[index]
                nicknames.remove(nickname)
                
                msg_out = f"{H_MERAH}SERVER: {nickname} keluar dari chat. Dadah!{RESET}"
                broadcast(msg_out.encode('utf-8'))
                
                with print_lock:
                    sys.stdout.write("\r\033[K")
                    print(f"{H_MERAH}[-] {nickname} telah keluar.{RESET}")
                    refresh_admin_line()
                break

def write_admin():
    """Fitur Admin Chat"""
    global admin_buffer
    
    with print_lock:
        refresh_admin_line()
    
    while True:
        try:
            # [ALUR] Input Character-by-Character
            # Mengambil satu karakter keyboard tanpa perlu tekan Enter (Raw Input)
            char = get_char()

            # --- LOGIKA ENTER (KIRIM PESAN) ---
            if char == '\r' or char == '\n':
                with print_lock:
                    text = "".join(admin_buffer)
                    admin_buffer.clear()
                    
                    sys.stdout.write("\r\033[K") # Bersihkan baris input
                    
                    # --- LOGIKA KATA 'EXIT' --- 
                    if text.strip().upper() == 'EXIT':
                        shutdown_server() # Panggil fungsi shutdown
                    
                    if text.strip() != "":
                        text = sensor_text(text)
                        
                        # [INOVASI] Timestamping
                        # Menambahkan penanda waktu real-time pada pesan admin
                        waktu = datetime.now().strftime('%d/%m/%Y %H:%M')
                        msg = f"[{waktu}] {H_MERAH}[ADMIN]{RESET}: {text}"
                        
                        # Tampilkan pesan admin sendiri
                        print(msg)
                        # Kirim ke semua client
                        broadcast(msg.encode('utf-8'))
                    
                    # Munculkan prompt baru
                    refresh_admin_line()
                    
            # --- LOGIKA BACKSPACE (HAPUS) ---
            elif char == '\b' or ord(char) == 8 or ord(char) == 127:
                with print_lock:
                    if len(admin_buffer) > 0:
                        admin_buffer.pop()
                        refresh_admin_line()
                        
            # --- LOGIKA CTRL+C ---
            elif ord(char) == 3:
                shutdown_server()
            
            # --- LOGIKA KARAKTER BIASA ---
            else:
                if char.isprintable():
                    with print_lock:
                        admin_buffer.append(char)
                        sys.stdout.write(char)
                        sys.stdout.flush()

        except (KeyboardInterrupt, EOFError):
            sys.stdout.write(f"\r\033[K")
            shutdown_server()
            break

if __name__ == "__main__":
    try:
        start_server()
    except KeyboardInterrupt:
        shutdown_server()