#!/usr/bin/python3
import argparse
import logging
import tkinter as tk
from tkinter import TclError, filedialog, ttk
from pathlib import Path
import os
import webbrowser
import subprocess
from functools import partial
from shared_libs.gitea import GiteaUpdate
from shared_libs.message import MessageDialog
from shared_libs.common_tools import (
    LogConfig,
    ConfigManager,
    ThemeManager,
    LxTools,
    Tooltip,
)
import sys
from file_and_dir_ensure import prepare_app_environment


class LogViewer(tk.Tk):
    def __init__(self, modul_name):
        super().__init__()

        self.my_tool_tip = None
        self.modul_name = modul_name  # Save the module name
        # from here the calls must be made with the module name
        _ = modul_name.AppConfig.setup_translations()

        self.x_width = modul_name.AppConfig.UI_CONFIG["window_size"][0]
        self.y_height = modul_name.AppConfig.UI_CONFIG["window_size"][1]
        # Set the window size
        self.geometry(f"{self.x_width}x{self.y_height}")
        self.minsize(
            modul_name.AppConfig.UI_CONFIG["window_size"][0],
            modul_name.AppConfig.UI_CONFIG["window_size"][1],
        )
        self.title(modul_name.AppConfig.UI_CONFIG["window_title2"])
        self.tk.call(
            "source", f"{modul_name.AppConfig.SYSTEM_PATHS['tcl_path']}/water.tcl"
        )
        ConfigManager.init(modul_name.AppConfig.SETTINGS_FILE)
        theme = ConfigManager.get("theme")
        ThemeManager.change_theme(self, theme)
        LxTools.center_window_cross_platform(self, self.x_width, self.y_height)
        self.createWidgets(modul_name, _)
        self.load_file(_, modul_name=modul_name)
        self.log_icon = tk.PhotoImage(file="/usr/share/icons/lx-icons/48/log.png")
        self.update_icon = tk.PhotoImage(
            file="/usr/share/icons/lx-icons/16/settings.png"
        )
        self.iconphoto(True, self.log_icon)
        self.grid_rowconfigure(0, weight=1)
        self.grid_rowconfigure(1, weight=1)
        self.grid_columnconfigure(0, weight=1)

        # StringVar-Variables initialization
        self.tooltip_state = tk.BooleanVar()
        # Get value from configuration
        state = ConfigManager.get("tooltips")
        # NOTE: ConfigManager.get("tooltips") can return either a boolean value or a string,
        # depending on whether the value was loaded from the file (bool) or the default value is used (string).
        # The expression 'lines[5].strip() == "True"' in ConfigManager.load() converts the string to a boolean.
        # Convert to boolean and set
        if isinstance(state, bool):
            # If it's already a boolean, use directly
            self.tooltip_state.set(state)
        else:
            # If it's a string or something else
            self.tooltip_state.set(str(state) == "True")

        self.tooltip_label = (
            tk.StringVar()
        )  # StringVar-Variable for tooltip label for view Disabled/Enabled
        self.tooltip_update_label(modul_name, _)
        self.update_label = tk.StringVar()  # StringVar-Variable for update label
        self.update_tooltip = (
            tk.StringVar()
        )  # StringVar-Variable for update tooltip please not remove!
        self.update_foreground = tk.StringVar(value="red")

        # Frame for Menu
        self.menu_frame = ttk.Frame(self)
        self.menu_frame.configure(relief="flat")
        if "'logview_app_config'" in f"{modul_name}".split():
            self.menu_frame.grid(column=0, row=0, columnspan=4, sticky=tk.NSEW)

        # App Menu
        self.version_lb = ttk.Label(self.menu_frame, text=modul_name.AppConfig.VERSION)
        self.version_lb.config(font=("Ubuntu", 11), foreground="#00c4ff")
        self.version_lb.grid(column=0, row=0, rowspan=4, padx=10, pady=10)

        Tooltip(
            self.version_lb,
            f"Version: {modul_name.AppConfig.VERSION[2:]}",
            self.tooltip_state,
        )
        self.load_button = ttk.Button(
            self.menu_frame,
            text=_("Load Log"),
            style="Toolbutton",
            command=lambda: self.directory_load(modul_name, _),
        )
        self.load_button.grid(column=1, row=0)
        self.options_btn = ttk.Menubutton(self.menu_frame, text=_("Options"))
        self.options_btn.grid(column=2, row=0)

        Tooltip(self.options_btn, modul_name.Msg.TTIP["settings"], self.tooltip_state)

        self.set_update = tk.IntVar()
        self.settings = tk.Menu(self, relief="flat")
        self.options_btn.configure(menu=self.settings, style="Toolbutton")
        self.settings.add_checkbutton(
            label=_("Disable Updates"),
            command=lambda: self.update_setting(self.set_update.get(), modul_name, _),
            variable=self.set_update,
        )

        self.updates_lb = ttk.Label(self.menu_frame, textvariable=self.update_label)
        self.updates_lb.grid(column=5, row=0, padx=10)
        self.updates_lb.grid_remove()
        self.update_label.trace_add("write", self.update_label_display)
        self.update_foreground.trace_add("write", self.update_label_display)
        res = GiteaUpdate.api_down(
            modul_name.AppConfig.UPDATE_URL,
            modul_name.AppConfig.VERSION,
            ConfigManager.get("updates"),
        )
        self.update_ui_for_update(res, modul_name, _)

        # Tooltip Menu
        self.settings.add_command(
            label=self.tooltip_label.get(),
            command=lambda: self.tooltips_toggle(modul_name, _),
        )
        # Label show dark or light
        self.theme_label = tk.StringVar()
        self.update_theme_label(modul_name, _)
        self.settings.add_command(
            label=self.theme_label.get(),
            command=lambda: self.on_theme_toggle(modul_name, _),
        )

        # About BTN Menu / Label
        self.about_btn = ttk.Button(
            self.menu_frame,
            text=_("About"),
            style="Toolbutton",
            command=lambda: self.about(modul_name, _),
        )
        self.about_btn.grid(column=3, row=0)
        self.readme = tk.Menu(self)
        # self.grid_rowconfigure(0, weight=)
        self.grid_rowconfigure(1, weight=25)
        self.grid_columnconfigure(0, weight=1)

    # Method that is called when the variable changes
    def update_label_display(self, *args):
        # Set the foreground color
        self.updates_lb.configure(foreground=self.update_foreground.get())

        # Show or hide the label based on whether it contains text
        if self.update_label.get():
            # Make sure the label is in the correct position every time it's shown
            self.updates_lb.grid(column=5, row=0, padx=10)
        else:
            self.updates_lb.grid_remove()

    def updater(self):
        """Start the lxtools_installer"""
        tmp_dir = Path("/tmp/lxtools")
        Path.mkdir(tmp_dir, exist_ok=True)
        os.chdir(tmp_dir)
        result = subprocess.run(["/usr/local/bin/lxtools_installer"], check=False)
        if result.returncode != 0:
            MessageDialog("error", result.stderr)

    # Update the labels based on the result
    def update_ui_for_update(self, res, modul_name, _):
        """Update UI elements based on an update check result"""
        # First, remove the update button if it exists to avoid conflicts
        if hasattr(self, "update_btn"):
            self.update_btn.grid_forget()
            delattr(self, "update_btn")

        if res == "False":
            self.set_update.set(value=1)
            self.update_label.set(_("Update search off"))
            self.update_tooltip.set(_("Updates you have disabled"))
            # Clear the foreground color as requested
            self.update_foreground.set("")
            # Set the tooltip for the label
            Tooltip(self.updates_lb, self.update_tooltip.get(), self.tooltip_state)

        elif res == "No Internet Connection!":
            self.update_label.set(_("No Server Connection!"))
            self.update_foreground.set("red")
            # Set the tooltip for "No Server Connection"
            Tooltip(
                self.updates_lb,
                _("Could not connect to update server"),
                self.tooltip_state,
            )

        elif res == "No Updates":
            self.update_label.set(_("No Updates"))
            self.update_tooltip.set(_("Congratulations! Wire-Py is up to date"))
            self.update_foreground.set("")
            # Set the tooltip for the label
            Tooltip(self.updates_lb, self.update_tooltip.get(), self.tooltip_state)

        else:
            self.set_update.set(value=0)

            # Clear the label text since we'll show the button instead
            self.update_label.set("")

            # Create the update button
            self.update_btn = ttk.Button(
                self.menu_frame,
                image=self.update_icon,
                style="Toolbutton",
                command=self.updater,
            )
            self.update_btn.grid(column=5, row=0, padx=0)
            Tooltip(
                self.update_btn, _("Click to install new version"), self.tooltip_state
            )

    @staticmethod
    def about(modul_name, _) -> None:
        """
        a tk.Toplevel window
        """
        msg_t = _(
            "Logviewer a simple Gui for View Logfiles.\n\n"
            "Logviewer is open source software written in Python.\n\n"
            "Email: polunga40@unity-mail.de also likes for donation.\n\n"
            "Use without warranty!\n"
        )

        MessageDialog(
            "info",
            text=msg_t,
            buttons=["OK", "Go to Logviewer"],
            commands=[
                None,  # Default on "OK"
                partial(webbrowser.open, "https://git.ilunix.de/punix/shared_libs"),
            ],
            icon=modul_name.AppConfig.IMAGE_PATHS["icon_log"],
            title="Logviewer",
        )

    def update_setting(self, update_res, modul_name, _) -> None:
        """write off or on in file
        Args:
            update_res (int): argument that is passed contains 0 or 1
        """
        if update_res == 1:
            # Disable updates
            ConfigManager.set("updates", "off")
            # When updates are disabled, we know the result should be "False"
            self.update_ui_for_update("False", modul_name, _)
        else:
            # Enable updates
            ConfigManager.set("updates", "on")
            # When enabling updates, we need to actually check for updates
            try:
                # Force a fresh check by passing "on" as the update setting
                res = GiteaUpdate.api_down(
                    modul_name.AppConfig.UPDATE_URL, modul_name.AppConfig.VERSION, "on"
                )

                # Make sure the UI is updated regardless of the previous state
                if hasattr(self, "update_btn"):
                    self.update_btn.grid_forget()
                if hasattr(self, "updates_lb"):
                    self.updates_lb.grid_forget()

                # Now update the UI with the fresh result
                self.update_ui_for_update(res, modul_name, _)
            except Exception as e:
                logging.error(f"Error checking for updates: {e}")
                # Fallback to a default message if there's an error
                self.update_ui_for_update("No Internet Connection!", modul_name, _)

    def tooltip_update_label(self, modul_name, _) -> None:
        """Updates the tooltip menu label based on the current tooltip status"""
        # Set the menu text based on the current status
        if self.tooltip_state.get():
            # If tooltips are enabled, the menu option should be to disable them
            self.tooltip_label.set(_("Disable Tooltips"))
        else:
            # If tooltips are disabled, the menu option should be to enable them
            self.tooltip_label.set(_("Enable Tooltips"))

    def tooltips_toggle(self, modul_name, _):
        """
        Toggles the visibility of tooltips (on/off) and updates
        the corresponding menu label. Inverts the current tooltip state
        (`self.tooltip_state`), saves the new value in the configuration,
        and applies the change immediately. Updates the menu entry's label to
        reflect the new tooltip status (e.g., "Tooltips: On" or "Tooltips: Off").
        """
        # Toggle the boolean state
        new_bool_state = not self.tooltip_state.get()
        # Save the converted value in the configuration
        ConfigManager.set("tooltips", str(new_bool_state))
        # Update the tooltip_state variable for immediate effect
        self.tooltip_state.set(new_bool_state)

        # Update the menu label
        self.tooltip_update_label(modul_name, _)

        # Update the menu entry - find the correct index
        # This assumes it's the third item (index 2) in your menu
        self.settings.entryconfigure(1, label=self.tooltip_label.get())

    def update_theme_label(self, modul_name, _) -> None:
        """Update the theme label based on the current theme"""
        current_theme = ConfigManager.get("theme")
        if current_theme == "light":
            self.theme_label.set(_("Dark"))
        else:
            self.theme_label.set(_("Light"))

    def on_theme_toggle(self, modul_name, _) -> None:
        """Toggle between light and dark theme"""
        current_theme = ConfigManager.get("theme")
        new_theme = "dark" if current_theme == "light" else "light"
        ThemeManager.change_theme(self, new_theme, new_theme)
        self.update_theme_label(modul_name, _)  # Update the theme label
        # Update Menulfield
        self.settings.entryconfigure(2, label=self.theme_label.get())

    def createWidgets(self, modul_name, _):

        text_frame = ttk.Frame(self)
        text_frame.grid(row=1, column=0, padx=5, pady=5, sticky=tk.NSEW)
        text_frame.rowconfigure(0, weight=3)
        text_frame.columnconfigure(0, weight=1)
        next_frame = ttk.Frame(self)
        next_frame.grid(row=2, column=0, sticky=tk.NSEW)
        next_frame.rowconfigure(2, weight=1)
        next_frame.columnconfigure(1, weight=1)
        # Create a Text widget for displaying the log file
        self.text_area = tk.Text(
            text_frame, wrap=tk.WORD, padx=5, pady=5, relief="flat"
        )
        self.text_area.grid(row=0, column=0, sticky=tk.NSEW)
        self.text_area.tag_configure(
            "found-tag", foreground="yellow", background="green"
        )
        # Create a vertical scrollbar for the Text widget
        v_scrollbar = ttk.Scrollbar(
            text_frame, orient="vertical", command=self.text_area.yview
        )
        v_scrollbar.grid(row=0, column=1, sticky=tk.NS)
        self.text_area.configure(yscrollcommand=v_scrollbar.set)

        self._entry = ttk.Entry(next_frame)
        self._entry.bind("<Return>", lambda e: self._onFind())
        self._entry.grid(row=0, column=1, padx=5, sticky=tk.EW)
        # Add a context menu to the Text widget
        self.context_menu = tk.Menu(self, tearoff=0)
        self.context_menu.add_command(label=_("Copy"), command=self.copy_text)
        self.context_menu.add_command(label=_("Paste"), command=self.paste_into_entry)
        self.text_area.bind("<Button-3>", self.show_context_menu)
        self._entry.bind("<Button-3>", self.show_context_menu)

        search_button = ttk.Button(next_frame, text=_("Search"), command=self._onFind)
        search_button.grid(row=0, column=0, padx=5, pady=5, sticky=tk.EW)

        delete_button = ttk.Button(
            next_frame, text=_("Delete_Log"), command=self.delete_file
        )
        delete_button.grid(row=0, column=2, padx=5, pady=5, sticky=tk.EW)

    def show_text_menu(self, event):
        try:
            self.configure.tk_popup(event.x_root, event.y_root)
        finally:
            self.context_menu.grab_release()

    def copy_text(self):

        try:
            selected_text = self.text_area.selection_get()
            self.clipboard_clear()
            self.clipboard_append(selected_text)
        except tk.TclError:
            # No Text selected
            pass

    def show_context_menu(self, event):
        try:
            self.context_menu.tk_popup(event.x_root, event.y_root)
        finally:
            self.context_menu.grab_release()

    def paste_into_entry(self):
        try:
            text = self.clipboard_get()
            self._entry.delete(0, tk.END)
            self._entry.insert(tk.END, text)
        except tk.TclError:
            # No Text on Clipboard
            pass

    def _onFind(self):
        searchText = self._entry.get()
        if len(searchText) == 0:
            return

        # Set the search start position to the last found position (initial value: "1.0")
        start_pos = self.last_search_pos if hasattr(self, "last_search_pos") else "1.0"

        var = tk.IntVar()
        foundIndex = self.text_area.search(
            searchText,
            start_pos,
            stopindex=tk.END,
            nocase=tk.YES,
            count=var,
            regexp=tk.YES,
        )

        if not foundIndex:
            # No further entry found, reset to the beginning
            self.last_search_pos = "1.0"
            return

        count = var.get()
        lastIndex = self.text_area.index(f"{foundIndex} + {count}c")

        # Remove and reapply highlighting
        self.text_area.tag_remove("found-tag", "1.0", tk.END)
        self.text_area.tag_add("found-tag", foundIndex, lastIndex)

        # Update the start position for the next search
        self.last_search_pos = lastIndex
        self.text_area.see(foundIndex)

    def delete_file(self, modul_name):
        Path.unlink(modul_name.AppConfig.LOG_FILE_PATH)
        modul_name.AppConfig.ensure_log()

    def load_file(self, _, modul_name):

        try:
            if not modul_name.AppConfig.LOG_FILE_PATH:
                return

            with open(
                modul_name.AppConfig.LOG_FILE_PATH, "r", encoding="utf-8"
            ) as file:
                self.text_area.delete(1.0, tk.END)
                self.text_area.insert(tk.END, file.read())
        except Exception as e:
            logging.error(_(f"A mistake occurred: {str(e)}"))
            MessageDialog("error", _(f"A mistake occurred:\n{str(e)}\n"))

    def directory_load(self, modul_name, _):

        filepath = filedialog.askopenfilename(
            initialdir=f"{Path.home() / ".local/share/lxlogs/"}",
            title="Select a Logfile File",
            filetypes=[("Logfiles", "*.log")],
        )

        try:
            with open(filepath, "r", encoding="utf-8") as file:
                self.text_area.delete(1.0, tk.END)
                self.text_area.insert(tk.END, file.read())
        except (IsADirectoryError, TypeError, FileNotFoundError):
            print("File load: abort by user...")
        except Exception as e:
            logging.error(_(f"A mistake occurred: {e}"))
            MessageDialog("error", _(f"A mistake occurred:\n{e}\n"))


def main():

    # Create an ArgumentParser object
    parser = argparse.ArgumentParser(
        description="LogViewer with optional module loading."
    )
    parser.add_argument(
        "--modul",
        type=str,
        default="logview_app_config",
        help="Give the name of the module to load.",
    )
    args = parser.parse_args()
    import importlib

    try:
        modul = importlib.import_module(args.modul)
    except ModuleNotFoundError:
        print(f"Modul '{args.modul}' not found")
        print("For help use logviewer -h")
        sys.exit(1)
    except Exception as e:
        print(f"Error load Modul: {str(e)}")
        sys.exit(1)

    prepare_app_environment()
    app = LogViewer(modul)
    LogConfig.logger(ConfigManager.get("logfile"))
    """
    the hidden files are hidden in Filedialog
    """
    try:
        app.tk.call("tk_getOpenFile", "-foobarbaz")
    except TclError:
        pass
    app.tk.call("set", "::tk::dialog::file::showHiddenBtn", "1")
    app.tk.call("set", "::tk::dialog::file::showHiddenVar", "0")
    app.mainloop()


if __name__ == "__main__":
    main()