gui

  1import os
  2import sys
  3import json
  4import time
  5import queue
  6import shutil
  7import gettext
  8import argparse
  9import threading
 10import subprocess
 11import tkinter as tk
 12from tkinter import ttk
 13from src.link_to_file import *
 14from src.downloader.sdilej import Sdilej_downloader
 15from src.downloader.datoid import Datoid_downloader
 16from src.downloader.prehrajto import Prehrajto_downloader
 17from main import download_folder, JSON_FILE
 18from src.downloader.page_search import Download_page_search, InsufficientTimeoutError
 19
 20CONFIG_FILE = "config.json"
 21DEFAULT_LANGUAGE = "en"
 22TIME_OUT = 50
 23
 24LANGUAGES = {
 25    'EN': 'en',
 26    'CZ': 'cs'
 27}
 28
 29SOURCES = [
 30    # {"name": "Sdilej.cz", "class": Sdilej_downloader, "timeout": TIME_OUT},
 31    {"name": "Datoid.cz", "class": Datoid_downloader, "timeout": TIME_OUT},
 32    {"name": "Prehraj.to", "class": Prehrajto_downloader, "timeout": TIME_OUT},
 33]
 34
 35GEOMETRY = (800, 600)
 36GEOMETRY = (1300, 800)
 37APP_NAME = "Universal Downloader"
 38
 39# map source class -> display name for quick lookup
 40CLASS_NAME_MAP = {s["class"]: s["name"] for s in SOURCES}
 41
 42DOMAIN = 'universal_downloader'
 43ICON_FILE = 'icon.png'
 44ASSETS_DIR = 'assets'
 45
 46def get_resource_path(relative_path):
 47    """
 48    Get absolute path to resource, works for dev and for PyInstaller
 49    """
 50    if hasattr(sys, "_MEIPASS"):
 51        # Cesta k dočasné složce při spuštění .exe
 52        return os.path.join(sys._MEIPASS, relative_path)
 53    return os.path.join(os.path.abspath("."), relative_path)
 54
 55def compile_mo_files():
 56    """
 57    Compiles .po files to .mo files using msgfmt.
 58    If msgfmt is not found, skips compilation (Typically on target machine with .exe).
 59    """
 60    localedir = get_resource_path("locales")
 61    msgfmt_path = shutil.which('msgfmt')
 62    if not msgfmt_path:
 63        print("msgfmt not found in PATH — skipping .po -> .mo compilation. Ensure .mo files are included in the build.")
 64        return
 65
 66    for lang in LANGUAGES.values():
 67        po_file = os.path.join(localedir, lang, 'LC_MESSAGES', DOMAIN + '.po')
 68        mo_file = os.path.join(localedir, lang, 'LC_MESSAGES', DOMAIN + '.mo')
 69        if os.path.exists(po_file):
 70            if not os.path.exists(mo_file) or os.path.getmtime(po_file) > os.path.getmtime(mo_file):
 71                print(f"Compiling {po_file} to {mo_file}")
 72                try:
 73                    subprocess.run([msgfmt_path, '-o', mo_file, po_file], check=True)
 74                except subprocess.CalledProcessError as e:
 75                    print(f"msgfmt failed: {e}")
 76
 77class DownloaderGUI(tk.Tk):
 78    lang_codes = LANGUAGES.values()
 79
 80    def __init__(self):
 81        super().__init__()
 82
 83        dpi = self.winfo_fpixels('1i')
 84        self.scaling_factor = dpi / 96.0
 85        
 86        # Nastavení škálování pro Tkinter engine
 87        self.tk.call('tk', 'scaling', self.scaling_factor)
 88        # ---------------------------
 89
 90        # Dynamický výpočet geometrie místo hardcodovaného "1300x800"
 91        width = int(GEOMETRY[0] * self.scaling_factor)
 92        height = int(GEOMETRY[1] * self.scaling_factor)
 93
 94        self.geometry(f"{width}x{height}")
 95
 96        icon_path = get_resource_path(os.path.join(ASSETS_DIR, "icon.png"))
 97        if os.path.isfile(icon_path):
 98            icon = tk.PhotoImage(file=icon_path)
 99            self.iconphoto(True, icon)
100        else:
101            print(f"Icon: '{icon_path}' not found.")
102        
103        self.settings = self.load_config()
104        self.current_language = tk.StringVar(value=self.settings.get("language", DEFAULT_LANGUAGE))
105        self.remove_successful_var = tk.BooleanVar(value=self.settings.get("remove_successful", False))
106        self.remove_successful_var.trace_add("write", self.update_remove_successful)
107        self.add_files_with_failed_timeout_var = tk.BooleanVar(value=self.settings.get("add_files_with_failed_timeout", False))
108        self.add_files_with_failed_timeout_var.trace_add("write", self.update_add_files_with_failed_timeout)
109
110        self.source_vars = []
111        for source in SOURCES:
112            var = tk.BooleanVar(value=self.settings.get(source["name"], True))
113            # Save changes to config on change
114            var.trace_add("write", lambda *args, name=source["name"], var=var: self.settings.update({name: var.get()}) or self.save_config())
115            self.source_vars.append(var)
116
117        self.link_map = {} # detail_url -> Link_to_file (mapping with result treeview)
118
119        self.setup_translation()
120        self.title(_(APP_NAME))
121        self.create_widgets()
122
123    def load_config(self, config_file=CONFIG_FILE) -> dict:
124        """
125        Load configuration from a JSON file.
126        If the file does not exist, returns an empty dictionary.
127        """
128        try:
129            with open(config_file, "r") as file:
130                return json.load(file)
131        except FileNotFoundError:
132            return {}
133        
134    def save_config(self, config_file=CONFIG_FILE):
135        """
136        Save configuration to a JSON file.
137        """
138        with open(config_file, "w") as file:
139            json.dump(self.settings, file)
140
141    def setup_translation(self, domain=DOMAIN):
142        lang_code = self.current_language.get()
143        global _
144        localedir = get_resource_path("locales")
145        try:
146            lang = gettext.translation(domain, localedir=localedir, languages=[lang_code])
147            lang.install()
148            if DEBUG:
149                print_success(f"Translation loaded for {lang_code}.")
150            _ = lang.gettext
151        except Exception as e:
152            print_error(f"Translation not found for {lang_code}, falling back to default. Error: {e}")
153            gettext.install(domain, localedir=localedir)
154            _ = gettext.gettext
155
156    def create_widgets(self):
157        # Menu bar
158        menubar = tk.Menu(self)
159        self.config(menu=menubar)
160
161        # File menu
162        file_menu = tk.Menu(menubar, tearoff=0)
163        file_menu.add_command(label=_("Save Selected"), command=self.save_selected)
164        file_menu.add_command(label=_("Load from file"), command=self.load_from_file)
165        menubar.add_cascade(label=_("File"), menu=file_menu)
166
167        # Settings menu
168        settings_menu = tk.Menu(menubar, tearoff=0)
169        lang_menu = tk.Menu(settings_menu, tearoff=0)
170        for lang in self.lang_codes:
171            lang_menu.add_radiobutton(label=lang, variable=self.current_language, value=lang, command=self.change_language)
172        settings_menu.add_cascade(label=_("Language"), menu=lang_menu)
173        settings_menu.add_separator()
174        settings_menu.add_checkbutton(label=_("Remove successful from json"), variable=self.remove_successful_var)
175        settings_menu.add_checkbutton(label=_("Add back files with failed timeout"), variable=self.add_files_with_failed_timeout_var)
176        menubar.add_cascade(label=_("Settings"), menu=settings_menu)
177
178        # Zdroje menu
179        sources_menu = tk.Menu(menubar, tearoff=0)
180        for i, source in enumerate(SOURCES):
181            sources_menu.add_checkbutton(
182                label=source["name"],
183                variable=self.source_vars[i],
184                onvalue=True,
185                offvalue=False
186            )
187        menubar.add_cascade(label=_("Sources"), menu=sources_menu)
188
189
190        # Search frame
191        search_frame = ttk.Frame(self)
192        search_frame.pack(pady=5, padx=5, fill=tk.X)
193
194        self.search_label = ttk.Label(search_frame, text=_("Search:"))
195        self.search_label.pack(side=tk.LEFT, padx=5)
196
197        self.search_entry = ttk.Entry(search_frame)
198        self.search_entry.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)
199
200        # file type: show translated labels but keep internal key
201        # internal vars (hold keys used by search)
202        self.file_type_var = tk.StringVar(value="all")
203        self.search_type_var = tk.StringVar(value="relevance")
204        # display vars (hold translated label shown in OptionMenu)
205        self.file_type_display_var = tk.StringVar(value=_(self.file_type_var.get()))
206        self.search_type_display_var = tk.StringVar(value=_(self.search_type_var.get()))
207
208        # build OptionMenus using display vars; commands set both internal key and display label
209        self.file_type_menu = ttk.OptionMenu(search_frame, self.file_type_display_var, self.file_type_display_var.get())
210        menu = self.file_type_menu["menu"]
211        menu.delete(0, "end")
212        for key in Download_page_search.file_types.keys():
213            label = _(key)
214            menu.add_command(label=label, command=lambda k=key, l=label: (self.file_type_var.set(k), self.file_type_display_var.set(l)))
215        self.file_type_menu.pack(side=tk.LEFT, padx=5)
216
217        self.search_type_menu = ttk.OptionMenu(search_frame, self.search_type_display_var, self.search_type_display_var.get())
218        menu2 = self.search_type_menu["menu"]
219        menu2.delete(0, "end")
220        for key in Download_page_search.search_types.keys():
221            label = _(key)
222            menu2.add_command(label=label, command=lambda k=key, l=label: (self.search_type_var.set(k), self.search_type_display_var.set(l)))
223        self.search_type_menu.pack(side=tk.LEFT, padx=5)
224
225        self.max_results_label = ttk.Label(search_frame, text=_("Max Results:"))
226        self.max_results_label.pack(side=tk.LEFT, padx=5)
227
228        self.max_results_entry = ttk.Entry(search_frame, width=5)
229        self.max_results_entry.pack(side=tk.LEFT, padx=5)
230        self.max_results_entry.insert(0, "100")
231
232        self.search_button = ttk.Button(search_frame, text=_("Search"), command=self.start_search_thread)
233        self.search_button.pack(side=tk.LEFT, padx=5)
234
235        # Action frame
236        action_frame = ttk.Frame(self)
237        action_frame.pack(pady=5, padx=5, fill=tk.X)
238
239        self.select_all_button = ttk.Button(action_frame, text=_("Select/Deselect All"), command=self.toggle_select_all)
240        self.select_all_button.pack(side=tk.LEFT, padx=5)
241
242        self.clear_button = ttk.Button(action_frame, text=_("Clear All"), command=self.clear_all)
243        self.clear_button.pack(side=tk.LEFT, padx=5)
244
245        self.clear_not_selected_button = ttk.Button(action_frame, text=_("Clear Not Selected"), command=self.clear_not_selected)
246        self.clear_not_selected_button.pack(side=tk.LEFT, padx=5)
247
248        self.download_button = ttk.Button(action_frame, text=_("Download Selected"), command=self.start_download_thread)
249        self.download_button.pack(side=tk.LEFT, padx=5)
250
251        # Results frame
252        self.results_frame = ttk.Frame(self)
253        self.results_frame.pack(pady=10, fill=tk.BOTH, expand=True)
254
255        style = ttk.Style()
256        row_h = int(32 * self.scaling_factor)
257        style.configure("Treeview", rowheight=row_h)
258        default_size = int(10 * self.scaling_factor)
259        style.configure("Treeview", font=('TkDefaultFont', default_size))
260        style.configure("Treeview.Heading", font=('TkDefaultFont', default_size, 'bold'))
261
262        self.results_tree = ttk.Treeview(self.results_frame, columns=("check", "Title", "Size", "Source"), show="headings")
263        self.results_tree.heading("check", text=_("Select"), command=lambda: self.sort_treeview("check", False))
264        self.results_tree.heading("Title", text=_("Title"), command=lambda: self.sort_treeview("Title", False))
265        self.results_tree.heading("Size", text=_("Size"), command=lambda: self.sort_treeview("Size", False))
266        self.results_tree.heading("Source", text=_("Source"))
267        self.results_tree.column("check", width=10, anchor="center")
268        self.results_tree.column("Title", width=240)
269        self.results_tree.column("Size", width=20)
270        self.results_tree.column("Source", width=140)
271
272        # Scrollbar
273        scrollbar = ttk.Scrollbar(self.results_frame, orient="vertical", command=self.results_tree.yview)
274        self.results_tree.configure(yscrollcommand=scrollbar.set)
275        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
276
277        self.results_tree.pack(fill=tk.BOTH, expand=True)
278        self.results_tree.bind("<Double-1>", self.toggle_check)
279        # Right-click on Link column copies the download URL to clipboard (Windows: Button-3)
280        self.results_tree.bind("<Button-3>", self.on_right_click_copy_link)
281
282        # Log frame
283        self.log_frame = ttk.Frame(self)
284        self.log_frame.pack(pady=10, fill=tk.BOTH, expand=True)
285
286        self.log_text = tk.Text(self.log_frame, height=10, state=tk.DISABLED)
287        self.log_text.pack(fill=tk.BOTH, expand=True)
288
289        # map item iid (detail_url) -> checked(bool). Keeps state independent of row ordering.
290        self.checked_map = {}
291 
292        # Define tags for colored text
293        self.log_text.tag_config("info", foreground="blue")
294        self.log_text.tag_config("warning", foreground="orange")
295        self.log_text.tag_config("error", foreground="red")
296        self.log_text.tag_config("success", foreground="green")
297
298    def get_check_symbol(self, checked):
299        return "✓" if checked else "✗"
300 
301    def toggle_check(self, event):
302        sel = self.results_tree.selection()
303        if not sel:
304            return
305        item = sel[0]
306        current = self.checked_map.get(item, False)
307        new = not current
308        self.checked_map[item] = new
309        self.results_tree.item(item, values=(self.get_check_symbol(new), *self.results_tree.item(item)["values"][1:]))
310 
311    def toggle_select_all(self):
312        children = list(self.results_tree.get_children())
313        select_all = not all(self.checked_map.get(item, False) for item in children)
314        for item in children:
315            self.checked_map[item] = select_all
316            self.results_tree.item(item, values=(self.get_check_symbol(select_all), *self.results_tree.item(item)["values"][1:]))
317     
318     
319    def on_right_click_copy_link(self, event):
320        """
321        Right-click handler: if clicked cell is in the Source column, copy underlying detail URL to clipboard.
322        """
323        try:
324            region = self.results_tree.identify_region(event.x, event.y)
325            col = self.results_tree.identify_column(event.x)  # e.g. "#4" for 4th column
326            # Source is the 4th column (#4)
327            if region != "cell" or col != "#4":
328                return
329            # identify_row returns the item id (we store detail_url as iid)
330            row = self.results_tree.identify_row(event.y)
331            if not row:
332                return
333            # use iid (row) as the real detail_url
334            link = row
335            # copy to clipboard
336            self.clipboard_clear()
337            self.clipboard_append(link)
338            self.log(_("Link copied to clipboard: {}").format(link), "info")
339        except Exception as e:
340            self.log(_("Failed to copy link: {}").format(e), "error")
341
342    def start_search_thread(self):
343        """
344        Starts the search in a separate thread for each selected source.
345        Initializes a queue to collect results and starts processing the queue.
346        """
347        self.searching = True
348        self.result_queue = queue.Queue()
349        self.threads = []
350        self.link_2_files = []
351        self.max_results = int(self.max_results_entry.get())
352        prompt = self.search_entry.get()
353        file_type = self.file_type_var.get()
354        search_type = self.search_type_var.get()
355        selected_sources = [source["class"] for i, source in enumerate(SOURCES) if self.source_vars[i].get()]
356        self.stop_event = threading.Event() 
357
358        def search_source(source_class):
359            try:
360                results = source_class().search(prompt, file_type, search_type)
361                for r in results:
362                    if self.stop_event.is_set():
363                        break
364                    self.result_queue.put(r)
365            except Exception as e:
366                self.log(_("Error in source {}: {}").format(source_class.__name__, e), "error")
367
368        for source_class in selected_sources:
369            t = threading.Thread(target=search_source, args=(source_class,))
370            t.start()
371            self.threads.append(t)
372
373        self.log(_("Search initiated..."), "info", end="")
374        self.after(100, self.process_search_queue)
375
376    def process_search_queue(self):
377        """
378        Processes the result queue, adding unique results to the treeview.
379        Stops adding results if max_results is reached and sets the `stop_event`.
380        """
381        added = 0
382        while not self.result_queue.empty() and (not self.max_results or len(self.link_2_files) < self.max_results):
383            link_2_file = self.result_queue.get()
384            self.add_unique_to_results([link_2_file])
385            self.link_2_files.append(link_2_file)
386            self.log(".", "info", end="")
387            added += 1
388
389            # Pokud jsme dosáhli max_results, nastav stop_event
390            if self.max_results and len(self.link_2_files) >= self.max_results:
391                self.stop_event.set()
392
393        if (any(t.is_alive() for t in self.threads) or not self.result_queue.empty()) and not self.stop_event.is_set():
394            self.after(100, self.process_search_queue)
395        elif any(t.is_alive() for t in self.threads) or not self.result_queue.empty():
396            # Po dosažení max_results ještě necháme doběhnout frontu
397            self.after(100, self.process_search_queue)
398        else:
399            self.log(_("\nNumber of files found: {}").format(len(self.link_2_files)), "success")
400            self.searching = False
401
402    def start_download_thread(self):
403        threading.Thread(target=self.download_selected, daemon=True).start()
404    
405    def download_worker(self, q: queue.Queue, timeout: int, success_list: list, success_lock: threading.Lock):
406        """
407        Worker function to download files from the queue.
408        
409        Args:
410            q (queue.Queue): Queue containing Link_to_file objects to download.
411            timeout (int): Timeout between downloads.
412            success_list (list): Shared list to store successfully downloaded files.
413            success_lock (threading.Lock): Lock to synchronize access to success_list.
414        """
415        while not q.empty():
416            link_2_file = q.get()
417
418            # test if file exists
419            target_path = f"{download_folder}/{link_2_file.title}"
420            if os.path.exists(target_path):
421                self.log(_("File {} already exists.").format(link_2_file.title), "warning")
422                with success_lock:
423                    success_list.append(link_2_file)
424                continue
425
426            self.log(_("Downloading file: {} of size {}...").format(link_2_file.title, link_2_file.size), "info")
427
428            try:
429                link_2_file.download(download_folder)
430
431                file_size = os.path.getsize(target_path)
432                if link_2_file.source_class.test_downloaded_file(link_2_file, download_folder):
433                    with success_lock:
434                        success_list.append(link_2_file)
435                    self.log(_("File {} of size {} was downloaded.").format(link_2_file.title, size_int_2_string(file_size)), "success")
436                    self.remove_from_results([link_2_file])
437            except ValueError as e:
438                self.log(_("Error: {}").format(e), "error")
439                self.log(_("File {} was not downloaded correctly.").format(link_2_file.title), "error")
440                if os.path.exists(target_path):
441                    os.remove(target_path)
442                    self.log(_("File {} was removed.").format(link_2_file.title), "info")
443            except InsufficientTimeoutError as e:
444                self.log(_("Error: {}").format(e), "error")
445                self.log(_("File {} was not downloaded at all.").format(link_2_file.title), "error")
446                if os.path.exists(target_path):
447                    os.remove(target_path)
448                    self.log(_("File {} was removed.").format(link_2_file.title), "info")
449                if self.add_files_with_failed_timeout_var.get():
450                    q.put(link_2_file)
451                    self.log(_("File {} was added back to the list.").format(link_2_file.title), "info")
452            except Exception as e:
453                self.log(_("Error: {}").format(e), "error")
454                if os.path.exists(target_path):
455                    os.remove(target_path)
456                    self.log(_("File {} was removed.").format(link_2_file.title), "info")
457            
458            if not q.empty():
459                self.log(_("Waiting for {} seconds...").format(timeout), "info")
460                time.sleep(timeout)
461
462    def download_selected(self):
463        """
464        Downloads all selected `Link_to_file` objects using worker threads.
465
466        1. loads selected `Link_to_file` objects,
467        2. groups them by `source_class`,
468        3. starts a worker thread for each group to download files with appropriate timeout,
469        4. waits for all threads to complete,
470        5. removes successfully downloaded files from the results and JSON file if configured.
471
472        """
473        self.log(_("Download initiated..."), "info")
474
475        selected = self.get_selected_link_2_files()
476        if not selected:
477            self.log(_("No files selected for download."), "warning")
478            return
479
480        self.log(_("Number of files to download: {}").format(len(selected)), "info")
481
482        # Seskupit podle source_class
483        groups: dict = {}
484        for l in selected:
485            groups.setdefault(l.source_class, []).append(l)
486
487        threads = []
488        successfull_files: list = []
489        success_lock = threading.Lock()
490
491        for source_class, items in groups.items():
492            q = queue.Queue()
493            for it in items:
494                q.put(it)
495
496            # najít timeout pro daný zdroj
497            timeout = next((s["timeout"] for s in SOURCES if s["class"] == source_class), TIME_OUT)
498
499            t = threading.Thread(target=self.download_worker, args=(q, timeout, successfull_files, success_lock), daemon=True)
500            t.start()
501            threads.append(t)
502
503        # počkat na dokončení všech worker vláken
504        for t in threads:
505            t.join()
506
507        self.log(_("Downloaded files: {}").format(len(successfull_files)), "success")
508
509        if self.remove_successful_var.get():
510            self.log(_("Removing successful downloads from the list..."), "info")
511            remove_links_from_file(successfull_files, JSON_FILE)
512
513    def result_tree_2_link_2_files(self):
514        """
515        Yields Link_to_file objects from the results treeview.
516        """
517        for item in self.results_tree.get_children():
518            # item is iid == detail_url
519            detail_url = item
520            l2f = self.link_map.get(detail_url)
521            if l2f is not None:
522                yield l2f
523            else:
524                vals = self.results_tree.item(item)["values"]
525                title = vals[1] if len(vals) > 1 else detail_url
526                size = vals[2] if len(vals) > 2 else "unknown"
527                self.log(_("Warning: Link not found in map, creating new Link_to_file object."), "warning")
528                yield Link_to_file(title, detail_url, size, Download_page_search) # Fallback
529
530    def replace_results(self, link_2_files):
531        """
532        Replaces all items in the results treeview with new Link_to_file objects.
533        And updates the link_map accordingly.
534        """
535        self.results_tree.delete(*self.results_tree.get_children())
536        self.checked_map.clear()
537        self.link_map.clear()
538        for i, link_2_file in enumerate(link_2_files):
539            source_name = CLASS_NAME_MAP.get(link_2_file.source_class, getattr(link_2_file.source_class, "__name__", "Unknown"))
540            # store detail_url as iid so we can later retrieve the real link even if we display Source
541            self.results_tree.insert(
542                "", "end", iid=link_2_file.detail_url,
543                values=(self.get_check_symbol(False), link_2_file.title, link_2_file.size, source_name),
544            )
545            self.checked_map[link_2_file.detail_url] = False
546            self.link_map[link_2_file.detail_url] = link_2_file
547
548    def add_unique_to_results(self, link_2_files):
549        """
550        Adds only unique Link_to_file objects to the results treeview.
551        And updates the link_map accordingly.
552        """
553        existing_links = set(self.link_map.keys())
554        for link_2_file in link_2_files:
555            if link_2_file.detail_url not in existing_links:
556                source_name = CLASS_NAME_MAP.get(link_2_file.source_class, getattr(link_2_file.source_class, "__name__", "Unknown"))
557                self.results_tree.insert(
558                    "", "end", iid=link_2_file.detail_url,
559                    values=(self.get_check_symbol(False), link_2_file.title, link_2_file.size, source_name),
560                )
561                self.checked_map[link_2_file.detail_url] = False
562                self.link_map[link_2_file.detail_url] = link_2_file
563                existing_links.add(link_2_file.detail_url)
564
565    def remove_from_results(self, link_2_files):
566        links_to_remove = {l.detail_url for l in link_2_files}
567        for item in list(self.results_tree.get_children()):
568            detail_url = item
569            if detail_url in links_to_remove:
570                self.results_tree.delete(item)
571                self.link_map.pop(detail_url, None)
572                self.checked_map.pop(detail_url, None)
573
574    def get_selected_link_2_files(self) -> list[Link_to_file]:
575        """
576        Returns a list of Link_to_file objects corresponding to currently checked items in the results treeview.
577        If a selected link is missing from link_map, creates a safe fallback Link_to_file object.
578        """
579        selected_links = [item for item in self.results_tree.get_children() if self.checked_map.get(item, False)]
580 
581        result = []
582        for link in selected_links:
583            l2f = self.link_map.get(link)
584            if l2f is None:
585                # Fallback: create a minimal Link_to_file object if map is missing entry
586                # Use link as title and unknown size; Download_page_search as a neutral source_class
587                self.log(_("Warning: Selected link {} not found in map, creating fallback object.").format(link), "warning")
588                try:
589                    fallback = Link_to_file(link, link, "unknown", Download_page_search)
590                    result.append(fallback)
591                except Exception:
592                    # If construction fails, skip the entry
593                    self.log(_("Failed to create fallback for {}").format(link), "error")
594            else:
595                result.append(l2f)
596        return result
597
598    def save_selected(self):
599        """
600        Loads selected items from the results treeview.
601        Maps them to Link_to_file objects using link_map.
602        Saves the Link_to_file objects to JSON_FILE.
603        """
604        self.log(_("Saving selected items..."), "info")
605
606        link_2_files = self.get_selected_link_2_files()
607        save_links_to_file(link_2_files, JSON_FILE)
608
609        self.log(_("Saved items: {}").format(len(link_2_files)), "success")
610
611    def load_from_file(self):
612        self.log(_("Loading selected items..."), "info")
613        link_2_files = load_links_from_file(JSON_FILE)
614        self.replace_results(link_2_files) # automatically updates link_map
615        self.log(_("Loaded items: {}").format(len(link_2_files)), "success")
616
617    def clear_all(self):
618        """
619        Clears all items from the:
620         - results treeview,
621         - link_map.
622        """
623        self.results_tree.delete(*self.results_tree.get_children())
624        self.checked_map.clear()
625        self.link_map.clear()
626        self.log(_("Cleared all displayed files."), "info")
627 
628    def clear_not_selected(self):
629        # keep only items that are checked (based on checked_map)
630        items_to_keep = [(self.results_tree.item(item)["values"], item) for item in self.results_tree.get_children() if self.checked_map.get(item, False)]
631        self.results_tree.delete(*self.results_tree.get_children())
632        self.checked_map.clear()
633        for values, iid in items_to_keep:
634            self.results_tree.insert("", "end", iid=iid, values=values)
635            self.checked_map[iid] = True
636        self.log(_("Cleared not selected files."), "info")
637
638    def log(self, message, tag="info", end="\n"):
639        self.log_text.config(state=tk.NORMAL)
640        self.log_text.insert(tk.END, message + end, tag)
641        self.log_text.config(state=tk.DISABLED)
642        self.log_text.see(tk.END)
643
644    def sort_treeview(self, col, reverse):
645        items = [(self.results_tree.set(k, col), k) for k in self.results_tree.get_children('')]
646        if col == "Size":
647            items.sort(key=lambda t: size_string_2_bytes(t[0]), reverse=reverse)
648        elif col == "check":
649            # sort by checked state stored per-iid
650            items.sort(key=lambda t: self.checked_map.get(t[1], False), reverse=reverse)
651        else:
652            items.sort(reverse=reverse)
653        
654        for index, (val, k) in enumerate(items):
655            self.results_tree.move(k, '', index)
656        
657        self.results_tree.heading(col, command=lambda: self.sort_treeview(col, not reverse))
658
659    def change_language(self, *args):
660        self.setup_translation()
661        self.update_ui_texts()
662        self.settings["language"] = self.current_language.get()
663        self.save_config()
664
665    def update_remove_successful(self, *args):
666        self.settings["remove_successful"] = self.remove_successful_var.get()
667        self.save_config()
668    
669    def update_add_files_with_failed_timeout(self, *args):
670        self.settings["add_files_with_failed_timeout"] = self.add_files_with_failed_timeout_var.get()
671        self.save_config()
672
673    def update_ui_texts(self):
674        self.title(_("Universal Downloader"))
675
676        self.search_label.config(text=_("Search:"))
677        self.search_button.config(text=_("Search"))
678        self.max_results_label.config(text=_("Max Results:"))
679
680        self.download_button.config(text=_("Download Selected"))
681        self.clear_button.config(text=_("Clear All"))
682        self.clear_not_selected_button.config(text=_("Clear Not Selected"))
683        self.select_all_button.config(text=_("Select/Deselect All"))
684
685        self.results_tree.heading("check", text=_("Select"))
686        self.results_tree.heading("Title", text=_("Title"))
687        self.results_tree.heading("Size", text=_("Size"))
688        self.results_tree.heading("Source", text=_("Source"))
689        self._rebuild_type_menus()
690        self.log(_("Language changed to {}.").format(self.current_language.get()), "info")
691
692    def _rebuild_type_menus(self):
693        # rebuild file type menu
694        try:
695            menu = self.file_type_menu["menu"]
696            menu.delete(0, "end")
697            for key in Download_page_search.file_types.keys():
698                label = _(key)
699                menu.add_command(label=label, command=lambda k=key, l=label: (self.file_type_var.set(k), self.file_type_display_var.set(l)))
700            # update displayed label to translated value for current key
701            self.file_type_display_var.set(_(self.file_type_var.get()))
702        except Exception:
703            print_error("Error rebuilding {Blue}file type{NC} menus.")
704            pass
705
706        # rebuild search type menu
707        try:
708            menu2 = self.search_type_menu["menu"]
709            menu2.delete(0, "end")
710            for key in Download_page_search.search_types.keys():
711                label = _(key)
712                menu2.add_command(label=label, command=lambda k=key, l=label: (self.search_type_var.set(k), self.search_type_display_var.set(l)))
713            self.search_type_display_var.set(_(self.search_type_var.get()))
714        except Exception:
715            print_error("Error rebuilding {Blue}search type{NC} menus.")
716            pass
717
718def main():
719    if not os.path.exists(JSON_FILE):
720        open(JSON_FILE, 'w').close()
721        print_info(f"Created empty JSON file at {JSON_FILE}")
722    
723    if not os.path.exists(download_folder):
724        os.makedirs(download_folder)
725        print_info(f"Created download folder at {download_folder}")
726    
727    compile_mo_files()
728    localedir = get_resource_path("locales")
729    if not os.path.exists(os.path.join(localedir, "cs", "LC_MESSAGES", DOMAIN + ".mo")):
730        print_error("Translation file not found!")
731    
732    app = DownloaderGUI()
733    app.mainloop()
734
735if __name__ == "__main__":
736    parser = argparse.ArgumentParser(description="Download files from internet.")
737    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose mode.")
738    parser.add_argument("-D", "--debug", action="store_true", help="Debug mode.")
739    args = parser.parse_args()
740
741    main()