# todo_reminder.py
# ポップアップ見切れ永久対策 + マルチモニター/タスクバー位置/DPI対応
# - 表示先モニターの作業領域に高さ・位置をクランプ
# - 本体最小化中でも透明復帰→ポップ→再最小化で確実表示
# - グレース±15秒/起動直後即チェック
# - ボタンは幅に応じて 1行/2行/縦並びを自動選択（見切れ防止）
# 既存機能：作成/編集/削除、優先度、締切、繰り返し（日/週/月/年）、スヌーズ、複数整列、統計、フィルタ、保存

import tkinter as tk
from tkinter import ttk, messagebox
from datetime import datetime, timedelta, date
import calendar as pycal
import json
import os
import uuid
import sys
import traceback
import shutil
import tkinter.font as tkfont

# ---------------- 保存先と移行 ----------------
APP_DIR = os.path.join(os.environ.get("LOCALAPPDATA", os.path.expanduser("~")), "TodoReminder")
os.makedirs(APP_DIR, exist_ok=True)
DATA_FILE = os.path.join(APP_DIR, "todo_reminder_data.json")

def _possible_legacy_paths():
    paths = []
    try:
        script_dir = os.path.dirname(os.path.abspath(__file__))
        paths.append(os.path.join(script_dir, "todo_reminder_data.json"))
    except Exception:
        pass
    try:
        paths.append(os.path.join(os.getcwd(), "todo_reminder_data.json"))
    except Exception:
        pass
    uniq = []
    for p in paths:
        if p and p not in uniq:
            uniq.append(p)
    return uniq

def migrate_legacy_data_if_needed():
    if os.path.exists(DATA_FILE):
        return
    for p in _possible_legacy_paths():
        try:
            if os.path.exists(p):
                shutil.copy2(p, DATA_FILE)
                print(f"[migrate] copied legacy data from: {p} -> {DATA_FILE}")
                return
        except Exception:
            traceback.print_exc()

# ---------------- 設定 ----------------
CHECK_INTERVAL_MS = 10_000  # 10秒ごとチェック
DUE_GRACE_SEC = 15          # 取りこぼし防止グレース（±15秒）
SNOOZE_MINUTES = 10
POPUP_W_DEFAULT = 480
POPUP_MARGIN = 16
PRIORITY_VALUES = ["高", "中", "低"]
PRIORITY_ICON = {"高": "🔴", "中": "🟡", "低": "🟢"}
PRIORITY_ORDER = {"高": 0, "中": 1, "低": 2}
FILTER_OPTIONS = ["すべて", "未完了", "完了", "今日が締切", "期限切れ"]
REPEAT_OPTIONS = ["なし", "日次", "週次", "月次", "年次"]
REPEAT_SHORT = {"なし": "", "日次": "日", "週次": "週", "月次": "月", "年次": "年"}
DATE_FMT = "%Y/%m/%d"
TIME_FMT = "%H:%M"
DATETIME_FMT = "%Y/%m/%d %H:%M"

# ---------------- ユーティリティ ----------------
def now_local():
    return datetime.now()

def parse_deadline(s: str) -> datetime:
    s = s.strip()
    for fmt in ("%Y/%m/%d %H:%M", "%Y-%m-%d %H:%M", "%Y.%m.%d %H:%M"):
        try:
            return datetime.strptime(s, fmt)
        except Exception:
            pass
    raise ValueError(f"日時の形式が正しくありません: {s}\n例: 2025/08/23 17:30")

def format_deadline(dt: datetime) -> str:
    return dt.strftime(DATETIME_FMT)

def safe_load_json(path: str, default):
    if not os.path.exists(path):
        return default
    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except Exception:
        traceback.print_exc()
        return default

def safe_save_json(path: str, data):
    try:
        with open(path, "w", encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
    except Exception:
        traceback.print_exc()

# ====== フォント拡大 ======
def apply_global_font_scaling(base_pt: int = 16, heading_delta: int = 3):
    for name in ("TkDefaultFont", "TkTextFont", "TkMenuFont", "TkFixedFont"):
        f = tkfont.nametofont(name)
        f.configure(size=base_pt)
    tkfont.nametofont("TkHeadingFont").configure(size=base_pt + heading_delta)
    text_f = tkfont.nametofont("TkTextFont")
    row_h = max(int(text_f.metrics("linespace") * 1.6), 26)
    style = ttk.Style()
    style.configure("Treeview", rowheight=row_h)
    style.configure("Treeview.Heading", padding=(8, 6))

# ====== 月/年ユーティリティ ======
def last_day_of_month(y: int, m: int) -> int:
    return pycal.monthrange(y, m)[1]

def add_months(dt: datetime, n: int) -> datetime:
    y, m = dt.year, dt.month
    m += n
    y += (m - 1) // 12
    m = (m - 1) % 12 + 1
    d = min(dt.day, last_day_of_month(y, m))
    return dt.replace(year=y, month=m, day=d)

def add_years(dt: datetime, n: int) -> datetime:
    y = dt.year + n
    m = dt.month
    d = min(dt.day, last_day_of_month(y, m))
    return dt.replace(year=y, month=m, day=d)

def next_occurrence(dt: datetime, repeat: str) -> datetime:
    if repeat == "日次":
        return dt + timedelta(days=1)
    if repeat == "週次":
        return dt + timedelta(weeks=1)
    if repeat == "月次":
        return add_months(dt, 1)
    if repeat == "年次":
        return add_years(dt, 1)
    return dt

def roll_forward_into_future(dt: datetime, repeat: str, reference: datetime) -> datetime:
    if repeat == "なし":
        return dt
    limit = 1000
    while dt <= reference and limit > 0:
        dt = next_occurrence(dt, repeat)
        limit -= 1
    return dt

# ====== Windows 作業領域（タスクバー除外） ======
def _get_windows_workarea():
    if not sys.platform.startswith("win"):
        return 0, 0, None, None
    try:
        from ctypes import wintypes, windll, byref
        SPI_GETWORKAREA = 0x0030
        rect = wintypes.RECT()
        ok = windll.user32.SystemParametersInfoW(SPI_GETWORKAREA, 0, byref(rect), 0)
        if ok:
            left, top, right, bottom = rect.left, rect.top, rect.right, rect.bottom
            return left, top, right - left, bottom - top
    except Exception:
        pass
    return 0, 0, None, None

# ========== カレンダー ==========
class CalendarPopup:
    def __init__(self, master, init_date: date, on_pick):
        self.top = tk.Toplevel(master)
        self.top.title("日付を選択")
        self.top.transient(master)
        self.on_pick = on_pick
        try:
            self.top.geometry("+380+240")
        except Exception:
            pass

        self.cur_year = init_date.year
        self.cur_month = init_date.month

        outer = ttk.Frame(self.top, padding=10)
        outer.pack(fill=tk.BOTH, expand=True)

        nav = ttk.Frame(outer)
        nav.pack(fill=tk.X, pady=(0, 6))
        ttk.Button(nav, text="◀", width=3, command=self.prev_month).pack(side=tk.LEFT)
        ttk.Button(nav, text="▶", width=3, command=self.next_month).pack(side=tk.RIGHT)
        self.lbl_ym = ttk.Label(nav, text="")
        self.lbl_ym.pack(side=tk.LEFT, expand=True)

        grid = ttk.Frame(outer)
        grid.pack()
        header = ["月","火","水","木","金","土","日"]
        for i, h in enumerate(header):
            ttk.Label(grid, text=h, width=4, anchor="center").grid(row=0, column=i, padx=2, pady=2)

        self.day_buttons = []
        for r in range(1, 7):
            row_btns = []
            for c in range(7):
                b = ttk.Button(grid, text="", width=4)
                b.grid(row=r, column=c, padx=2, pady=2)
                row_btns.append(b)
            self.day_buttons.append(row_btns)

        ctrl = ttk.Frame(outer)
        ctrl.pack(fill=tk.X, pady=(8, 0))
        ttk.Button(ctrl, text="今日", command=self.pick_today).pack(side=tk.LEFT)
        ttk.Button(ctrl, text="キャンセル", command=self.close).pack(side=tk.RIGHT)

        self.render()
        self.top.bind("<Escape>", lambda e: self.close())

    def render(self):
        self.lbl_ym.config(text=f"{self.cur_year}年 {self.cur_month:02d}月")
        monthcal = pycal.Calendar(firstweekday=0).monthdayscalendar(self.cur_year, self.cur_month)
        for r in range(6):
            week = monthcal[r] if r < len(monthcal) else [0]*7
            for c in range(7):
                day = week[c]
                btn = self.day_buttons[r][c]
                if day == 0:
                    btn.config(text="", state="disabled", command=None)
                else:
                    btn.config(text=str(day), state="normal", command=lambda d=day: self.pick_day(d))

    def prev_month(self):
        if self.cur_month == 1:
            self.cur_month = 12
            self.cur_year -= 1
        else:
            self.cur_month -= 1
        self.render()

    def next_month(self):
        if self.cur_month == 12:
            self.cur_month = 1
            self.cur_year += 1
        else:
            self.cur_month += 1
        self.render()

    def pick_day(self, day):
        self.on_pick(date(self.cur_year, self.cur_month, day))
        self.close()

    def pick_today(self):
        self.on_pick(date.today())
        self.close()

    def close(self):
        try:
            self.top.destroy()
        except Exception:
            pass

# ========== メイン ==========
class TodoApp:
    def __init__(self, root: tk.Tk):
        self.root = root
        self.root.title("TODO + リマインダー（Tkinter）")
        try:
            self.root.iconbitmap("")  # 失敗しても無視
        except Exception:
            pass

        # 画面情報
        self.root.update_idletasks()
        self.screen_w = self.root.winfo_screenwidth()
        self.screen_h = self.root.winfo_screenheight()
        self.work_left, self.work_top, self.work_w, self.work_h = _get_windows_workarea()
        self.effective_h = (self.work_h or self.screen_h)
        self.top_margin = POPUP_MARGIN + (self.work_top or 0)

        self.tasks = []
        self.active_popups = {}   # task_id -> Toplevel

        # ポップ幅と段積み
        self.popup_w = self._get_popup_width()
        self.tiling_cols = max(1, self.screen_w // (self.popup_w + POPUP_MARGIN))
        self.tiling_next_y = [self.top_margin] * self.tiling_cols

        self.root.geometry("1100x720")
        self._build_ui()
        self._bind_keys()

        migrate_legacy_data_if_needed()
        self._load_data()
        self._migrate_data()
        self.refresh_view()
        self._update_minsize()

        # 起動直後即チェック
        self.root.after(0, self._check_reminders)
        self._schedule_check()

    def _get_popup_width(self):
        avail_w = (self.work_w or self.screen_w)
        return max(320, min(POPUP_W_DEFAULT, avail_w - 2 * POPUP_MARGIN))

    # --- UI ---
    def _build_ui(self):
        topbar = ttk.Frame(self.root, padding=6)
        topbar.pack(fill=tk.X)

        self.btn_add = ttk.Button(topbar, text="新規 (Ctrl+N)", command=self.add_task_dialog)
        self.btn_edit = ttk.Button(topbar, text="編集 (Ctrl+E)", command=self.edit_selected)
        self.btn_delete = ttk.Button(topbar, text="削除 (Del)", command=self.delete_selected)
        for b in (self.btn_add, self.btn_edit, self.btn_delete):
            b.pack(side=tk.LEFT, padx=2)

        ttk.Separator(topbar, orient="vertical").pack(side=tk.LEFT, fill=tk.Y, padx=8)

        ttk.Label(topbar, text="フィルター:").pack(side=tk.LEFT, padx=(0, 4))
        self.filter_var = tk.StringVar(value=FILTER_OPTIONS[0])
        self.filter_combo = ttk.Combobox(topbar, textvariable=self.filter_var, values=FILTER_OPTIONS, width=12, state="readonly")
        self.filter_combo.pack(side=tk.LEFT)
        self.filter_combo.bind("<<ComboboxSelected>>", lambda e: self.refresh_view())

        ttk.Separator(topbar, orient="vertical").pack(side=tk.LEFT, fill=tk.Y, padx=8)

        self.stats_var = tk.StringVar(value="全: 0 / 完了: 0 / 期限切れ: 0")
        ttk.Label(topbar, textvariable=self.stats_var).pack(side=tk.LEFT, padx=4)

        # Treeview + スクロール
        tree_wrap = ttk.Frame(self.root)
        tree_wrap.pack(fill=tk.BOTH, expand=True, padx=6, pady=6)

        columns = ("done", "priority", "deadline", "repeat", "title")
        self.tree = ttk.Treeview(tree_wrap, columns=columns, show="headings", selectmode="browse")
        self.tree.heading("done", text="完了", anchor="center")
        self.tree.heading("priority", text="優先度", anchor="center")
        self.tree.heading("deadline", text="締切", anchor="center")
        self.tree.heading("repeat", text="繰り返し", anchor="center")
        self.tree.heading("title", text="内容", anchor="w")

        self.tree.column("done", anchor=tk.CENTER, stretch=False, width=60)
        self.tree.column("priority", anchor=tk.CENTER, stretch=False, width=100)
        self.tree.column("deadline", anchor=tk.CENTER, stretch=False, width=190)
        self.tree.column("repeat", anchor=tk.CENTER, stretch=False, width=90)
        self.tree.column("title", anchor=tk.W, stretch=True, width=620)

        yscroll = ttk.Scrollbar(tree_wrap, orient="vertical", command=self.tree.yview)
        xscroll = ttk.Scrollbar(tree_wrap, orient="horizontal", command=self.tree.xview)
        self.tree.configure(yscrollcommand=yscroll.set, xscrollcommand=xscroll.set)

        self.tree.grid(row=0, column=0, sticky="nsew")
        yscroll.grid(row=0, column=1, sticky="ns")
        xscroll.grid(row=1, column=0, sticky="ew")
        tree_wrap.rowconfigure(0, weight=1)
        tree_wrap.columnconfigure(0, weight=1)

        self.tree.tag_configure("completed", foreground="#888")
        self.tree.tag_configure("overdue", background="#ffe6e6")
        self.tree.tag_configure("high", foreground="#d00000")

        self.tree.bind("<Double-1>", self.on_double_click_edit)
        self.tree.bind("<Button-1>", self.on_tree_click_toggle)

        self.hint_lbl = ttk.Label(
            self.root, padding=(8, 0),
            text=("ダブルクリックで編集 / Ctrl+N新規 / Space完了 / Del削除 / "
                  "📅で日付選択・時刻は現在時刻から微調整 / 繰り返し：日・週・月・年 / "
                  "同時刻の予定は複数ポップアップで整列表示（本文スクロール対応）")
        )
        self.hint_lbl.pack(fill=tk.X)
        self.root.bind("<Configure>", self._on_resize_adjust_columns)

    def _bind_keys(self):
        self.root.bind("<Control-n>", lambda e: self.add_task_dialog())
        self.root.bind("<Control-N>", lambda e: self.add_task_dialog())
        self.root.bind("<Control-e>", lambda e: self.edit_selected())
        self.root.bind("<Control-E>", lambda e: self.edit_selected())
        self.root.bind("<space>", lambda e: self.toggle_selected())
        self.root.bind("<Delete>", lambda e: self.delete_selected())

    # --- ウィンドウ最小サイズ ---
    def _update_minsize(self):
        f_head = tkfont.nametofont("TkHeadingFont")
        pad = 28
        done_w = max(60, f_head.measure("完了") + pad)
        pr_w   = max(100, f_head.measure("優先度") + pad)
        dl_w   = max(190, f_head.measure("0000/00/00 00:00") + pad)
        rp_w   = max(90,  f_head.measure("繰り返し") + pad)
        fixed_w = done_w + pr_w + dl_w + rp_w
        title_min = max(260, f_head.measure("内容") + 200)
        min_w = min(fixed_w + title_min + 60, self.screen_w - 40)
        min_h = min(560, self.effective_h - 80)
        self.root.minsize(min_w, min_h)

    # --- 列幅調整＆ヒント折返し ---
    def _on_resize_adjust_columns(self, event=None):
        try:
            f_head = tkfont.nametofont("TkHeadingFont")
            pad = 28
            done_w = max(60, f_head.measure("完了") + pad)
            pr_w   = max(100, f_head.measure("優先度") + pad)
            dl_w   = max(190, f_head.measure("0000/00/00 00:00") + pad)
            rp_w   = max(90,  f_head.measure("繰り返し") + pad)
            tw = self.tree.winfo_width()
            fixed = done_w + pr_w + dl_w + rp_w
            title_w = max(240, tw - fixed - 8) if tw > 0 else 620
            self.tree.column("done", width=done_w)
            self.tree.column("priority", width=pr_w)
            self.tree.column("deadline", width=dl_w)
            self.tree.column("repeat", width=rp_w)
            self.tree.column("title", width=title_w)
            wrap = max(200, self.root.winfo_width() - 40)
            self.hint_lbl.configure(wraplength=wrap)
        except Exception:
            pass

    # --- データ ---
    def _load_data(self):
        data = safe_load_json(DATA_FILE, {"tasks": []})
        self.tasks = data.get("tasks", [])

    def _migrate_data(self):
        for t in self.tasks:
            t.setdefault("id", str(uuid.uuid4()))
            t.setdefault("completed", False)
            t.setdefault("snooze_until", None)
            t.setdefault("alerted", False)
            t.setdefault("repeat", "なし")

    def _save_data(self):
        safe_save_json(DATA_FILE, {"tasks": self.tasks})

    # --- タスク操作 ---
    def add_task_dialog(self, preset=None):
        TaskDialog(self.root, title="タスクの追加", on_ok=self._add_task_from_dialog, preset=preset)

    def _add_task_from_dialog(self, title: str, priority: str, date_str: str, time_str: str, repeat: str):
        try:
            dt = datetime.strptime(date_str.strip() + " " + time_str.strip(), DATETIME_FMT)
        except Exception:
            messagebox.showerror(
                "エラー",
                f"日付/時刻の形式が正しくありません。\n例: {date.today().strftime(DATE_FMT)} と {now_local().strftime(TIME_FMT)}"
            )
        else:
            new_task = {
                "id": str(uuid.uuid4()),
                "title": title.strip(),
                "priority": priority,
                "deadline": dt.strftime(DATETIME_FMT),
                "completed": False,
                "snooze_until": None,
                "alerted": False,
                "repeat": repeat,
            }
            self.tasks.append(new_task)
            self._save_data()
            self.refresh_view()

    def get_selected_task(self):
        sel = self.tree.selection()
        if not sel:
            return None, None
        iid = sel[0]
        for t in self.tasks:
            if t["id"] == iid:
                return iid, t
        return None, None

    def edit_selected(self):
        iid, task = self.get_selected_task()
        if not task:
            return
        try:
            dt = parse_deadline(task["deadline"])
            preset_date = dt.strftime(DATE_FMT)
            preset_time = dt.strftime(TIME_FMT)
        except Exception:
            preset_date = date.today().strftime(DATE_FMT)
            preset_time = now_local().strftime(TIME_FMT)

        TaskDialog(
            self.root,
            title="タスクの編集",
            on_ok=lambda *args: self._edit_task_apply(iid, *args),
            preset={
                "title": task["title"],
                "priority": task["priority"],
                "date": preset_date,
                "time": preset_time,
                "repeat": task.get("repeat", "なし"),
            }
        )

    def _edit_task_apply(self, task_id: str, title: str, priority: str, date_str: str, time_str: str, repeat: str):
        try:
            dt = datetime.strptime(date_str.strip() + " " + time_str.strip(), DATETIME_FMT)
        except Exception:
            messagebox.showerror(
                "エラー",
                f"日付/時刻の形式が正しくありません。\n例: {date.today().strftime(DATE_FMT)} と {now_local().strftime(TIME_FMT)}"
            )
            return

        for t in self.tasks:
            if t["id"] == task_id:
                t["title"] = title.strip()
                t["priority"] = priority
                t["deadline"] = dt.strftime(DATETIME_FMT)
                t["repeat"] = repeat
                t["alerted"] = False
                t["snooze_until"] = None
                break
        self._save_data()
        self.refresh_view()

    def _roll_task_to_next_if_repeating(self, task):
        if task.get("repeat", "なし") != "なし":
            cur = parse_deadline(task["deadline"])
            nxt = roll_forward_into_future(next_occurrence(cur, task["repeat"]), task["repeat"], now_local())
            task["deadline"] = format_deadline(nxt)
            task["completed"] = False
            task["snooze_until"] = None
            task["alerted"] = False
        else:
            task["snooze_until"] = None
            task["alerted"] = True

    def toggle_selected(self):
        iid, task = self.get_selected_task()
        if not task:
            return
        task["completed"] = not task["completed"]
        if task["completed"]:
            self._roll_task_to_next_if_repeating(task)
        else:
            task["alerted"] = False
        self._save_data()
        self.refresh_view()

    def delete_selected(self):
        iid, task = self.get_selected_task()
        if not task:
            return
        if messagebox.askyesno("削除", "選択したタスクを削除しますか？"):
            self.tasks = [t for t in self.tasks if t["id"] != iid]
            self._save_data()
            self.refresh_view()

    # --- Tree 操作 ---
    def on_double_click_edit(self, event):
        item = self.tree.identify_row(event.y)
        if not item:
            return
        for t in self.tasks:
            if t["id"] == item:
                try:
                    dt = parse_deadline(t["deadline"])
                    preset_date = dt.strftime(DATE_FMT)
                    preset_time = dt.strftime(TIME_FMT)
                except Exception:
                    preset_date = date.today().strftime(DATE_FMT)
                    preset_time = now_local().strftime(TIME_FMT)
                TaskDialog(
                    self.root,
                    title="タスクの編集",
                    on_ok=lambda *args: self._edit_task_apply(item, *args),
                    preset={
                        "title": t["title"],
                        "priority": t["priority"],
                        "date": preset_date,
                        "time": preset_time,
                        "repeat": t.get("repeat", "なし"),
                    }
                )
                break

    def on_tree_click_toggle(self, event):
        region = self.tree.identify("region", event.x, event.y)
        if region != "cell":
            return
        col = self.tree.identify_column(event.x)  # "#1" が先頭列（完了）
        if col != "#1":
            return
        row = self.tree.identify_row(event.y)
        if not row:
            return
        self.tree.selection_set(row)
        for t in self.tasks:
            if t["id"] == row:
                t["completed"] = not t["completed"]
                if t["completed"]:
                    self._roll_task_to_next_if_repeating(t)
                else:
                    t["alerted"] = False
                break
        self._save_data()
        self.refresh_view()
        return "break"

    # --- フィルタ/ソート/統計 ---
    def _filtered_tasks(self):
        mode = self.filter_var.get()
        today = date.today()
        res = []
        for t in self.tasks:
            try:
                dl = parse_deadline(t["deadline"])
            except Exception:
                continue
            if mode == "すべて":
                res.append(t)
            elif mode == "未完了":
                if not t["completed"]:
                    res.append(t)
            elif mode == "完了":
                if t["completed"]:
                    res.append(t)
            elif mode == "今日が締切":
                if not t["completed"] and dl.date() == today:
                    res.append(t)
            elif mode == "期限切れ":
                if not t["completed"] and dl < now_local():
                    res.append(t)
        res.sort(key=lambda x: (PRIORITY_ORDER.get(x["priority"], 9),
                                parse_deadline(x["deadline"])))
        return res

    def _compute_stats(self):
        total = len(self.tasks)
        completed = sum(1 for t in self.tasks if t.get("completed"))
        overdue = 0
        now_ = now_local()
        for t in self.tasks:
            try:
                dl = parse_deadline(t["deadline"])
                if not t["completed"] and dl < now_:
                    overdue += 1
            except Exception:
                pass
        self.stats_var.set(f"全: {total} / 完了: {completed} / 期限切れ: {overdue}")

    def refresh_view(self):
        for iid in self.tree.get_children():
            self.tree.delete(iid)
        for t in self._filtered_tasks():
            done = "☑" if t.get("completed") else "☐"
            pr = t.get("priority", "中")
            pr_disp = f"{PRIORITY_ICON.get(pr, '')}{pr}"
            dl_text = t.get("deadline", "")
            rep = t.get("repeat", "なし")
            rep_disp = REPEAT_SHORT.get(rep, "")
            title_raw = t.get("title", "")
            title = " ".join(title_raw.splitlines()).strip()

            tags = []
            if t.get("completed"):
                tags.append("completed")
            else:
                try:
                    dl = parse_deadline(dl_text)
                    if dl < now_local():
                        tags.append("overdue")
                except Exception:
                    pass
                if pr == "高":
                    tags.append("high")

            self.tree.insert("", tk.END, iid=t["id"],
                             values=(done, pr_disp, dl_text, rep_disp, title),
                             tags=tuple(tags))
        self._compute_stats()
        self._on_resize_adjust_columns()

    # --- 自動ロール（取りこぼし対策） ---
    def _auto_roll_repeating_tasks_if_missed(self):
        now_ = now_local()
        changed = False
        for t in self.tasks:
            if t.get("completed"):
                continue
            repeat = t.get("repeat", "なし")
            if repeat == "なし":
                continue
            try:
                dl = parse_deadline(t["deadline"])
            except Exception:
                continue
            if t.get("alerted", False) and dl < now_:
                nxt = roll_forward_into_future(next_occurrence(dl, repeat), repeat, now_)
                if nxt > dl:
                    t["deadline"] = format_deadline(nxt)
                    t["alerted"] = False
                    t["snooze_until"] = None
                    changed = True
        if changed:
            self._save_data()
            self.refresh_view()

    # --- チェックスケジュール ---
    def _schedule_check(self):
        self.root.after(CHECK_INTERVAL_MS, self._check_reminders)

    def _check_reminders(self):
        try:
            self._auto_roll_repeating_tasks_if_missed()
            due_list = self._find_due_tasks_for_popups()
            for task in due_list:
                try:
                    self._show_popup(task)
                except Exception:
                    traceback.print_exc()
        except Exception:
            traceback.print_exc()
        finally:
            self._schedule_check()

    def _find_due_tasks_for_popups(self):
        now_ = now_local()
        grace_end   = now_ + timedelta(seconds=DUE_GRACE_SEC)

        candidates = []
        for t in self.tasks:
            if t.get("completed"):
                continue
            if t["id"] in self.active_popups:
                continue
            try:
                dl = parse_deadline(t["deadline"])
            except Exception:
                continue
            if t.get("alerted", False):
                continue

            snooze_until = None
            if t.get("snooze_until"):
                try:
                    snooze_until = parse_deadline(t["snooze_until"])
                except Exception:
                    snooze_until = None

            if dl <= grace_end and (snooze_until is None or snooze_until <= grace_end):
                candidates.append(t)

        candidates.sort(key=lambda x: (PRIORITY_ORDER.get(x["priority"], 9),
                                       parse_deadline(x["deadline"])))
        return candidates

    # --- 親が最小化でもポップできるように ---
    def _prepare_parent_for_popup(self):
        state = None
        try:
            state = self.root.state()
        except Exception:
            state = "normal"
        need_restore = state in ("iconic", "withdrawn")
        orig_alpha = None
        if need_restore:
            try:
                orig_alpha = self.root.attributes("-alpha")
            except Exception:
                orig_alpha = None
            try:
                self.root.attributes("-alpha", 0.0)  # 透明
            except Exception:
                pass
            try:
                self.root.deiconify()
            except Exception:
                pass

        def restore():
            if need_restore:
                try:
                    if orig_alpha is not None:
                        self.root.attributes("-alpha", orig_alpha)
                except Exception:
                    pass
                try:
                    self.root.iconify()
                except Exception:
                    pass
        return restore

    # --- 表示先モニターの作業領域を取得 ---
    def _workarea_for_point(self, x, y):
        """(x,y) が属するモニターの作業領域(left, top, width, height)"""
        if not sys.platform.startswith("win"):
            return 0, 0, self.root.winfo_screenwidth(), self.root.winfo_screenheight()
        try:
            import ctypes
            from ctypes import wintypes, byref
            MONITOR_DEFAULTTONEAREST = 2
            user32 = ctypes.windll.user32

            class POINT(ctypes.Structure):
                _fields_ = [("x", wintypes.LONG), ("y", wintypes.LONG)]
            class RECT(ctypes.Structure):
                _fields_ = [("left", wintypes.LONG), ("top", wintypes.LONG),
                            ("right", wintypes.LONG), ("bottom", wintypes.LONG)]
            class MONITORINFO(ctypes.Structure):
                _fields_ = [("cbSize", wintypes.DWORD),
                            ("rcMonitor", RECT),
                            ("rcWork", RECT),
                            ("dwFlags", wintypes.DWORD)]

            pt = POINT(int(x), int(y))
            hmon = user32.MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST)
            mi = MONITORINFO()
            mi.cbSize = ctypes.sizeof(MONITORINFO)
            if user32.GetMonitorInfoW(hmon, byref(mi)):
                left = mi.rcWork.left
                top = mi.rcWork.top
                width = mi.rcWork.right - mi.rcWork.left
                height = mi.rcWork.bottom - mi.rcWork.top
                return left, top, width, height
        except Exception:
            pass
        return 0, 0, self.root.winfo_screenwidth(), self.root.winfo_screenheight()

    # --- 段積み列選択 ---
    def _choose_column_for_popup(self):
        col = min(range(self.tiling_cols), key=lambda i: self.tiling_next_y[i])
        x = POPUP_MARGIN + col * (self.popup_w + POPUP_MARGIN)
        y = self.tiling_next_y[col]
        return col, x, y

    # --- ボタン自動レイアウト（1行/2行/縦） ---
    def _layout_buttons(self, btns_frame: ttk.Frame, buttons, max_width: int) -> int:
        """
        ボタンを1行/2行/縦並びに自動レイアウトする。returns: 使用した行数
        """
        for w in btns_frame.grid_slaves():
            w.grid_forget()
        for i in range(10):
            try:
                btns_frame.grid_columnconfigure(i, weight=0)
            except Exception:
                pass

        btns_frame.update_idletasks()
        widths = [b.winfo_reqwidth() for b in buttons]
        gap = 8  # 左右余白合計の簡易見積もり

        # 1行で収まる？
        one_row = sum(widths) + gap * (len(buttons) + 1)
        if one_row <= max_width:
            for i, b in enumerate(buttons):
                b.grid(row=0, column=i, padx=4, pady=4, sticky="ew")
                btns_frame.grid_columnconfigure(i, weight=1)
            return 1

        # 2行で試す（上段に ceil(n/2) 個）
        n = len(buttons)
        k = (n + 1) // 2
        top_w = sum(widths[:k]) + gap * (k + 1)
        bot_w = sum(widths[k:]) + gap * (n - k + 1)
        if max(top_w, bot_w) <= max_width:
            for i, b in enumerate(buttons[:k]):
                b.grid(row=0, column=i, padx=4, pady=4, sticky="ew")
                btns_frame.grid_columnconfigure(i, weight=1)
            for i, b in enumerate(buttons[k:]):
                b.grid(row=1, column=i, padx=4, pady=4, sticky="ew")
                btns_frame.grid_columnconfigure(i, weight=1)
            return 2

        # 最終手段：縦並び（確実に切れない）
        for r, b in enumerate(buttons):
            b.grid(row=r, column=0, padx=4, pady=4, sticky="ew")
        btns_frame.grid_columnconfigure(0, weight=1)
        return n

    # --- ポップ表示 ---
    def _show_popup(self, task):
        restore_parent = self._prepare_parent_for_popup()
        col, x, y = self._choose_column_for_popup()

        popup = tk.Toplevel(self.root)
        popup.title("リマインダー")
        popup.attributes("-topmost", True)
        popup.geometry(f"+{int(x)}+{int(y)}")
        popup.lift()
        popup.after(120, lambda: popup.attributes("-topmost", True))

        try:
            self.root.bell()
        except Exception:
            pass

        outer = ttk.Frame(popup, padding=16)
        outer.pack(fill=tk.BOTH, expand=True)

        # 本文（スクロール可）
        content = ttk.Frame(outer)
        content.pack(fill=tk.BOTH, expand=True)

        msg = (
            f"件名: {task['title']}\n"
            f"優先度: {task['priority']}\n"
            f"締切: {task['deadline']}\n"
            f"繰り返し: {task.get('repeat','なし')}"
        )
        txt = tk.Text(content, wrap="word", height=8)
        txt.insert("1.0", msg)
        txt.configure(state="disabled")
        scy = ttk.Scrollbar(content, orient="vertical", command=txt.yview)
        txt.configure(yscrollcommand=scy.set)
        txt.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scy.pack(side=tk.RIGHT, fill=tk.Y)

        # ====== ボタン（自動改行レイアウト） ======
        btns = ttk.Frame(outer)
        btns.pack(fill=tk.X, pady=(12, 0))

        def _close_and_unregister():
            try:
                popup.destroy()
            finally:
                self.active_popups.pop(task["id"], None)

        def finish_and_close():
            if task.get("repeat", "なし") != "なし":
                cur = parse_deadline(task["deadline"])
                nxt = roll_forward_into_future(next_occurrence(cur, task["repeat"]), task["repeat"], now_local())
                task["deadline"] = format_deadline(nxt)
                task["completed"] = False
                task["snooze_until"] = None
                task["alerted"] = False
            else:
                task["completed"] = True
                task["snooze_until"] = None
                task["alerted"] = True
            self._save_data()
            self.refresh_view()
            _close_and_unregister()

        def snooze_and_close():
            next_time = now_local() + timedelta(minutes=SNOOZE_MINUTES)
            task["snooze_until"] = format_deadline(next_time)
            task["alerted"] = False
            self._save_data()
            self.refresh_view()
            _close_and_unregister()

        def skip_to_next_and_close():
            cur = parse_deadline(task["deadline"])
            nxt = roll_forward_into_future(next_occurrence(cur, task.get("repeat", "なし")),
                                           task.get("repeat", "なし"), now_local())
            task["deadline"] = format_deadline(nxt)
            task["completed"] = False
            task["snooze_until"] = None
            task["alerted"] = False
            self._save_data()
            self.refresh_view()
            _close_and_unregister()

        def just_close():
            repeat = task.get("repeat", "なし")
            if repeat != "なし":
                cur = parse_deadline(task["deadline"])
                nxt = roll_forward_into_future(next_occurrence(cur, repeat), repeat, now_local())
                task["deadline"] = format_deadline(nxt)
                task["completed"] = False
                task["snooze_until"] = None
                task["alerted"] = False
            else:
                task["alerted"] = True
            self._save_data()
            self.refresh_view()
            _close_and_unregister()

        btn_finish = ttk.Button(btns, text="完了にする", command=finish_and_close)
        btn_snooze = ttk.Button(btns, text=f"スヌーズ（{SNOOZE_MINUTES}分）", command=snooze_and_close)
        buttons = [btn_finish, btn_snooze]
        if task.get("repeat", "なし") != "なし":
            btn_skip = ttk.Button(btns, text="次回へ延期（繰り返し）", command=skip_to_next_and_close)
            buttons.append(btn_skip)
        btn_close = ttk.Button(btns, text="閉じる", command=just_close)
        buttons.append(btn_close)

        popup.update_idletasks()
        max_btnbar_width = self.popup_w - 2 * 16  # outer左右paddingを考慮
        _ = self._layout_buttons(btns, buttons, max_btnbar_width)

        # ====== 高さ・位置クランプ（ボタンは必ず画面内） ======
        popup.update_idletasks()
        wa_left, wa_top, wa_w, wa_h = self._workarea_for_point(x, y)
        safe_h_max = max(320, wa_h - 2 * POPUP_MARGIN)
        safe_top_min = wa_top + POPUP_MARGIN

        needed_h = outer.winfo_reqheight()
        if needed_h > safe_h_max:
            try:
                outer.configure(padding=12)
                popup.update_idletasks()
                needed_h = outer.winfo_reqheight()
            except Exception:
                pass

        used_h = min(needed_h, safe_h_max)
        max_top = wa_top + wa_h - POPUP_MARGIN - used_h
        y = max(safe_top_min, min(y, max_top))
        popup.geometry(f"{self.popup_w}x{int(used_h)}+{int(x)}+{int(y)}")

        # 段積み位置更新
        self.tiling_next_y[col] = max(self.tiling_next_y[col], y + used_h + POPUP_MARGIN)

        # 表示中登録
        self.active_popups[task["id"]] = popup

        popup.protocol("WM_DELETE_WINDOW", just_close)
        popup.bind("<Escape>", lambda e: just_close())

        # 親を元に戻す（必要時のみ）
        self.root.after(150, restore_parent)

# ========== 入力ダイアログ ==========
class TaskDialog:
    def __init__(self, master, title: str, on_ok, preset=None):
        self.top = tk.Toplevel(master)
        self.top.title(title)
        self.top.transient(master)
        self.top.grab_set()
        self.on_ok = on_ok
        try:
            self.top.geometry("+360+220")
        except Exception:
            pass

        frm = ttk.Frame(self.top, padding=16)
        frm.pack(fill=tk.BOTH, expand=True)

        ttk.Label(frm, text="内容:").grid(row=0, column=0, sticky="nw")
        self.txt_title = tk.Text(frm, height=5, wrap="word")
        self.txt_title.grid(row=0, column=1, columnspan=4, sticky="nsew", pady=4)
        scroll_y = ttk.Scrollbar(frm, orient="vertical", command=self.txt_title.yview)
        scroll_y.grid(row=0, column=5, sticky="ns")
        self.txt_title.configure(yscrollcommand=scroll_y.set)
        init_text = (preset or {}).get("title", "")
        if init_text:
            self.txt_title.insert("1.0", init_text)

        ttk.Label(frm, text="優先度:").grid(row=1, column=0, sticky="w")
        self.priority_var = tk.StringVar(value=(preset or {}).get("priority", "中"))
        self.cmb_priority = ttk.Combobox(frm, textvariable=self.priority_var, values=PRIORITY_VALUES, width=8, state="readonly")
        self.cmb_priority.grid(row=1, column=1, sticky="w", pady=4)

        ttk.Label(frm, text="繰り返し:").grid(row=1, column=2, sticky="w")
        self.repeat_var = tk.StringVar(value=(preset or {}).get("repeat", "なし"))
        self.cmb_repeat = ttk.Combobox(frm, textvariable=self.repeat_var, values=REPEAT_OPTIONS, width=10, state="readonly")
        self.cmb_repeat.grid(row=1, column=3, sticky="w", pady=4)

        ttk.Label(frm, text="締切:").grid(row=2, column=0, sticky="w")
        init_date = (preset or {}).get("date", date.today().strftime(DATE_FMT))
        self.date_var = tk.StringVar(value=init_date)
        self.ent_date = ttk.Entry(frm, textvariable=self.date_var, width=12)
        self.ent_date.grid(row=2, column=1, sticky="w", pady=4)
        ttk.Button(frm, text="📅 日付選択…", command=self.open_calendar).grid(row=2, column=2, sticky="w")

        ttk.Label(frm, text="時刻:").grid(row=3, column=0, sticky="w")
        init_time = (preset or {}).get("time", now_local().strftime(TIME_FMT))
        self.time_var = tk.StringVar(value=init_time)
        self.ent_time = ttk.Entry(frm, textvariable=self.time_var, width=8)
        self.ent_time.grid(row=3, column=1, sticky="w", pady=4)
        ttk.Label(frm, text="例: 09:30 / 17:45").grid(row=3, column=2, sticky="w")

        btns = ttk.Frame(frm)
        btns.grid(row=4, column=0, columnspan=6, pady=(12, 0), sticky="e")
        ttk.Button(btns, text="OK", command=self._ok).pack(side=tk.LEFT, padx=4)
        ttk.Button(btns, text="キャンセル", command=self._cancel).pack(side=tk.LEFT, padx=4)

        self.top.bind("<Control-Return>", lambda e: self._ok())
        self.top.bind("<Escape>", lambda e: self._cancel())

        self.txt_title.focus_set()
        frm.columnconfigure(1, weight=1)
        frm.rowconfigure(0, weight=1)

    def open_calendar(self):
        try:
            base_d = datetime.strptime(self.date_var.get().strip(), DATE_FMT).date()
        except Exception:
            base_d = date.today()
        CalendarPopup(self.top, init_date=base_d, on_pick=self._set_date_from_calendar)

    def _set_date_from_calendar(self, d: date):
        self.date_var.set(d.strftime(DATE_FMT))

    def _ok(self):
        title = self.txt_title.get("1.0", "end-1c").strip()
        priority = self.priority_var.get()
        date_str = self.date_var.get().strip()
        time_str = self.time_var.get().strip()
        repeat = self.repeat_var.get()

        if not title:
            messagebox.showwarning("入力不足", "内容を入力してください。")
            return
        if priority not in PRIORITY_VALUES:
            messagebox.showwarning("入力不足", "優先度を選択してください。")
            return
        if repeat not in REPEAT_OPTIONS:
            messagebox.showwarning("入力不足", "繰り返しを選択してください。")
            return
        try:
            datetime.strptime(date_str, DATE_FMT)
            datetime.strptime(time_str, TIME_FMT)
        except Exception:
            messagebox.showwarning(
                "入力エラー",
                f"日付または時刻の形式が正しくありません。\n"
                f"日付: YYYY/MM/DD 例 {date.today().strftime(DATE_FMT)} / "
                f"時刻: HH:MM 例 {now_local().strftime(TIME_FMT)}"
            )
            return

        self.on_ok(title, priority, date_str, time_str, repeat)
        self.top.destroy()

    def _cancel(self):
        self.top.destroy()

# ========== エントリポイント ==========
def _windows_dpi_awareness():
    try:
        if sys.platform.startswith("win"):
            from ctypes import windll
            windll.shcore.SetProcessDpiAwareness(1)
    except Exception:
        pass

def main():
    try:
        _windows_dpi_awareness()
        root = tk.Tk()
        apply_global_font_scaling(base_pt=16, heading_delta=3)
        app = TodoApp(root)
        if "--minimized" in sys.argv or "-m" in sys.argv:
            root.update_idletasks()
            root.iconify()
        root.mainloop()
    except Exception:
        traceback.print_exc()
        try:
            messagebox.showerror("起動エラー", "アプリ起動中にエラーが発生しました。コンソールのトレースバックをご確認ください。")
        except Exception:
            pass

if __name__ == "__main__":
    main()