import json
import os
import subprocess
import shutil
from datetime import datetime, date

# Add common binary paths to PATH for user binaries
os.environ['PATH'] = '/run/current-system/sw/bin:/home/' + os.environ.get('USER', 'user') + '/.nix-profile/bin:' + os.environ.get('PATH', '')
from fabric.widgets.box import Box
from fabric.widgets.label import Label
from fabric.widgets.button import Button
from fabric.widgets.image import Image
from fabric.widgets.wayland import WaylandWindow as Window
from loguru import logger
from bar.config import CALENDAR

# Try to import khal as a Python library
try:
    from khal.cli.main import main_khal
    from khal.settings import get_config
    from khal.khalendar import CalendarCollection
    KHAL_AVAILABLE = True
    logger.info("[Calendar] Using khal as Python library")
except ImportError:
    KHAL_AVAILABLE = False
    logger.info("[Calendar] khal Python library not available, falling back to subprocess")


class CalendarService:
    def __init__(self, update_interval=300000):  # 5 minutes default
        self.events = []
        self.callbacks = []
        self._update_interval = update_interval
        self._timer_id = None

        # Initial load
        self.update_events()
        # Start periodic updates
        self.start_monitoring()

    def connect(self, signal_name, callback):
        """Simple callback system to replace signals"""
        if signal_name == "events-changed":
            self.callbacks.append(callback)

    def emit_events_changed(self, events):
        """Emit events changed to all callbacks"""
        for callback in self.callbacks:
            callback(self, events)

    def start_monitoring(self):
        """Start periodic event updates"""
        if self._timer_id is None:
            from fabric.utils import invoke_repeater

            self._timer_id = invoke_repeater(
                self._update_interval, self._periodic_update
            )
            logger.info(
                f"[Calendar] Started periodic updates every {self._update_interval/1000/60:.1f} minutes"
            )

    def stop_monitoring(self):
        """Stop periodic event updates"""
        if self._timer_id is not None:
            from gi.repository import GLib

            GLib.source_remove(self._timer_id)
            self._timer_id = None
            logger.info("[Calendar] Stopped periodic updates")

    def _periodic_update(self):
        """Periodic update callback"""
        logger.info("[Calendar] Performing periodic events update")
        self.update_events()
        return True  # Keep the timer running

    def get_cached_events(self):
        """Get cached events without triggering update"""
        return self.events

    def update_events_python_api(self):
        """Fetch today's events using khal Python API"""
        try:
            # Get khal configuration
            config = get_config()

            # Create calendar collection
            collection = CalendarCollection.from_calendars(
                calendars=config['calendars'],
                dbpath=config['sqlite']['path'],
                locale=config['locale'],
                color=config['default']['print_new'],
                unicode_symbols=config['default']['unicode_symbols'],
                default_calendar=config['default']['default_calendar'],
                readonly=True
            )

            # Get today's events
            today = date.today()
            events = collection.get_events_on(today)

            # Format events to match our expected structure
            formatted_events = []
            for event in events:
                formatted_event = {
                    'title': str(event.summary),
                    'start': event.start.strftime('%m-%d %H:%M') if hasattr(event.start, 'strftime') else '',
                    'end': event.end.strftime('%m-%d %H:%M') if hasattr(event.end, 'strftime') else '',
                    'location': str(event.location) if event.location else ''
                }
                formatted_events.append(formatted_event)

            # Sort by start time
            formatted_events.sort(key=lambda e: e.get('start', ''))

            self.events = formatted_events
            logger.info(f"[Calendar] Found {len(self.events)} events using Python API")
            self.emit_events_changed(self.events)

        except Exception as e:
            logger.error(f"[Calendar] Error using khal Python API: {e}")
            # Fall back to subprocess method
            self.update_events_subprocess()

    def update_events_subprocess(self):
        """Fetch today's events using khal subprocess (fallback)"""
        # Get khal path from config
        khal_path = CALENDAR.get("khal_path", "khal")

        # Check if khal is available
        if not shutil.which(khal_path):
            logger.warning(f"[Calendar] khal not found at '{khal_path}'. Please install khal or configure the correct path.")
            self.events = []
            self.emit_events_changed(self.events)
            return

        try:
            cmd = [
                khal_path,
                "list",
                "--json",
                "title",
                "--json",
                "start",
                "--json",
                "end",
                "--json",
                "location",
                "today",
            ]
            logger.info(f"[Calendar] Running command: {' '.join(cmd)}")
            result = subprocess.run(
                cmd,
                capture_output=True,
                text=True,
                check=True,
            )
            logger.info(f"[Calendar] Command stdout: {result.stdout[:200]}...")
            logger.info(f"[Calendar] Command stderr: {result.stderr[:200]}...")

            if result.stdout.strip():
                lines = result.stdout.strip().split("\n")
                all_events = []

                for line in lines:
                    if line.strip():
                        try:
                            events = json.loads(line)
                            all_events.extend(events)
                        except json.JSONDecodeError:
                            continue

                self.events = all_events
                logger.info(f"[Calendar] Found {len(self.events)} events using subprocess")
                self.emit_events_changed(self.events)
            else:
                self.events = []
                self.emit_events_changed(self.events)

        except subprocess.CalledProcessError as e:
            logger.error(f"[Calendar] Failed to fetch events: {e}")
            self.events = []
            self.emit_events_changed(self.events)
        except Exception as e:
            logger.error(f"[Calendar] Error processing events: {e}")
            self.events = []
            self.emit_events_changed(self.events)

    def update_events(self):
        """Fetch today's events from khal"""
        # Check if calendar is enabled
        if not CALENDAR.get("enable", True):
            logger.info("[Calendar] Calendar is disabled in config")
            self.events = []
            self.emit_events_changed(self.events)
            return

        # Try Python API first, fall back to subprocess
        if KHAL_AVAILABLE:
            logger.info("[Calendar] Using khal Python API")
            self.update_events_python_api()
        else:
            logger.info("[Calendar] Using khal subprocess")
            self.update_events_subprocess()


class CalendarPopup(Window):
    def __init__(self, **kwargs):
        super().__init__(
            name="calendar-popup",
            layer="top",
            anchor="top right",
            margin="10px 10px 0px 0px",  # Just a few pixels under the bar
            exclusivity="none",
            visible=False,
            all_visible=False,
            **kwargs,
        )


        # Events container
        self.events_box = Box(
            name="events-box",
            orientation="v",
            spacing=6,
            style="min-width: 450px; min-height: 200px;",
        )

        # Add a test label to make sure popup is working
        test_label = Label("Calendar Events", name="calendar-title")

        container = Box(
            orientation="v", spacing=4, children=[test_label, self.events_box]
        )

        self.children = container

        # Set explicit size - much bigger
        self.set_size_request(500, 400)

    def update_events_display(self, events):
        """Update the events display"""
        logger.info(f"[Calendar] Updating popup with {len(events)} events")

        # Clear existing children first
        self.events_box.children = []

        if not events:
            logger.info("[Calendar] No events, showing 'no events' message")
            no_events_label = Label("No events today", name="no-events")
            self.events_box.add(no_events_label)
            return

        # Check current time for time indicator placement
        now = datetime.now()
        current_time = now.strftime("%H:%M")
        current_time_added = False

        for i, event in enumerate(events):
            logger.info(f"[Calendar] Processing event {i+1} for display")
            title = event.get("title", "No title")
            start_time = event.get("start", "").split()[1] if event.get("start") else ""
            end_time = event.get("end", "").split()[1] if event.get("end") else ""
            location = event.get("location", "")

            # Check if we should add current time indicator before this event
            if not current_time_added and start_time and start_time > current_time:
                self.add_current_time_indicator(current_time)
                current_time_added = True

            # Format time display
            time_str = ""
            if start_time and end_time:
                time_str = f"{start_time} - {end_time}"
            elif start_time:
                time_str = start_time

            logger.info(f"[Calendar] Creating widget for: {title} ({time_str})")

            # Create event item with horizontal layout - time on left, content on right
            event_box = Box(
                name="event-item",
                orientation="h",  # Horizontal layout
                spacing=12,
                style_classes=["event-item"],
            )

            # Left side: Time display (fixed width for alignment)
            time_display = time_str if time_str else "All day"
            time_label = Label(
                time_display,
                name="event-time",
                style_classes=["event-time"],
                style="min-width: 100px;"  # Fixed width for consistent alignment
            )

            # Right side: Content (title and location)
            content_box = Box(
                name="event-content",
                orientation="v",
                spacing=2
            )

            # Title (no more status prefix)
            title_label = Label(
                title,
                name="event-title",
                style_classes=["event-title"],
            )
            content_box.add(title_label)

            if location:
                location_label = Label(
                    f"📍 {location}",
                    name="event-location",
                    style_classes=["event-location"],
                )
                content_box.add(location_label)

            # Add time and content to the main event box
            event_box.add(time_label)
            event_box.add(content_box)

            self.events_box.add(event_box)
            logger.info(f"[Calendar] Added event widget to events_box")

        # Add current time indicator at the end if not added yet
        if not current_time_added:
            self.add_current_time_indicator(current_time)

        # Force refresh the popup display
        self.events_box.show_all()
        logger.info(f"[Calendar] Finished updating popup")

    def add_current_time_indicator(self, current_time):
        """Add a current time indicator to the events list"""
        time_indicator = Box(
            name="current-time-indicator",
            orientation="h",
            spacing=8,
            style_classes=["current-time-indicator"],
        )

        # Current time label
        time_label = Label(
            current_time,
            name="current-time-label",
            style_classes=["current-time-label"],
            style="min-width: 100px; font-weight: bold;"
        )

        # Line indicator
        line_label = Label(
            "━━━ NOW",
            name="current-time-line",
            style_classes=["current-time-line"],
        )

        time_indicator.add(time_label)
        time_indicator.add(line_label)

        self.events_box.add(time_indicator)
        logger.info(f"[Calendar] Added current time indicator at {current_time}")


class CalendarWidget(Button):
    def __init__(self, **kwargs):
        super().__init__(
            name="calendar-widget",
            child=Image(icon_name="x-office-calendar-symbolic", icon_size=16),
            on_clicked=self.toggle_events,
            **kwargs,
        )

        self.service = CalendarService()
        self.service.connect("events-changed", self.update_events_display)

        # Create popup window
        self.popup = CalendarPopup()
        self.popup_visible = False
        logger.info("[Calendar] Calendar widget initialized with popup")

        # Initial update
        self.update_events_display(self.service, self.service.events)

    def toggle_events(self, button=None):
        """Toggle the visibility of the events popup"""
        logger.info(f"[Calendar] Button clicked, popup_visible: {self.popup_visible}")

        if self.popup_visible:
            logger.info("[Calendar] Hiding popup")
            self.popup.set_visible(False)
            self.popup_visible = False
        else:
            logger.info("[Calendar] Showing popup")
            # Refresh events when opening
            self.service.update_events()
            self.popup.set_visible(True)
            self.popup.show_all()
            self.popup_visible = True

    def update_events_display(self, service, events):
        """Update the events display in popup"""
        self.popup.update_events_display(events)