collate.py

import customtkinter as ctk
import threading
import time
import psutil
import requests
import hashlib
import os
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from datetime import datetime

# --- CONFIGURATION & STYLING ---
ctk.set_appearance_mode("Dark") # Modes: "System" (standard), "Dark", "Light"
ctk.set_default_color_theme("blue") # Themes: "blue" (standard), "green", "dark-blue"

LOG_DIR = "logs"
os.makedirs(LOG_DIR, exist_ok=True)

# --- THREADED MONITORS (Same Logic, Different Alerts) ---

class BaseMonitor(threading.Thread):
    def __init__(self, update_callback, status_callback):
        super().__init__()
        self.update_callback = update_callback
        self.status_callback = status_callback
        self.running = True
        self.daemon = True

    def stop(self):
        self.running = False

    def log_and_display(self, message, log_file="activity.log", is_alert=False):
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        prefix = "[!!!] ALERT: " if is_alert else "[INFO] "
        full_msg = f"{prefix}{message}"
        self.update_callback(full_msg, is_alert)
        if is_alert: self.status_callback("red") # Set indicator to red on alert
        
        with open(os.path.join(LOG_DIR, log_file), "a") as f:
            f.write(f"[{timestamp}] {full_msg}\n")

class SystemMonitor(BaseMonitor):
    def run(self):
        while self.running:
            cpu = psutil.cpu_percent(interval=1)
            mem = psutil.virtual_memory().percent
            self.log_and_display(f"Heartbeat: CPU: {cpu}% | RAM: {mem}%")
            if cpu > 80 or mem > 90:
                self.log_and_display(f"CRITICAL RESOURCE LOAD: {cpu}% CPU / {mem}% RAM", is_alert=True)
            time.sleep(5)

class NetworkMonitor(BaseMonitor):
    def run(self):
        targets = ["https://www.google.com", "https://www.github.com"]
        while self.running:
            for url in targets:
                try:
                    r = requests.get(url, timeout=5)
                    self.log_and_display(f"Pinging {url}... Status: {r.status_code}")
                except:
                    self.log_and_display(f"DOWNTIME DETECTED: {url} is unreachable!", is_alert=True)
            time.sleep(15)

class FileMonitor(BaseMonitor):
    def run(self):
        class Handler(FileSystemEventHandler):
            def __init__(self, parent): self.parent = parent
            def on_modified(self, event):
                if not event.is_directory and "logs" not in event.src_path:
                    self.parent.log_and_display(f"File Modified: {event.src_path}", is_alert=True)

        observer = Observer()
        observer.schedule(Handler(self), ".", recursive=False)
        observer.start()
        self.log_and_display("File Watcher Activated.")
        while self.running: time.sleep(1)
        observer.stop(); observer.join()

class ProcessMonitor(BaseMonitor):
    def run(self):
        forbidden = ["notepad.exe", "calc.exe", "cmd.exe"]
        alerted_pids = set()
        while self.running:
            current_pids = {p.pid for p in psutil.process_iter()}
            for proc in psutil.process_iter(['pid', 'name']):
                try:
                    name = proc.info['name'].lower()
                    pid = proc.info['pid']
                    if name in forbidden and pid not in alerted_pids:
                        self.log_and_display(f"FORBIDDEN APP OPENED: {name} (PID: {pid})", is_alert=True)
                        alerted_pids.add(pid)
                except: pass
            alerted_pids = alerted_pids.intersection(current_pids)
            time.sleep(3)

class WebMonitor(BaseMonitor):
    def run(self):
        url = "https://www.google.com"
        last_hash = None
        while self.running:
            try:
                new_hash = hashlib.sha256(requests.get(url).text.encode()).hexdigest()
                if last_hash and new_hash != last_hash:
                    self.log_and_display(f"WEB CHANGE DETECTED on {url}", is_alert=True)
                last_hash = new_hash
                self.log_and_display(f"Web Check: Hash matches on {url}")
            except: pass
            time.sleep(60)

# --- PRO UI DASHBOARD ---

class ProDashboard(ctk.CTk):
    def __init__(self):
        super().__init__()

        self.title("SECURITY COMMAND CENTER v2.0")
        self.geometry("1100x700")

        # Grid layout (1x2)
        self.grid_columnconfigure(1, weight=1)
        self.grid_rowconfigure(0, weight=1)

        # 1. SIDEBAR
        self.sidebar_frame = ctk.CTkFrame(self, width=250, corner_radius=0)
        self.sidebar_frame.grid(row=0, column=0, sticky="nsew")
        
        self.logo_label = ctk.CTkLabel(self.sidebar_frame, text="GUARD CORE", font=ctk.CTkFont(size=24, weight="bold"))
        self.logo_label.pack(pady=30)

        self.start_all_btn = ctk.CTkButton(self.sidebar_frame, text="ACTIVATE SUITE", font=ctk.CTkFont(weight="bold"), 
                                         fg_color="#1b5e20", hover_color="#2e7d32", command=self.start_all)
        self.start_all_btn.pack(pady=20, padx=20, fill="x")

        self.monitors = {
            "System": SystemMonitor,
            "Network": NetworkMonitor,
            "File": FileMonitor,
            "Process": ProcessMonitor,
            "Web": WebMonitor
        }
        self.active_threads = {}
        self.buttons = {}
        self.indicators = {}

        for name, cls in self.monitors.items():
            frame = ctk.CTkFrame(self.sidebar_frame, fg_color="transparent")
            frame.pack(pady=5, padx=20, fill="x")

            # Status Indicator (Dot)
            indicator = ctk.CTkLabel(frame, text="●", text_color="gray", font=("Arial", 16))
            indicator.pack(side="left", padx=5)
            self.indicators[name] = indicator

            btn = ctk.CTkButton(frame, text=f"START {name}", width=180, height=35,
                               command=lambda n=name, c=cls: self.toggle_monitor(n, c))
            btn.pack(side="left")
            self.buttons[name] = btn

        # 2. MAIN FEED
        self.main_frame = ctk.CTkFrame(self, corner_radius=10, fg_color="#0a0a0a")
        self.main_frame.grid(row=0, column=1, padx=20, pady=20, sticky="nsew")

        self.console_label = ctk.CTkLabel(self.main_frame, text="LIVE SURVEILLANCE FEED", font=ctk.CTkFont(size=14, weight="bold"), text_color="#00ff00")
        self.console_label.pack(pady=10)

        self.console = ctk.CTkTextbox(self.main_frame, font=("Consolas", 12), fg_color="#000000", text_color="#00ff00")
        self.console.pack(padx=20, pady=10, fill="both", expand=True)

    def log_to_gui(self, message, is_alert=False):
        timestamp = datetime.now().strftime("%H:%M:%S")
        color_prefix = ">>> " if is_alert else "--- "
        self.console.insert("end", f"[{timestamp}] {color_prefix}{message}\n")
        self.console.see("end")

    def set_status_color(self, name, color):
        self.indicators[name].configure(text_color=color)

    def start_all(self):
        for name, cls in self.monitors.items():
            if name not in self.active_threads: self.toggle_monitor(name, cls)

    def toggle_monitor(self, name, cls):
        if name in self.active_threads:
            self.active_threads[name].stop()
            del self.active_threads[name]
            self.buttons[name].configure(text=f"START {name}", fg_color=["#3B8ED0", "#1F6AA5"])
            self.set_status_color(name, "gray")
            self.log_to_gui(f"OFFLINE: {name} Monitor")
        else:
            # We pass two callbacks: one for logs, one for the status indicator color
            thread = cls(self.log_to_gui, lambda c, n=name: self.set_status_color(n, c))
            thread.start()
            self.active_threads[name] = thread
            self.buttons[name].configure(text=f"STOP {name}", fg_color="#c62828")
            self.set_status_color(name, "#4caf50")
            self.log_to_gui(f"ONLINE: {name} Monitor")

if __name__ == "__main__":
    app = ProDashboard()
    app.mainloop()