FileSearchUI

import os
import re
import tkinter as tk
from tkinter import filedialog, ttk
from pathlib import Path
import webbrowser
import time


class FileSearchApp:
    def __init__(self, root):
        self.root = root
        self.root.title("File Search and Sort")
        self.root.geometry("1200x1000")

        self.folder_path = tk.StringVar(value="D:/ABogue/Books/")
        self.search_patterns = tk.StringVar(value="pytorch, python")
        self.extensions = tk.StringVar(value="pdf, txt")
        self.sort_by = tk.StringVar(value="published, publisher, modified")
        self.publisher_filters = tk.StringVar()
        self.limit = tk.IntVar(value=100)

        self.all_results = []  # Store all search results
        self.create_widgets()

    def create_widgets(self):
        frame = ttk.Frame(self.root)
        frame.pack(pady=10, padx=10, fill=tk.X)

        ttk.Button(frame, text="Select Folder", command=self.select_folder).grid(row=0, column=0, sticky=tk.W, padx=5)
        ttk.Label(frame, textvariable=self.folder_path, foreground="green").grid(row=0, column=1, sticky=tk.W, padx=5)

        self.add_input(frame, "Search Patterns:", self.search_patterns, 1)
        self.add_input(frame, "File Extensions:", self.extensions, 2)
        self.add_input(frame, "Sort By:", self.sort_by, 3)
        self.add_input(frame, "Publisher Filters:", self.publisher_filters, 4)

        ttk.Label(frame, text="Limit:").grid(row=5, column=0, sticky=tk.W, padx=5)
        ttk.Entry(frame, textvariable=self.limit, width=10).grid(row=5, column=1, sticky=tk.W, padx=5)

        # ttk.Button(frame, text="Search Files", command=self.search_files).grid(row=6, column=0, columnspan=2, pady=5)
        ttk.Button(frame, text="Search Files", command=self.search_files).grid(row=6, column=0, sticky=tk.W, pady=5)

        # ttk.Button(frame, text="By Published", command=self.by_published).grid(row=7, column=0, sticky=tk.W, pady=10)
        # ttk.Button(frame, text="By Publisher", command=self.by_publisher).grid(row=8, column=0, sticky=tk.W, pady=10)
        # ttk.Button(frame, text="By Date", command=self.by_modified_date).grid(row=9, column=0, sticky=tk.W, pady=10)

        # Progress bar
        self.progress = ttk.Progressbar(self.root, orient="horizontal", length=480, mode="determinate")
        self.progress.pack(pady=10, padx=10, fill=tk.X)

        # Filter input field
        ttk.Label(self.root, text="Filter Results:").pack(pady=5)
        self.filter_var = tk.StringVar()
        self.filter_entry = ttk.Entry(self.root, textvariable=self.filter_var, width=50)
        self.filter_entry.pack()
        self.filter_entry.bind("<KeyRelease>", self.filter_results)  # Event binding

        # Results listbox
        self.results_frame = ttk.Frame(self.root, padding=10)
        self.results_frame.pack(fill=tk.BOTH, expand=True)
        self.results_list = tk.Listbox(self.results_frame, height=15, font=("Arial", 11))
        self.results_list.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        self.results_list.bind("<Double-Button-1>", self.open_file)

    def add_input(self, frame, label, var, row):
        ttk.Label(frame, text=label).grid(row=row, column=0, sticky=tk.W, padx=5)
        ttk.Entry(frame, textvariable=var, width=50).grid(row=row, column=1, sticky=tk.W, padx=5)

    def select_folder(self):
        folder = filedialog.askdirectory()
        print('folder selected:', folder)
        if folder:
            self.folder_path.set(folder)

    def reset(self):
        self.progress["value"] = 0
        self.results_list.delete(0, tk.END)
        self.filter_entry.delete(0, tk.END)

    def by_modified_date(self):
        sort_by = ['modified']
        self.all_results.sort(key=lambda x: self.get_sort_key(x, sort_by), reverse=True)
        self.display_results(self.all_results)

    def by_publisher(self):
        sort_by = ['publisher']
        self.all_results.sort(key=lambda x: self.get_sort_key(x, sort_by), reverse=True)
        self.display_results(self.all_results)

    def by_published(self):
        sort_by = ['published']
        self.all_results.sort(key=lambda x: self.get_sort_key(x, sort_by), reverse=True)
        self.display_results(self.all_results)

    def search_files(self):
        self.reset()

        folder = Path(self.folder_path.get())
        if not folder.exists():
            return

        include_patterns, exclude_patterns = self.get_patterns(self.search_patterns.get())
        extensions = [ext.strip().lower() for ext in self.extensions.get().split(",")]
        print('extensions:', extensions)
        sort_by = [s.strip().lower() for s in self.sort_by.get().split(",")]
        include_publishers, exclude_publishers = self.get_patterns(self.publisher_filters.get())

        files = list(folder.glob("**/*"))  # Get all files first
        total_files = len(files)
        self.progress["maximum"] = total_files
        self.progress["value"] = 0

        results = []
        for idx, file in enumerate(files):
            if extensions:  # Check if extensions list is not empty
                if not file.is_file() or file.suffix[1:].lower() not in extensions:
                    continue

            filename = file.name.lower()
            if include_patterns and not any(p in filename for p in include_patterns):
                continue
            if any(p in filename for p in exclude_patterns):
                continue

            publisher = self.extract_publisher(filename)
            if include_publishers and publisher not in include_publishers:
                continue
            if publisher in exclude_publishers:
                continue

            results.append((file, self.extract_year(filename), publisher, file.stat().st_mtime))

            self.progress["value"] = idx + 1
            self.root.update_idletasks()  # Update UI during search
            time.sleep(0.01)  # Simulate processing delay

        results.sort(key=lambda x: self.get_sort_key(x, sort_by), reverse=True)

        self.all_results = results[:self.limit.get()]
        self.display_results(self.all_results)
        self.progress["value"] = total_files  # Ensure full completion

    def get_patterns(self, pattern_str):
        patterns = [p.strip() for p in pattern_str.split(",") if p.strip()]
        return ([p for p in patterns if not p.startswith("-")],
                [p[1:] for p in patterns if p.startswith("-")])

    def extract_year(self, filename):
        match = re.search(r'\b(19\d{2}|20\d{2})\b', filename)
        return int(match.group()) if match else 0

    def extract_publisher(self, filename):
        match = re.match(r'([^\-]+)-', filename)
        return match.group(1).strip().lower() if match else "unknown"

    def get_sort_key(self, file_data, sort_by):
        file, year, publisher, modified = file_data
        key = []
        for criteria in sort_by:
            if criteria == "published":
                key.append(year)
            elif criteria == "publisher":
                key.append(publisher)
            elif criteria == "modified":
                key.append(modified)
        return tuple(key)

    def display_results(self, files):
        self.results_list.delete(0, tk.END)
        for file, year, publisher, _ in files:
            self.results_list.insert(tk.END, f"{file.name}")

    def filter_results(self, event):
        query = self.filter_var.get().lower()
        filtered_files = [f for f in self.all_results if query in f[0].name.lower()]
        self.display_results(filtered_files)

    def open_file(self, event):
        selected = self.results_list.curselection()
        if selected:
            file_name = self.results_list.get(selected[0])
            file_path = Path(self.folder_path.get()) / file_name
            if file_path.exists():
                webbrowser.open(file_path.as_uri())


if __name__ == "__main__":
    root = tk.Tk()
    app = FileSearchApp(root)
    root.mainloop()