import re
import subprocess
import threading
from datetime import datetime, timedelta
from typing import Dict, List, Optional

from modules.launcher.plugin_base import PluginBase
from modules.launcher.result import Result


class Reminder:
    """
    Represents a single reminder with its timer and metadata.
    """

    def __init__(
        self,
        reminder_id: int,
        message: str,
        target_time: datetime,
        timer: threading.Timer,
    ):
        self.id = reminder_id
        self.message = message
        self.target_time = target_time
        self.timer = timer
        self.created_time = datetime.now()

    def cancel(self):
        """Cancel this reminder."""
        if self.timer:
            self.timer.cancel()

    def get_time_remaining(self) -> str:
        """Get formatted time remaining until reminder."""
        now = datetime.now()
        if self.target_time <= now:
            return "Overdue"

        delta = self.target_time - now
        total_seconds = int(delta.total_seconds())

        if total_seconds < 60:
            return f"{total_seconds}s"
        elif total_seconds < 3600:
            minutes = total_seconds // 60
            seconds = total_seconds % 60
            return f"{minutes}m {seconds}s" if seconds > 0 else f"{minutes}m"
        else:
            hours = total_seconds // 3600
            minutes = (total_seconds % 3600) // 60
            return f"{hours}h {minutes}m" if minutes > 0 else f"{hours}h"

    def get_target_time_str(self) -> str:
        """Get formatted target time."""
        return self.target_time.strftime("%H:%M")


class RemindersPlugin(PluginBase):
    """
    Time-based reminders plugin for the launcher.
    """

    def __init__(self):
        super().__init__()
        self.display_name = "Reminders"
        self.description = "Set time-based reminders with notifications"
        self.reminders: Dict[int, Reminder] = {}
        self.next_id = 1

        # Regex patterns for time parsing
        self.time_patterns = {
            "relative_time": re.compile(r"^(\d+)([smhd])$"),  # 5m, 30s, 2h, 1d
            "absolute_time": re.compile(r"^(\d{1,2}):(\d{2})$"),  # 14:30, 9:15
            "relative_with_unit": re.compile(
                r"^(\d+)\s*(min|mins|minute|minutes|hour|hours|sec|seconds|day|days)$",
                re.IGNORECASE,
            ),
        }

    def initialize(self):
        """Initialize the reminders plugin."""
        self.set_triggers(["remind"])

    def cleanup(self):
        """Cleanup the reminders plugin."""
        # Cancel all active reminders
        for reminder in self.reminders.values():
            reminder.cancel()
        self.reminders.clear()

    def _send_notification(self, title: str, message: str):
        """Send a desktop notification using notify-send."""
        try:
            subprocess.run(
                ["notify-send", "-a", "Reminders", "-i", "alarm-clock", title, message],
                check=False,
            )
        except Exception as e:
            print(f"Failed to send notification: {e}")

    def _parse_time_input(self, time_str: str) -> Optional[datetime]:
        """
        Parse various time input formats and return target datetime.

        Supported formats:
        - 5m, 30s, 2h, 1d (relative time)
        - 14:30, 9:15 (absolute time today)
        - 5 minutes, 2 hours (relative with full unit names)
        """
        time_str = time_str.strip().lower()

        # Try relative time format (5m, 30s, 2h, 1d)
        match = self.time_patterns["relative_time"].match(time_str)
        if match:
            value, unit = match.groups()
            value = int(value)

            if unit == "s":
                delta = timedelta(seconds=value)
            elif unit == "m":
                delta = timedelta(minutes=value)
            elif unit == "h":
                delta = timedelta(hours=value)
            elif unit == "d":
                delta = timedelta(days=value)
            else:
                return None

            return datetime.now() + delta

        # Try absolute time format (14:30, 9:15)
        match = self.time_patterns["absolute_time"].match(time_str)
        if match:
            hour, minute = map(int, match.groups())
            if 0 <= hour <= 23 and 0 <= minute <= 59:
                target = datetime.now().replace(
                    hour=hour, minute=minute, second=0, microsecond=0
                )
                # If the time has already passed today, schedule for tomorrow
                if target <= datetime.now():
                    target += timedelta(days=1)
                return target

        # Try relative time with full unit names
        match = self.time_patterns["relative_with_unit"].match(time_str)
        if match:
            value, unit = match.groups()
            value = int(value)
            unit = unit.lower()

            if unit in ["sec", "seconds"]:
                delta = timedelta(seconds=value)
            elif unit in ["min", "mins", "minute", "minutes"]:
                delta = timedelta(minutes=value)
            elif unit in ["hour", "hours"]:
                delta = timedelta(hours=value)
            elif unit in ["day", "days"]:
                delta = timedelta(days=value)
            else:
                return None

            return datetime.now() + delta

        return None

    def _create_reminder(self, time_str: str, message: str) -> Optional[Reminder]:
        """Create a new reminder with the given time and message."""
        target_time = self._parse_time_input(time_str)
        if not target_time:
            return None

        # Calculate delay in seconds
        delay = (target_time - datetime.now()).total_seconds()
        if delay <= 0:
            return None

        # Create timer that will trigger the notification
        timer = threading.Timer(delay, self._trigger_reminder, [self.next_id, message])

        # Create reminder object
        reminder = Reminder(self.next_id, message, target_time, timer)

        # Store reminder and start timer
        self.reminders[self.next_id] = reminder
        timer.start()

        # Increment ID for next reminder
        self.next_id += 1

        return reminder

    def _trigger_reminder(self, reminder_id: int, message: str):
        """Trigger a reminder notification and remove it from active reminders."""
        # Send notification
        self._send_notification("⏰ Reminder", message)

        # Remove from active reminders
        if reminder_id in self.reminders:
            del self.reminders[reminder_id]

    def _cancel_reminder(self, reminder_id: Optional[int] = None) -> int:
        """Cancel a specific reminder or all reminders. Returns number of cancelled reminders."""
        if reminder_id is not None:
            if reminder_id in self.reminders:
                self.reminders[reminder_id].cancel()
                del self.reminders[reminder_id]
                return 1
            return 0
        else:
            # Cancel all reminders
            count = len(self.reminders)
            for reminder in self.reminders.values():
                reminder.cancel()
            self.reminders.clear()
            return count

    def _format_time_remaining(self, total_seconds: float) -> str:
        """Format time remaining in a human-readable way."""
        total_seconds = int(total_seconds)

        if total_seconds < 60:
            return f"{total_seconds}s"
        elif total_seconds < 3600:
            minutes = total_seconds // 60
            seconds = total_seconds % 60
            return f"{minutes}m {seconds}s" if seconds > 0 else f"{minutes}m"
        else:
            hours = total_seconds // 3600
            minutes = (total_seconds % 3600) // 60
            return f"{hours}h {minutes}m" if minutes > 0 else f"{hours}h"

    def _create_and_confirm_reminder(self, time_str: str, message: str):
        """Actually create the reminder when the user presses Enter."""
        reminder = self._create_reminder(time_str, message)
        if reminder:
            time_remaining = reminder.get_time_remaining()
            self._send_notification(
                "✅ Reminder Created", f"Reminder set for {time_remaining}: {message}"
            )
        else:
            self._send_notification(
                "❌ Failed to Create Reminder", "The specified time may be in the past"
            )

    def query(self, query_string: str) -> List[Result]:
        """Process reminder queries."""
        results = []
        query = query_string.strip()

        if not query:
            # Show help and active reminders count
            active_count = len(self.reminders)
            results.append(
                Result(
                    title="Reminders Help",
                    subtitle=f"Active reminders: {
                        active_count
                    } | Usage: remind 5m Take a break",
                    icon_name="alarm-timer",
                    action=lambda: None,
                    relevance=1.0,
                    plugin_name=self.display_name,
                    data={"type": "help"},
                )
            )

            # Show quick examples
            examples = [
                ("remind 5m Take a break", "Set 5 minute reminder"),
                ("remind 14:30 Meeting", "Set reminder for 2:30 PM"),
                ("remind list", "List active reminders"),
                ("remind cancel", "Cancel all reminders"),
            ]

            for example, desc in examples:
                results.append(
                    Result(
                        title=example,
                        subtitle=desc,
                        icon_name="alarm-timer",
                        action=lambda: None,
                        relevance=0.8,
                        plugin_name=self.display_name,
                        data={"type": "example"},
                    )
                )

            return results

        # Handle list command
        if query.lower() in ["list", "ls", "show"]:
            if not self.reminders:
                results.append(
                    Result(
                        title="No Active Reminders",
                        subtitle="Use 'remind 5m message' to set a reminder",
                        icon_name="timer-off",
                        action=lambda: None,
                        relevance=1.0,
                        plugin_name=self.display_name,
                        data={"type": "empty_list"},
                    )
                )
            else:
                for reminder in sorted(
                    self.reminders.values(), key=lambda r: r.target_time
                ):
                    time_remaining = reminder.get_time_remaining()
                    target_time = reminder.get_target_time_str()

                    results.append(
                        Result(
                            title=f"#{reminder.id}: {reminder.message}",
                            subtitle=f"In {time_remaining} (at {target_time})",
                            icon_name="alarm-timer",
                            action=lambda rid=reminder.id: self._cancel_reminder(rid),
                            relevance=1.0,
                            plugin_name=self.display_name,
                            data={"type": "active_reminder", "id": reminder.id},
                        )
                    )

            return results

        # Handle cancel command
        if query.lower().startswith("cancel") or query.lower().startswith("stop"):
            parts = query.split()
            if len(parts) == 1:
                # Cancel all reminders
                count = self._cancel_reminder()
                results.append(
                    Result(
                        title=f"Cancelled {count} Reminders",
                        subtitle="All active reminders have been cancelled",
                        icon_name="timer-off",
                        action=lambda: None,
                        relevance=1.0,
                        plugin_name=self.display_name,
                        data={"type": "cancel_all"},
                    )
                )
            else:
                # Try to cancel specific reminder by ID
                try:
                    reminder_id = int(parts[1])
                    count = self._cancel_reminder(reminder_id)
                    if count > 0:
                        results.append(
                            Result(
                                title=f"Cancelled Reminder #{reminder_id}",
                                subtitle="Reminder has been cancelled",
                                icon_name="timer-off",
                                action=lambda: None,
                                relevance=1.0,
                                plugin_name=self.display_name,
                                data={"type": "cancel_specific"},
                            )
                        )
                    else:
                        results.append(
                            Result(
                                title="Reminder Not Found",
                                subtitle=f"No reminder with ID #{reminder_id}",
                                icon_name="alert",
                                action=lambda: None,
                                relevance=0.5,
                                plugin_name=self.display_name,
                                data={"type": "error"},
                            )
                        )
                except ValueError:
                    results.append(
                        Result(
                            title="Invalid Reminder ID",
                            subtitle="Please provide a valid reminder ID number",
                            icon_name="alert",
                            action=lambda: None,
                            relevance=0.5,
                            plugin_name=self.display_name,
                            data={"type": "error"},
                        )
                    )

            return results

        # Handle setting new reminders
        parts = query.split(None, 1)
        if len(parts) >= 1:
            time_str = parts[0]
            message = parts[1] if len(parts) > 1 else "Reminder"

            # Try to parse the time (but don't create the reminder yet!)
            target_time = self._parse_time_input(time_str)
            if target_time:
                # Calculate delay and check if it's valid
                delay = (target_time - datetime.now()).total_seconds()
                if delay > 0:
                    # Show what would happen, but don't create the reminder yet
                    time_remaining = self._format_time_remaining(delay)
                    target_time_str = target_time.strftime("%H:%M")

                    results.append(
                        Result(
                            title=f"Set Reminder: {message}",
                            subtitle=f"Will remind in {time_remaining} (at {
                                target_time_str
                            })",
                            icon_name="alarm-timer",
                            action=lambda ts=time_str, msg=message: self._create_and_confirm_reminder(
                                ts, msg
                            ),
                            relevance=1.0,
                            plugin_name=self.display_name,
                            data={
                                "type": "preview",
                                "time_str": time_str,
                                "message": message,
                            },
                        )
                    )
                else:
                    results.append(
                        Result(
                            title="Time is in the Past",
                            subtitle="Please specify a future time",
                            icon_name="alert",
                            action=lambda: None,
                            relevance=0.5,
                            plugin_name=self.display_name,
                            data={"type": "error"},
                        )
                    )
            else:
                # Invalid time format
                results.append(
                    Result(
                        title="Invalid Time Format",
                        subtitle="Use formats like: 5m, 30s, 2h, 14:30, or '5 minutes'",
                        icon_name="alert",
                        action=lambda: None,
                        relevance=0.5,
                        plugin_name=self.display_name,
                        data={"type": "error"},
                    )
                )

        return results