# Standard library imports
from datetime import datetime

# Fabric imports
from fabric.utils import get_relative_path
from fabric.widgets.box import Box
from fabric.widgets.button import Button
from fabric.widgets.entry import Entry
from fabric.widgets.label import Label
from fabric.widgets.scrolledwindow import ScrolledWindow
from fabric.widgets.svg import Svg
from gi.repository import GLib

# Local imports
from services.todo import todo_service
from widgets.mousecapture import MouseCapture
from widgets.wayland import WaylandWindow as Window


class TodoItem(Box):
    """Individual todo item widget"""

    def __init__(self, todo_data, todo_list_widget, **kwargs):
        self.todo_data = todo_data
        self.todo_list_widget = todo_list_widget
        self.editing = False

        super().__init__(
            name="todo-item",
            orientation="h",
            spacing=8,
            style_classes=["menu"],
            **kwargs,
        )

        self._build_ui()

    def _build_ui(self):
        """Build the todo item UI"""
        # Checkbox for completion - using SVG icons
        checkbox_icon = (
            "checkbox-check.svg"
            if self.todo_data["completed"]
            else "checkbox-uncheck.svg"
        )
        self.checkbox_icon = Svg(
            name="todo-checkbox-icon",
            size=24,
            svg_file=get_relative_path(
                "../../config/assets/icons/todo/" + checkbox_icon
            ),
        )
        self.checkbox = Button(
            name="todo-checkbox",
            child=self.checkbox_icon,
            on_clicked=self._toggle_completion,
        )

        # Todo text (can be converted to entry for editing)
        text_content = self.todo_data["text"]
        if self.todo_data["completed"]:
            text_content = f"<s>{text_content}</s>"

        self.text_label = Label(
            markup=text_content,
            name="todo-text",
            h_align="start",
            h_expand=True,
            line_wrap="word-char",
            style_classes=(
                ["title-widget"]
                if not self.todo_data["completed"]
                else ["status-label"]
            ),
        )

        # Date/time label
        created_at = datetime.fromisoformat(self.todo_data["created_at"])
        date_text = created_at.strftime("%b %d, %Y at %I:%M %p")

        self.date_label = Label(
            label=date_text,
            name="todo-date",
            h_align="start",
            style_classes=["todo-date-text"],
        )

        self.text_entry = Entry(
            name="todo-text-entry",
            text=self.todo_data["text"],
            h_expand=True,
            visible=False,
        )
        self.text_entry.connect("activate", self._save_edit)

        # Priority indicator
        # priority_symbols = {"high": "🔴", "medium": "🟡", "low": "🟢"}
        #
        # self.priority_label = Label(
        #     label=priority_symbols.get(self.todo_data["priority"], "🟡"),
        #     name="todo-priority-label",
        # )
        # self.priority_button = Button(
        #     name="todo-priority",
        #     size=(20, 20),
        #     child=self.priority_label,
        #     on_clicked=self._cycle_priority,
        # )
        #
        # Edit button - using SVG icon
        self.edit_icon = Svg(
            name="todo-edit-icon",
            size=12,
            svg_file=get_relative_path("../../config/assets/icons/todo/edit.svg"),
        )
        self.edit_button = Button(
            name="todo-edit",
            child=self.edit_icon,
            on_clicked=self._start_edit,
        )

        # Delete button - using SVG icon
        self.delete_icon = Svg(
            name="todo-delete-icon",
            size=12,
            svg_file=get_relative_path(
                "../../config/assets/icons/todo/delete-symbolic.svg"
            ),
        )
        self.delete_button = Button(
            name="todo-delete",
            child=self.delete_icon,
            on_clicked=self._delete_todo,
        )

        # Text container that switches between label and entry
        self.text_container = Box(
            orientation="v",
            h_expand=True,
            children=[
                Box(orientation="h", children=[self.text_label]),
                self.date_label,
            ],
        )

        self.children = [
            self.checkbox,
            self.text_container,
            # self.priority_button,
            self.edit_button,
            self.delete_button,
        ]

    def _toggle_completion(self, *_):
        """Toggle todo completion status"""
        todo_service.toggle_todo(self.todo_data["id"])

    def _cycle_priority(self, *_):
        """Cycle through priority levels"""
        priorities = ["low", "medium", "high"]
        current_index = priorities.index(self.todo_data["priority"])
        new_priority = priorities[(current_index + 1) % len(priorities)]
        todo_service.set_priority(self.todo_data["id"], new_priority)

    def _start_edit(self, *_):
        """Start editing the todo text"""
        if self.editing:
            return

        self.editing = True
        self.text_container.children = [
            Box(orientation="h", children=[self.text_entry]),
            self.date_label,
        ]
        self.text_entry.set_visible(True)
        self.text_entry.grab_focus()
        self.text_entry.set_position(-1)  # Move cursor to end

    def _save_edit(self, *_):
        """Save the edited todo text"""
        if not self.editing:
            return

        new_text = self.text_entry.get_text().strip()
        if new_text:
            todo_service.edit_todo(self.todo_data["id"], new_text)

        self._cancel_edit()

    def _cancel_edit(self):
        """Cancel editing and revert to label"""
        self.editing = False
        self.text_container.children = [
            Box(orientation="h", children=[self.text_label]),
            self.date_label,
        ]
        self.text_entry.set_visible(False)

    def _delete_todo(self, *_):
        """Delete this todo"""
        todo_service.delete_todo(self.todo_data["id"])

    def update_from_data(self, todo_data):
        """Update the widget from new todo data"""
        self.todo_data = todo_data

        # Update checkbox icon by recreating it
        checkbox_icon = (
            "checkbox-check.svg" if todo_data["completed"] else "checkbox-uncheck.svg"
        )
        new_checkbox_icon = Svg(
            name="todo-checkbox-icon",
            size=20,
            svg_file=get_relative_path(
                "../../config/assets/icons/todo/" + checkbox_icon
            ),
        )
        self.checkbox.set_child(new_checkbox_icon)
        self.checkbox_icon = new_checkbox_icon

        # Update text and styling with markup
        text_content = todo_data["text"]
        if todo_data["completed"]:
            text_content = f"<s>{text_content}</s>"

        self.text_label.set_markup(text_content)
        self.text_label.style_classes = (
            ["title-widget"] if not todo_data["completed"] else ["status-label"]
        )

        # Update date/time
        created_at = datetime.fromisoformat(todo_data["created_at"])
        date_text = created_at.strftime("%b %d, %Y at %I:%M %p")
        self.date_label.set_label(date_text)


class TodoListWidget(Window):
    """Main todo list widget window"""

    def __init__(self, **kwargs):
        super().__init__(
            title="modus-todo",
            anchor="top right",
            margin="2px 10px 0px 0px",
            exclusivity="auto",
            keyboard_mode="on-demand",
            name="todo-list-window",
            visible=False,  # Back to hidden by default
            **kwargs,
        )

        self.todo_items = {}  # Maps todo IDs to TodoItem widgets

        # Register callback with todo service
        todo_service.add_callback(self._on_todo_event)

        self._build_ui()
        self._refresh_todos()

        # Add keybinding for escape
        self.add_keybinding("Escape", self.hide_todo_list)

    def _build_ui(self):
        """Build the main UI"""
        # Header with title and stats
        self.stats_label = Label(
            label="",
            name="todo-stats",
            style_classes=["status-label"],
            h_align="start",
        )

        self.header = Box(
            name="todo-header",
            orientation="v",
            children=[
                Label(
                    label="Todo List",
                    name="todo-title",
                    style_classes=["title"],
                    h_align="start",
                ),
                self.stats_label,
            ],
        )

        # Add new todo section
        self.new_todo_entry = Entry(
            name="new-todo-entry",
            placeholder_text="Add a new task...",
            h_expand=True,
        )
        self.new_todo_entry.connect("activate", self._add_todo)

        # Add button - using SVG icon
        self.add_icon = Svg(
            name="add-todo-icon",
            size=12,
            svg_file=get_relative_path(
                "../../config/assets/icons/todo/plus-symbolic.svg"
            ),
        )
        self.add_button = Button(
            name="add-todo-button",
            child=self.add_icon,
            on_clicked=self._add_todo,
        )

        self.add_section = Box(
            name="todo-add-section",
            orientation="h",
            spacing=8,
            style_classes=["menu"],
            children=[
                self.new_todo_entry,
                self.add_button,
            ],
        )

        # Todo items container
        self.todos_container = Box(
            name="todos-container",
            orientation="v",
            spacing=4,
        )

        # Scrolled window for todos
        self.scrolled = ScrolledWindow(
            name="todos-scrolled",
            min_content_height=300,
            max_content_height=500,
            min_content_width=400,
            child=self.todos_container,
            policy="automatic",
            v_expand=True,  # Allow vertical expansion
        )

        # Clear completed button
        self.clear_button = Button(
            name="clear-completed-button",
            label="Clear Completed",
            style_classes=["status-label"],
            on_clicked=self._clear_completed,
        )

        # Main container
        self.main_container = Box(
            name="todo-main-container",
            orientation="v",
            spacing=8,
            style_classes=["menu"],
            children=[
                self.header,
                self.add_section,
                self.scrolled,
                self.clear_button,
            ],
        )

        self.children = [self.main_container]

    def _add_todo(self, *_):
        """Add a new todo"""
        text = self.new_todo_entry.get_text().strip()
        if text:
            todo_service.add_todo(text)
            self.new_todo_entry.set_text("")

    def _clear_completed(self, *_):
        """Clear all completed todos"""
        todo_service.clear_completed()

    def _on_todo_event(self, event_type, data=None):
        """Handle todo service events via callback"""
        if event_type == "todos-changed":
            GLib.idle_add(self._refresh_todos)
        elif event_type == "todo-added":
            GLib.idle_add(self._refresh_todos)
        elif event_type == "todo-deleted":
            GLib.idle_add(self._refresh_todos)
        elif event_type in ["todo-toggled", "todo-edited", "todo-priority-changed"]:
            if data and data["id"] in self.todo_items:
                GLib.idle_add(
                    lambda: self.todo_items[data["id"]].update_from_data(data)
                )
            GLib.idle_add(self._update_stats)

    def _refresh_todos(self, *_):
        """Refresh the entire todo list"""
        # Clear existing items
        self.todo_items.clear()
        self.todos_container.children = []

        # Get all todos
        todos = todo_service.todos

        # Sort todos: incomplete first, then by priority, then by creation date
        def sort_key(todo):
            priority_order = {"high": 0, "medium": 1, "low": 2}
            return (
                todo["completed"],  # False (incomplete) comes before True (completed)
                priority_order.get(todo["priority"], 1),
                todo["created_at"],
            )

        sorted_todos = sorted(todos, key=sort_key)

        # Create todo item widgets
        for todo in sorted_todos:
            todo_item = TodoItem(todo, self)
            self.todo_items[todo["id"]] = todo_item

        # Update container children
        self.todos_container.children = list(self.todo_items.values())

        # Update stats
        self._update_stats()

    def _update_stats(self):
        """Update the statistics display"""
        stats = todo_service.get_stats()
        stats_text = f"{stats['pending']} pending, {stats['completed']} completed"
        self.stats_label.set_label(stats_text)

    def set_visible(self, visible):
        """Override set_visible for debugging"""
        super().set_visible(visible)

    def hide_todo_list(self, *_):
        """Hide the todo list"""
        if hasattr(self, "_mousecapture_parent"):
            self._mousecapture_parent.toggle_mousecapture()
        self.set_visible(False)

    def _init_mousecapture(self, mousecapture):
        """Initialize mousecapture parent reference"""
        self._mousecapture_parent = mousecapture

    def destroy(self):
        """Clean up when destroyed"""
        # Remove callback from todo service
        todo_service.remove_callback(self._on_todo_event)

        super().destroy()


class TodoListCapture(MouseCapture):
    """MouseCapture wrapper for the todo list"""

    def __init__(self, **kwargs):
        super().__init__(
            layer="top",
            child_window=TodoListWidget(),
            **kwargs,
        )