# Copyright 2025 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import re
import sys
import tkinter as tk
import webbrowser
from tkinter import messagebox as mb
from tkinter import ttk
from typing import Any

import cli
import data_structure
import util


class GUI:
    def __init__(self) -> None:
        self.cli: cli.CLI | None = None

    def inform(self, out: util.Outputs) -> None:
        if not self.cli:
            self.cli = cli.CLI()
        self.cli.inform(out)

    def test_list(self, tests: data_structure.Tests) -> None:
        GUIWithTests(tests).run()

    def bail(self, failure_message: str) -> None:
        print(failure_message)
        sys.exit(1)


class GUIWithTests:
    def __init__(self, tests: data_structure.Tests) -> None:
        self.tests = tests
        self.cli: cli.CLI | None = None
        self.unsaved = False
        self.window = Window()
        self.tree = Tree(self)
        self.edit_pane = EditPane(self, self.tree)
        self.edit_pane.display("Select a test case")
        self.control_pane = ControlPane(self)
        self.tree.fill(self.select_test_suites())
        self.window.window.bind("<Control-s>", self.save)
        self.window.window.bind("<Control-q>", self.try_quit)

    def save(self, event: Any = None) -> None:
        self.tests.save()
        self.unsaved = False

    def run(self) -> None:
        self.window.mainloop()

    def select_test_suites(
        self, filter: str = "", disabled_only: bool = False
    ) -> list[data_structure.TestSuite]:
        test_list = self.tests.tests
        if filter == "" and not disabled_only:
            return test_list
        filtered_suites: list[data_structure.TestSuite] = []
        for t in test_list:
            if filter in t.compact_name and not disabled_only:
                filtered_suites.append(t)
            else:
                filtered_cases = []
                for c in t.cases:
                    if filter in c.name and not (
                        disabled_only and not c.disabled
                    ):
                        filtered_cases.append(c)
                if filtered_cases:
                    filtered_suites.append(
                        data_structure.TestSuite(
                            name=t.name, cases=filtered_cases
                        )
                    )
        return filtered_suites

    def set_unsaved(self) -> None:
        self.unsaved = True

    def try_quit(self, _: Any = None) -> None:
        if self.unsaved:
            response = mb.askyesnocancel(
                "Unsaved changes!",
                "Do you want to save before quitting?",
                default=mb.YES,
                icon=mb.QUESTION,
            )
            if response is None:
                return
            if response:
                self.save()
        sys.exit(0)

    def filter_tree(self, filter_string: str, disabled_only: bool) -> None:
        self.tree.fill(self.select_test_suites(filter_string, disabled_only))


DISPLAY_DISABLED = "  Disabled"
DISPLAY_ENABLED = "        -"


class Tree:
    def __init__(self, state: GUIWithTests) -> None:
        self.state = state
        self.cases_lookup: dict[str, data_structure.TestCase] = {}
        t = ttk.Treeview(columns=("disabled", "bug"))
        self.tree = t
        t.heading("#0", text="Name")
        t.heading("disabled", text="Disabled")
        t.heading("bug", text="Bug")
        t.column("#0", width=300)
        t.column("disabled", width=80, stretch=tk.NO)
        t.column("bug", width=140)
        t.bind("<<TreeviewSelect>>", self.selected)
        t.pack(fill=tk.BOTH, expand=True)

    def fill(self, tests: list[data_structure.TestSuite]) -> None:
        for item in self.tree.get_children():
            self.tree.delete(item)

        self.cases_lookup = {}
        for t in tests:
            t_tkid = self.tree.insert("", tk.END, text=t.compact_name)
            self.tree.item(t_tkid, open=True)
            for c in t.cases:
                case_id = self.tree.insert(
                    t_tkid,
                    tk.END,
                    text=c.name,
                    values=(self.disabled_string(c.disabled), c.bug),
                )
                self.cases_lookup[case_id] = c

    def selected_name_and_values(self) -> tuple[str, Any]:
        item_and_foo = self.tree.selection()
        if len(item_and_foo) != 1:
            return "", []
        item = item_and_foo[0]
        name = self.tree.item(item, "text")
        values = self.tree.item(item, "values")
        return name, values

    def selected(self, _: Any) -> None:
        self.tree.after_idle(self.deferred_selected)

    def deferred_selected(self) -> None:
        name, values = self.selected_name_and_values()
        if len(values) != 2:
            self.state.edit_pane.display(name)
        else:
            self.state.edit_pane.edit_tree_selection()

    def edit_values(self) -> tuple[str, bool, str]:
        name, values = self.selected_name_and_values()
        if len(values) != 2:
            return name, False, ""
        disabled_string, bug = values
        parent_item = self.tree.parent(self.tree.selection()[0])
        parent_name = self.tree.item(parent_item, "text")
        return f"{parent_name}:{name}", disabled_string == DISPLAY_DISABLED, bug

    def update(self, disabled: bool, bug: str) -> None:
        item = self.tree.selection()[0]
        self.tree.item(item, values=(self.disabled_string(disabled), bug))
        case = self.cases_lookup[item]
        case.disabled = disabled
        case.bug = bug
        self.state.set_unsaved()

    def disabled_string(self, disabled: bool) -> str:
        return DISPLAY_DISABLED if disabled else DISPLAY_ENABLED


class EditPane:
    def __init__(self, state: GUIWithTests, tree: Tree) -> None:
        self.frame = ttk.Frame(state.window.window)
        # subframe holds the 2nd line of the EditPane with several widgets in it.
        self.subframe = ttk.Frame(self.frame)
        self.disable_widget_actions = False
        self.label_contents = tk.StringVar(value="")
        self.label = ttk.Label(self.frame, textvariable=self.label_contents)
        # We want label above subframe
        self.label.pack(side="top", anchor="w")
        self.checkbox_value = tk.BooleanVar(value=False)
        self.checkbox = ttk.Checkbutton(
            self.subframe,
            text="Disable?",
            variable=self.checkbox_value,
            onvalue=True,
            offvalue=False,
            command=self.update,
        )
        self.checkbox.grid(row=0, column=0, padx=20, sticky="w")
        self.b = ttk.Label(self.subframe, text="Bug:")
        self.b.grid(row=0, column=1, padx=(20, 0), sticky="w")
        self.edit_value = tk.StringVar(value="")
        self.editor = ttk.Entry(
            self.subframe, textvariable=self.edit_value, width=40
        )
        self.editor.grid(row=0, column=2, padx=(0, 20), sticky="ew")
        self.edit_value.trace_add("write", self.update)
        self.clickable_url = ttk.Label(self.subframe, text="")
        self.clickable_url.grid(row=0, column=3, sticky="w")
        self.subframe.pack(
            side="bottom", fill=tk.X, expand=False, anchor="w", padx=20, pady=20
        )
        self.frame.pack(
            side="bottom", fill=tk.X, expand=False, anchor="w", padx=20, pady=20
        )
        self.tree = tree
        self.editing = False

    def update(self, _1: Any = None, _2: Any = None, _3: Any = None) -> None:
        if self.editing and not self.disable_widget_actions:
            bug = self.edit_value.get()
            self.update_clickable_url(bug)
            self.tree.update(self.checkbox_value.get(), bug)

    def done_with_programmatic_change(self) -> None:
        """Start treating UI updates as user actions.

        The program should not call this to balance
        start_programmatic_change(). Instead, start_programmatic_change() will
        queue this up to be called after Tkinter has drained all the events
        associated with the programmatic change."""

        self.disable_widget_actions = False

    def start_programmatic_change(self) -> None:
        """Don't treat UI updates as user actions.

        This is needed because Tkinter processes events in a strange order, and
        a checkbox may still be False after I've told it to be True. If I display
        a new test that's disabled, and the previous test was not disabled, then
        setting the checkbox to disabled might cause an update() call on the tree,
        which would check the checkbox and find disabled=False still.

        So this function should be called when the program is modifying the UI
        values. It will queue up setting disable_widget_actions to False after
        all the event-loop stuff has finished."""

        self.disable_widget_actions = True
        self.frame.after_idle(self.done_with_programmatic_change)

    def update_clickable_url(self, bug: str | None) -> None:
        def open_url_in_browser(url: str) -> None:
            try:
                webbrowser.open_new_tab(url)
            except webbrowser.Error as e:
                print(f"Could not open URL: {e}")

        if bug is not None:
            bug_text = re.search(r"\bb/(\d+)\b", bug)
            if bug_text:
                url = f"fxbug.dev/{bug_text.group(1)}"
                self.clickable_url.config(
                    text=url, foreground="blue", cursor="hand2"
                )
                # Python footgun: Beware of capturing the wrong version of the
                # variable in the lambda. In this case, it's OK to use
                # the latest, but if I were putting up several different
                # URLs I'd want to do something like:
                #   lambda event, bound_url_value=f"https://{url}": \
                #       open_url_in_browser(bound_url_value)
                self.clickable_url.bind(
                    "<Button-1>",
                    lambda event: open_url_in_browser(f"https://{url}"),
                )
                return
        self.clickable_url.config(text="", cursor="")
        self.clickable_url.unbind("<Button-1>")

    def display(self, name: str) -> None:
        self.start_programmatic_change()
        self.update_clickable_url(None)
        self.editing = False
        self.label_contents.set(name)
        self.checkbox.config(state="disabled")
        self.editor.config(state="disabled")
        self.b.config(foreground="gray")

    def edit_tree_selection(self) -> None:
        self.start_programmatic_change()
        text, disabled, bug = self.tree.edit_values()
        self.update_clickable_url(bug)
        self.label_contents.set(text)
        self.edit_value.set(bug)
        self.checkbox_value.set(disabled)
        self.checkbox.config(state="normal")
        self.editor.config(state="normal")
        self.b.config(foreground="black")
        self.editing = True


class ControlPane:
    def __init__(self, state: GUIWithTests) -> None:
        self.state = state
        self.frame = ttk.Frame(state.window.window)
        self.filter_label = ttk.Label(self.frame, text="Filter:")
        self.filter_label.pack(side="left", padx=(20, 0))
        self.filter_value = tk.StringVar(value="")
        self.filter_entry = ttk.Entry(
            self.frame, textvariable=self.filter_value
        )
        self.filter_entry.pack(side="left", padx=(0, 20))
        self.filter_value.trace_add("write", self.update)
        self.checkbox_value = tk.BooleanVar(value=False)
        self.checkbox = ttk.Checkbutton(
            self.frame,
            text="Disabled Only",
            variable=self.checkbox_value,
            onvalue=True,
            offvalue=False,
            command=self.update,
        )
        self.checkbox.pack(side="left", padx=20)
        self.save_button = ttk.Button(
            self.frame, text="Save ^S", command=self.state.save
        )
        self.save_button.pack(side="left", padx=20)
        self.quit_button = ttk.Button(
            self.frame, text="Quit ^Q", command=state.try_quit
        )
        self.quit_button.pack(side="left", padx=20)
        self.frame.pack(side="bottom", padx=20, pady=20)

    def update(self, *_) -> None:  # type: ignore
        self.state.filter_tree(
            self.filter_value.get(), self.checkbox_value.get()
        )


class Window:
    def __init__(self) -> None:
        w = tk.Tk()
        w.title("CTF Test Disabler")
        w.geometry("1000x600")
        w.update_idletasks()
        # w.geometry(f"800x{w.winfo_reqheight()}")
        self.window = w

    def mainloop(self) -> None:
        self.window.mainloop()