timer.py

#!/usr/bin/python3
"""Tray app and CLI on top of worklog.py / store.py."""
import os
from datetime import date, datetime, timedelta

import store
import worklog

# GtkStatusIcon (MATE's Notification Area applet) renders hover tooltips and
# Pango markup; the AppIndicator backend renders neither. Overridable via env.
os.environ.setdefault("PYSTRAY_BACKEND", "gtk")


def create_image(is_running=False):
    from PIL import Image, ImageDraw
    size = 16
    fg = "#dfdbd2ff"
    red = "#f00"
    image = Image.new('RGBA', (2*size, 2*size), "#0000")
    dc = ImageDraw.Draw(image)
    if is_running:
        bbox = [(2, 2), (2*size-4, 2*size-4)]
        dc.ellipse(bbox, fill=red)
    else:
        triangle = [(size // 2, 0), (size // 2, 2*size), (3 * size // 2, size)]
        dc.polygon(triangle, fill=fg)
    image = image.resize((size, size))
    return image


def pretty_duration(minutes):
    minutes = int(minutes)
    hours, minutes = divmod(minutes, 60)
    days, hours = divmod(hours, 24)
    if not days:
        return f"{hours}:{minutes:02}"
    return f"{days}d {hours:02}:{minutes:02}"


def elapsed_minutes(segment, now=None):
    now = now or datetime.now()
    return (now - segment.start).total_seconds() // 60


def current_journal():
    return worklog.parse(store.read())


def all_journal():
    return worklog.parse("\n".join(store.read_all()))


def running_segment(journal):
    """The open segment, but only if it is running today; else None.

    An open segment left over from an earlier day is a data problem, not a
    running task.
    """
    segment = journal.open_segment
    if segment and segment.start.date() == date.today():
        return segment
    return None


def start_label(default_task):
    """Label of the default menu item / idle tooltip when nothing runs: the
    task a left click would start, or a note that there is none."""
    return f"Začít {default_task}" if default_task else "Žádný nedávný úkol"


def tooltip(segment, default_task=None):
    """Plain-text tray title / fallback: task and elapsed on the first line,
    the inline comment on the second. Idle mirrors the first menu item."""
    if segment is None:
        return start_label(default_task)
    head = f"{segment.task} ({pretty_duration(elapsed_minutes(segment))})"
    return f"{head}\n{segment.comment}" if segment.comment else head


def tooltip_markup(segment, default_task=None):
    """Pango markup for the hover tooltip: bold task and elapsed on the first
    line, the inline comment on the second. Idle mirrors the first menu item."""
    from gi.repository import GLib
    esc = GLib.markup_escape_text
    if segment is None:
        return f"<b>{esc(start_label(default_task))}</b>"
    head = esc(f"{segment.task} ({pretty_duration(elapsed_minutes(segment))})")
    return f"<b>{head}</b>\n{esc(segment.comment)}" if segment.comment else f"<b>{head}</b>"


def stale_open_problem(journal):
    """A synthesized parse problem for an open segment stuck on a past day.

    worklog.parse() only flags an unclosed day when a later day header
    follows it in the text; it has no clock, so it cannot notice a file that
    simply ends open on a day before today. Only the app knows "today".
    """
    segment = journal.open_segment
    if segment and segment.start.date() != date.today():
        return [(None, f"day {segment.start.date()} left unclosed by task {segment.task!r}")]
    return []


class App:
    def __init__(self):
        from pystray import Icon, Menu
        self._file_token = store.stat_token()
        self.reminder_enabled = False
        self.reminder_minutes = 15
        self.reminder_at = None
        self._reminder_open = False
        self.journal = current_journal()
        running = running_segment(self.journal)
        self.icon = Icon("timer", create_image(running is not None), menu=Menu(self.create_menu))
        orig_fn = self.icon._create_menu
        def impostor(*args, **kwargs):
            result = orig_fn(*args, **kwargs)
            self.set_click_callback()
            return result
        self.icon._create_menu = impostor

    def reload(self):
        self._file_token = store.stat_token()
        self.journal = current_journal()
        self.journal.problems = [*self.journal.problems, *stale_open_problem(self.journal)]
        self.refresh_presentation()

    def refresh_presentation(self):
        running = running_segment(self.journal)
        default_task = None if running else next(iter(self.journal.recent_tasks(1)), None)
        self.icon.icon = create_image(running is not None)
        self.icon.title = tooltip(running, default_task)
        status_icon = getattr(self.icon, '_status_icon', None)
        if status_icon is not None:
            status_icon.set_tooltip_markup(tooltip_markup(running, default_task))

    def tick(self):
        # One periodic source, double duty: re-read only when the file changed
        # on disk, but always advance the running task's elapsed display.
        if store.stat_token() != self._file_token:
            self.reload()
        else:
            self.refresh_presentation()
        self.check_reminder()
        return True

    def schedule_reminder(self):
        """Arm the next auto-note if the reminder is on and a task is running."""
        if self.reminder_enabled and running_segment(self.journal) is not None:
            self.reminder_at = datetime.now() + timedelta(minutes=self.reminder_minutes)
        else:
            self.reminder_at = None

    def check_reminder(self):
        if self._reminder_open:
            return
        if not self.reminder_enabled or running_segment(self.journal) is None:
            self.reminder_at = None
            return
        if self.reminder_at is None:
            self.schedule_reminder()
        elif datetime.now() >= self.reminder_at:
            self.add_note_dialog(self.icon)

    def start(self, token, comment=""):
        running = running_segment(self.journal)
        if running and running.task == token:
            return
        # A (token) boundary already closes any running task -- no stop line.
        now = datetime.now().replace(second=0, microsecond=0)
        store.append_lines([worklog.open_line(now, token, comment)])
        self.reload()
        self.schedule_reminder()

    def stop(self, when=None, text=None):
        if running_segment(self.journal) is None:
            return
        when = when or datetime.now().replace(second=0, microsecond=0)
        store.append_lines([worklog.stop_line(when, text or "")])
        self.reload()
        self.schedule_reminder()

    def note(self, text, when=None):
        if running_segment(self.journal) is None or not text:
            return
        when = when or datetime.now().replace(second=0, microsecond=0)
        store.append_lines([worklog.note_line(when, text)])
        self.reload()

    def create_menu(self):
        from pystray import Menu, MenuItem

        def starter(token):
            return lambda icon: self.start(token)

        running = running_segment(self.journal)
        task = running.task if running else None
        if task:
            label = f"{task} ({pretty_duration(elapsed_minutes(running))})"
            title = MenuItem(label, self.add_note_dialog, default=True)
        else:
            default_task = next(iter(self.journal.recent_tasks(1)), None)
            if default_task:
                title = MenuItem(start_label(default_task), lambda icon: self.add_note_dialog(icon, start_token=default_task), default=True)
            else:
                title = MenuItem(start_label(None), None, enabled=False, default=True)

        recent_items = [MenuItem(token, starter(token)) for token in self.journal.recent_tasks(20)]
        recent_items.append(Menu.SEPARATOR)
        recent_items.append(MenuItem("Všechny úkoly...", self.pick_task_dialog))
        recent = MenuItem("Nedávné...", Menu(*recent_items))

        new = MenuItem("Začít úkol...", self.run_new_task_dialog)

        items = [title, Menu.SEPARATOR, recent, Menu.SEPARATOR]
        if task:
            items.append(MenuItem(f"Zastavit {task}", lambda icon: self.stop()))
        items.append(new)
        if self.journal.problems:
            items.append(Menu.SEPARATOR)
            items.append(MenuItem(f"Chyby v záznamu: {len(self.journal.problems)}", self.show_problems_dialog))
        return items

    def set_click_callback(self):
        from gi.repository import GLib

        def update_label(menu):
            running = running_segment(self.journal)
            if not running:
                return
            minutes = elapsed_minutes(running)
            label = f"{running.task} ({pretty_duration(minutes)})"
            item = next(iter(menu))
            GLib.idle_add(item.set_label, label)

        def postponed():
            self.icon._menu_handle.connect('show', update_label)

        GLib.idle_add(postponed)

    def run_new_task_dialog(self, icon):
        from gi.repository import Gtk
        dialog = Gtk.Dialog(parent=None, flags=0)
        dialog.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK)
        dialog.set_default_response(Gtk.ResponseType.OK)
        dialog.set_title("Začít úkol...")
        box = dialog.get_content_area()
        token_entry = Gtk.Entry()
        comment_entry = Gtk.Entry()
        token_entry.set_activates_default(True)
        comment_entry.set_activates_default(True)
        box.add(Gtk.Label(label="Úkol"))
        box.add(token_entry)
        box.add(Gtk.Label(label="Komentář"))
        box.add(comment_entry)
        reminder = self._reminder_controls(box)
        dialog.show_all()
        response = dialog.run()
        token = token_entry.get_text().strip()
        comment = comment_entry.get_text().strip()
        ok = response == Gtk.ResponseType.OK
        if ok:
            self._apply_reminder(reminder)
        dialog.destroy()
        if ok and token:
            self.start(token, comment)

    def pick_task_dialog(self, icon):
        from gi.repository import Gtk
        journal = all_journal()
        dialog = Gtk.Dialog(parent=None, flags=0)
        dialog.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK)
        dialog.set_default_response(Gtk.ResponseType.OK)
        dialog.set_title("Všechny úkoly")
        box = dialog.get_content_area()
        listbox = Gtk.ListBox(selection_mode=Gtk.SelectionMode.SINGLE)
        tokens = journal.recent_tasks()
        by_task = journal.by_task()
        for token in tokens:
            segments = by_task.get(token, [])
            total = journal.total_minutes(segments)
            latest = max((s.start for s in segments), default=None)
            latest_str = latest.strftime('%Y-%m-%d') if latest else "nikdy"
            listbox.add(Gtk.Label(label=f"{token}, celkem: {pretty_duration(total)}, naposledy: {latest_str}"))
        scrollbar = Gtk.ScrolledWindow(width_request=600, height_request=600)
        scrollbar.add(listbox)
        box.add(scrollbar)
        dialog.show_all()
        response = dialog.run()
        if response == Gtk.ResponseType.OK:
            row = listbox.get_selected_row()
            if row:
                self.start(tokens[row.get_index()])
        dialog.destroy()

    def _reminder_controls(self, box):
        """Add the shared "remind me to note" checkbox + minutes spinner,
        initialised from the in-memory state; returns (check, spin)."""
        from gi.repository import Gtk
        check = Gtk.CheckButton(label="Připomenout poznámku za (min):")
        check.set_active(self.reminder_enabled)
        spin = Gtk.SpinButton.new_with_range(1, 600, 1)
        spin.set_value(self.reminder_minutes)
        row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
        row.add(check)
        row.add(spin)
        box.add(row)
        return check, spin

    def _apply_reminder(self, controls):
        check, spin = controls
        self.reminder_enabled = check.get_active()
        self.reminder_minutes = int(spin.get_value())

    def add_note_dialog(self, icon, start_token=None):
        from gi.repository import Gtk
        running = running_segment(self.journal)
        if running is None and start_token is None:
            return
        when = datetime.now().replace(second=0, microsecond=0)
        dialog = Gtk.Dialog(parent=None, flags=0)
        dialog.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK)
        dialog.set_default_response(Gtk.ResponseType.OK)
        dialog.set_title("Poznámka")
        box = dialog.get_content_area()
        task_label = f"Aktuální úkol: {running.task}" if running else f"Úkol: {start_token}"
        box.add(Gtk.Label(label=task_label))
        box.add(Gtk.Label(label=f"Čas: {when:%H:%M}"))
        entry = Gtk.Entry(width_chars=80)
        entry.set_activates_default(True)
        box.add(entry)
        stop_check = Gtk.CheckButton(label="Zastavit úkol")
        stop_check.set_sensitive(start_token is None)
        box.add(stop_check)
        reminder = self._reminder_controls(box)
        self._reminder_open = True
        dialog.show_all()
        dialog.present()
        try:
            ok = dialog.run() == Gtk.ResponseType.OK
            text = entry.get_text().strip()
            stop = stop_check.get_active()
            if ok:
                self._apply_reminder(reminder)
        finally:
            dialog.destroy()
            self._reminder_open = False
        if ok:
            if start_token:
                self.start(start_token)
            if stop:
                self.stop(when, text)
            elif text:
                self.note(text, when)
        self.schedule_reminder()

    def show_problems_dialog(self, icon):
        from gi.repository import Gtk
        dialog = Gtk.Dialog(parent=None, flags=0)
        dialog.add_buttons(Gtk.STOCK_OK, Gtk.ResponseType.OK)
        dialog.set_default_response(Gtk.ResponseType.OK)
        dialog.set_title("Chyby v záznamu")
        box = dialog.get_content_area()
        for lineno, message in self.journal.problems:
            prefix = f"line {lineno}: " if lineno is not None else ""
            box.add(Gtk.Label(label=f"{prefix}{message}"))
        dialog.show_all()
        dialog.run()
        dialog.destroy()

    def run(self):
        from gi.repository import GLib
        GLib.timeout_add(1000, self.tick)
        self.icon.run()


def print_segments(segments):
    for s in sorted(segments, key=lambda s: s.start):
        duration = pretty_duration((s.end - s.start).total_seconds() // 60) if s.end else "bezi"
        print(f"  {s.start:%Y-%m-%d %H:%M} +{duration} {s.comment}")


def cmd_task(token):
    journal = all_journal()
    segments = journal.by_task().get(token, [])
    print(token, pretty_duration(journal.total_minutes(segments)))
    print_segments(segments)


def cmd_project(prefix=None):
    journal = all_journal()
    by_task = journal.by_task()
    if prefix is None:
        prefixes = sorted({worklog.project(token) for token in by_task})
        for p in prefixes:
            print(p)
        return
    for token in sorted(by_task):
        if worklog.project(token) == prefix:
            segments = by_task[token]
            print(token, pretty_duration(journal.total_minutes(segments)))
            print_segments(segments)


def parse_period(arg, period_start):
    """The start date for a period arg, or None if arg is not a valid period."""
    try:
        return period_start(arg)
    except ValueError:
        return None


def _load_stat_module():
    import importlib.util
    from pathlib import Path
    spec = importlib.util.spec_from_file_location("worklog_stat", Path(__file__).with_name("stat.py"))
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


if __name__ == "__main__":
    from sys import argv
    stat_report = _load_stat_module()
    match argv[1:]:
        case ["--task", token]:
            cmd_task(token)
        case ["--project"]:
            cmd_project()
        case ["--project", prefix]:
            cmd_project(prefix)
        case [period] if (start := parse_period(period, stat_report.period_start)) is not None:
            stat_report.main(start)
        case [period, prefix] if (start := parse_period(period, stat_report.period_start)) is not None:
            stat_report.main(start, prefix)
        case []:
            App().run()
        case _:
            print("usage: ./timer.py [--task <token> | --project [prefix] | day|week|month|year|YYYY-MM-DD [project]]")