admin_gui

import tkinter as tk
from tkinter import ttk, messagebox
import mysql.connector

# ---------------- MySQL Configuration ----------------
MYSQL_CONFIG = {
    "host": "10.243.143.218",
    "user": "streamer_user",
    "password": "1234",
    "database": "stock_streamer_db"
}

# ---------------- Database Functions ----------------
def get_connection():
    return mysql.connector.connect(**MYSQL_CONFIG)

def fetch_topics():
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    cursor.execute("SELECT * FROM topics ORDER BY created_at DESC")
    rows = cursor.fetchall()
    conn.close()
    return rows

def fetch_users():
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    cursor.execute("SELECT id, username, email, created_at, last_login FROM users ORDER BY created_at DESC")
    rows = cursor.fetchall()
    conn.close()
    return rows

def approve_topic(topic_name, companies):
    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute("UPDATE topics SET status='approved', companies=%s WHERE topic_name=%s", (companies, topic_name))
    conn.commit()
    conn.close()
    print(f"[Admin] ✅ Approved: {topic_name}")

def deactivate_topic(topic_name):
    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute("UPDATE topics SET status='deactivate' WHERE topic_name=%s", (topic_name,))
    conn.commit()
    conn.close()
    print(f"[Admin] 📴 Deactivated: {topic_name}")
    
def reject_topic(topic_name):
    conn = get_connection()
    cursor = conn.cursor()
    cursor.execute("UPDATE topics SET status='rejected' WHERE topic_name=%s", (topic_name,))
    conn.commit()
    conn.close()
    print(f"[Admin] ❌ Rejected: {topic_name}")


def fetch_user_subscriptions():
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    cursor.execute("""
        SELECT us.id, u.username, u.email, t.topic_name, t.status, us.subscribed_at
        FROM user_subscriptions us
        JOIN users u ON us.user_id = u.id
        JOIN topics t ON us.topic_id = t.id
        ORDER BY us.subscribed_at DESC
    """)
    rows = cursor.fetchall()
    conn.close()
    return rows

def fetch_subscriptions_by_user(user_id):
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    cursor.execute("""
        SELECT t.topic_name, t.status, t.companies, us.subscribed_at
        FROM user_subscriptions us
        JOIN topics t ON us.topic_id = t.id
        WHERE us.user_id = %s
        ORDER BY us.subscribed_at DESC
    """, (user_id,))
    rows = cursor.fetchall()
    conn.close()
    return rows

def fetch_subscriptions_by_topic(topic_name):
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    cursor.execute("""
        SELECT u.id, u.username, u.email, us.subscribed_at
        FROM user_subscriptions us
        JOIN users u ON us.user_id = u.id
        JOIN topics t ON us.topic_id = t.id
        WHERE t.topic_name = %s
        ORDER BY us.subscribed_at DESC
    """, (topic_name,))
    rows = cursor.fetchone()
    conn.close()
    return rows

# ---------------- Tkinter UI ----------------
class AdminGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("🧠 Stock Streamer Admin")
        self.root.geometry("1000x700")

        # Notebook (Tabs)
        self.notebook = ttk.Notebook(root)
        self.notebook.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        # Tab 1: Topics
        self.topics_tab = tk.Frame(self.notebook)
        self.notebook.add(self.topics_tab, text="📋 Topics")
        self.setup_topics_tab()

        # Tab 2: Users
        self.users_tab = tk.Frame(self.notebook)
        self.notebook.add(self.users_tab, text="👥 Users")
        self.setup_users_tab()

        # Tab 3: Subscriptions
        self.subs_tab = tk.Frame(self.notebook)
        self.notebook.add(self.subs_tab, text="📊 Subscriptions")
        self.setup_subscriptions_tab()

    # ============ TOPICS TAB ============
    def setup_topics_tab(self):
        tk.Label(self.topics_tab, text="📋 Topics Management", font=("Arial", 12, "bold")).pack(pady=(10, 5))
        
        self.tree = ttk.Treeview(self.topics_tab, columns=("ID", "Topic", "Companies", "Status", "Created"), show="headings", height=10)
        for col in ("ID", "Topic", "Companies", "Status", "Created"):
            self.tree.heading(col, text=col)
        
        self.tree.column("ID", width=50)
        self.tree.column("Topic", width=150)
        self.tree.column("Companies", width=250)
        self.tree.column("Status", width=100)
        self.tree.column("Created", width=150)
        
        self.tree.pack(fill=tk.BOTH, expand=True, padx=10, pady=(0, 10))

        form_frame = tk.Frame(self.topics_tab, relief=tk.RIDGE, bd=1, bg="#f0f0f0")
        form_frame.pack(fill=tk.X, padx=10, pady=10)

        tk.Label(form_frame, text="Topic:", bg="#f0f0f0", font=("Arial", 9, "bold")).grid(row=0, column=0, padx=10, pady=8, sticky="e")
        self.topic_entry = tk.Entry(form_frame, width=30, state='readonly')
        self.topic_entry.grid(row=0, column=1, padx=10, pady=8)

        tk.Label(form_frame, text="Companies:", bg="#f0f0f0", font=("Arial", 9, "bold")).grid(row=1, column=0, padx=10, pady=8, sticky="e")
        self.companies_entry = tk.Entry(form_frame, width=30)
        self.companies_entry.grid(row=1, column=1, padx=10, pady=8)

        btn_frame = tk.Frame(self.topics_tab)
        btn_frame.pack(pady=10)
        tk.Button(btn_frame, text="✅ Approve", command=self.approve_selected, bg="#4CAF50", fg="white", width=15).grid(row=0, column=0, padx=5)
        tk.Button(btn_frame, text="❌ Reject", command=self.reject_selected, bg="#F44336", fg="white", width=15).grid(row=0, column=1, padx=5)
        tk.Button(btn_frame, text="📴 Deactivate", command=self.deactivate_selected, bg="#9C27B0", fg="white", width=15).grid(row=0, column=2, padx=5)
        tk.Button(btn_frame, text="👥 Subscribers", command=self.view_topic_subscribers, bg="#607D8B", fg="white", width=15).grid(row=0, column=3, padx=5)
        tk.Button(btn_frame, text="🔄 Refresh", command=self.load_topics, bg="#555", fg="white", width=15).grid(row=0, column=4, padx=5)

        self.tree.bind("<ButtonRelease-1>", self.select_topic)
        self.load_topics()

    def load_topics(self):
        for item in self.tree.get_children():
            self.tree.delete(item)
        
        for t in fetch_topics():
            self.tree.insert("", "end", values=(t["id"], t["topic_name"], t["companies"], t["status"], t["created_at"]))

    def select_topic(self, event):
        selected = self.tree.focus()
        if not selected:
            return
        data = self.tree.item(selected)["values"]
        
        self.topic_entry.config(state='normal')
        self.topic_entry.delete(0, tk.END)
        self.topic_entry.insert(0, data[1])
        self.topic_entry.config(state='readonly')
        
        self.companies_entry.delete(0, tk.END)
        if data[2]:
            self.companies_entry.insert(0, data[2])

    def approve_selected(self):
        topic = self.topic_entry.get().strip().lower()
        companies = self.companies_entry.get().strip()
        
        if not topic or not companies:
            messagebox.showwarning("Missing Data", "Select topic and enter companies")
            return
        
        try:
            approve_topic(topic, companies)
            messagebox.showinfo("Success", f"✅ '{topic}' approved!\n\nProducer will activate it.")
            self.load_topics()
        except Exception as e:
            messagebox.showerror("Error", str(e))
            
    def reject_selected(self):
        topic = self.topic_entry.get().strip().lower()
        if not topic:
            messagebox.showwarning("Missing Data", "Select a topic first")
            return

        if not messagebox.askyesno("Confirm", f"Reject topic '{topic}'?\n\nIt will not be created in Kafka."):
            return

        try:
            reject_topic(topic)
            messagebox.showinfo("Success", f"❌ '{topic}' rejected successfully!")
            self.load_topics()
        except Exception as e:
            messagebox.showerror("Error", str(e))


    def deactivate_selected(self):
        topic = self.topic_entry.get().strip().lower()
        
        if not topic:
            messagebox.showwarning("Missing Data", "Select a topic first")
            return
        
        if not messagebox.askyesno("Confirm", f"Deactivate '{topic}'?\n\nThis will delete the Kafka topic."):
            return
        
        try:
            deactivate_topic(topic)
            messagebox.showinfo("Success", f"📴 '{topic}' deactivated!")
            self.load_topics()
        except Exception as e:
            messagebox.showerror("Error", str(e))

    def view_topic_subscribers(self):
        topic = self.topic_entry.get().strip().lower()
        
        if not topic:
            messagebox.showwarning("Missing Data", "Select a topic")
            return
        
        try:
            subs = fetch_subscriptions_by_topic(topic)
            
            win = tk.Toplevel(self.root)
            win.title(f"Subscribers: {topic}")
            win.geometry("700x400")
            
            tk.Label(win, text=f"Users subscribed to '{topic}'", font=("Arial", 12, "bold")).pack(pady=10)
            
            tree = ttk.Treeview(win, columns=("User ID", "Username", "Email", "Subscribed"), show="headings")
            for col in ("User ID", "Username", "Email", "Subscribed"):
                tree.heading(col, text=col)
            
            tree.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
            
            if subs:
                for s in subs:
                    tree.insert("", "end", values=(s["id"], s["username"], s["email"], s["subscribed_at"]))
            else:
                tk.Label(win, text="No subscribers yet", fg="#999").pack(pady=20)
            
            tk.Button(win, text="Close", command=win.destroy, bg="#555", fg="white").pack(pady=10)
            
        except Exception as e:
            messagebox.showerror("Error", str(e))

    # ============ USERS TAB ============
    def setup_users_tab(self):
        tk.Label(self.users_tab, text="👥 User Management", font=("Arial", 12, "bold")).pack(pady=(10, 5))
        
        self.users_tree = ttk.Treeview(self.users_tab, columns=("ID", "Username", "Email", "Created", "Last Login"), show="headings", height=12)
        for col in ("ID", "Username", "Email", "Created", "Last Login"):
            self.users_tree.heading(col, text=col)
        
        self.users_tree.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        btn_frame = tk.Frame(self.users_tab)
        btn_frame.pack(pady=10)

        tk.Button(btn_frame, text="📋 View Subscriptions", command=self.view_user_subs, bg="#2196F3", fg="white", width=20).grid(row=0, column=0, padx=5)
        tk.Button(btn_frame, text="🔄 Refresh", command=self.load_users, bg="#555", fg="white", width=20).grid(row=0, column=1, padx=5)

        self.load_users()

    def load_users(self):
        for item in self.users_tree.get_children():
            self.users_tree.delete(item)
        
        for u in fetch_users():
            self.users_tree.insert("", "end", values=(u["id"], u["username"], u["email"], u["created_at"], u["last_login"] or "Never"))

    def view_user_subs(self):
        selected = self.users_tree.focus()
        if not selected:
            messagebox.showwarning("No Selection", "Select a user")
            return
        
        data = self.users_tree.item(selected)["values"]
        user_id = data[0]
        username = data[1]
        
        try:
            subs = fetch_subscriptions_by_user(user_id)
            
            win = tk.Toplevel(self.root)
            win.title(f"Subscriptions: {username}")
            win.geometry("700x400")
            
            tk.Label(win, text=f"Subscriptions for '{username}'", font=("Arial", 12, "bold")).pack(pady=10)
            
            tree = ttk.Treeview(win, columns=("Topic", "Status", "Companies", "Subscribed"), show="headings")
            for col in ("Topic", "Status", "Companies", "Subscribed"):
                tree.heading(col, text=col)
            
            tree.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
            
            if subs:
                for s in subs:
                    tree.insert("", "end", values=(s["topic_name"], s["status"], s["companies"], s["subscribed_at"]))
                tk.Label(win, text=f"Total: {len(subs)}", font=("Arial", 10, "bold")).pack(pady=5)
            else:
                tk.Label(win, text="No subscriptions", fg="#999").pack(pady=20)
            
            tk.Button(win, text="Close", command=win.destroy, bg="#555", fg="white").pack(pady=10)
            
        except Exception as e:
            messagebox.showerror("Error", str(e))

    # ============ SUBSCRIPTIONS TAB ============
    def setup_subscriptions_tab(self):
        tk.Label(self.subs_tab, text="📊 All Subscriptions", font=("Arial", 12, "bold")).pack(pady=(10, 5))
        
        self.subs_tree = ttk.Treeview(self.subs_tab, columns=("ID", "Username", "Email", "Topic", "Status", "Subscribed"), show="headings", height=15)
        for col in ("ID", "Username", "Email", "Topic", "Status", "Subscribed"):
            self.subs_tree.heading(col, text=col)
        
        self.subs_tree.column("ID", width=50)
        self.subs_tree.column("Username", width=120)
        self.subs_tree.column("Email", width=180)
        self.subs_tree.column("Topic", width=150)
        self.subs_tree.column("Status", width=100)
        self.subs_tree.column("Subscribed", width=150)
        
        self.subs_tree.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        tk.Button(self.subs_tab, text="🔄 Refresh", command=self.load_subscriptions, bg="#555", fg="white", width=20).pack(pady=10)

        self.load_subscriptions()

    def load_subscriptions(self):
        for item in self.subs_tree.get_children():
            self.subs_tree.delete(item)
        
        subs = fetch_user_subscriptions()
        for s in subs:
            self.subs_tree.insert("", "end", values=(s["id"], s["username"], s["email"], s["topic_name"], s["status"], s["subscribed_at"]))

# ---------------- Run ----------------
if __name__ == "__main__":
    root = tk.Tk()
    app = AdminGUI(root)
    root.mainloop()