#!/usr/bin/env python3
"""
config_tui.py — Interactive ncurses-based configuration editor for meshcore-bot.

Features:
  • Read an existing config.ini or create one from config.ini.example
  • Resize-aware layout — redraws correctly when terminal is resized
  • Browse sections and keys with arrow-key navigation
  • Edit values in-place with a full-featured line editor
  • Help overlay (?) shows description + example lines for the current key
  • Validate config against known required/optional keys (v)
  • Migrate config to newer schema — add missing keys from example (m)
  • Save (s), quit with unsaved-changes guard (q / Esc)

Usage:
    python3 scripts/config_tui.py [config.ini]
    python3 scripts/config_tui.py        # auto-detects config.ini in project root

Navigation:
    ↑ / ↓          move between keys in current section
    ← / →  or Tab  previous / next section
    Enter          edit selected value
    ?              help for current key (description + example from config.ini.example)
    s              save
    v              validate (show errors / warnings)
    m              migrate (add missing keys/sections from example)
    q / Esc        quit (asks to save if unsaved changes)
"""

import configparser
import curses
import os
import re
import sys
import textwrap
from pathlib import Path
from typing import Dict, List, Optional, Tuple


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------

def find_project_root() -> Path:
    try:
        here = Path(__file__).resolve().parent
        for candidate in [here, here.parent, here.parent.parent]:
            if (candidate / "pyproject.toml").exists() or (candidate / "meshcore_bot.py").exists():
                return candidate
        return here.parent
    except Exception:
        return Path.cwd()


def load_config(path: Path) -> configparser.ConfigParser:
    cfg = configparser.ConfigParser(allow_no_value=True, inline_comment_prefixes=None)
    cfg.optionxform = str  # preserve case
    if path.exists():
        try:
            cfg.read(str(path), encoding="utf-8")
        except (configparser.Error, IOError, OSError, UnicodeDecodeError) as e:
            # Return empty config rather than crash; caller may show a warning
            cfg._load_error = str(e)  # type: ignore[attr-defined]
    return cfg


def load_example_comments(example_path: Path) -> Dict[str, Dict[str, str]]:
    """Parse config.ini.example — return {section: {key: comment_text}}."""
    comments: Dict[str, Dict[str, str]] = {}
    if not example_path.exists():
        return comments
    try:
        current_section = ""
        pending: List[str] = []
        with open(example_path, encoding="utf-8", errors="replace") as fh:
            for line in fh:
                stripped = line.strip()
                if stripped.startswith("[") and stripped.endswith("]"):
                    current_section = stripped[1:-1]
                    comments.setdefault(current_section, {})
                    pending = []
                elif stripped.startswith("#"):
                    pending.append(stripped[1:].strip())
                elif "=" in stripped and not stripped.startswith("#"):
                    key = stripped.split("=", 1)[0].strip()
                    if current_section and pending:
                        comments.setdefault(current_section, {})[key] = " ".join(pending)
                    pending = []
                else:
                    pending = []
    except (IOError, OSError, UnicodeDecodeError):
        pass
    return comments


def load_example_lines(example_path: Path) -> Dict[str, Dict[str, str]]:
    """Return {section: {key: 'full raw line from example'}}."""
    lines: Dict[str, Dict[str, str]] = {}
    if not example_path.exists():
        return lines
    try:
        current_section = ""
        with open(example_path, encoding="utf-8", errors="replace") as fh:
            for line in fh:
                stripped = line.strip()
                if stripped.startswith("[") and stripped.endswith("]"):
                    current_section = stripped[1:-1]
                    lines.setdefault(current_section, {})
                elif "=" in stripped and not stripped.startswith("#"):
                    key = stripped.split("=", 1)[0].strip()
                    if current_section:
                        lines.setdefault(current_section, {})[key] = stripped
    except (IOError, OSError, UnicodeDecodeError):
        pass
    return lines


def load_example_keys(example_path: Path) -> Dict[str, Dict[str, str]]:
    """Return {section: {key: default_value}} from config.ini.example."""
    keys: Dict[str, Dict[str, str]] = {}
    if not example_path.exists():
        return keys
    try:
        cfg = configparser.ConfigParser(allow_no_value=True)
        cfg.optionxform = str
        cfg.read(str(example_path), encoding="utf-8")
        for section in cfg.sections():
            try:
                keys[section] = dict(cfg.items(section))
            except configparser.Error:
                keys[section] = {}
    except (configparser.Error, IOError, OSError, UnicodeDecodeError):
        pass
    return keys


def validate_config(
    cfg: configparser.ConfigParser,
    example_keys: Dict[str, Dict[str, str]],
) -> List[Tuple[str, str, str]]:
    """Return list of (severity, section, message) issues."""
    issues: List[Tuple[str, str, str]] = []
    try:
        required = {
            "Connection": {"connection_type"},
            "Bot": {"bot_name"},
        }
        for section, req_keys in required.items():
            if not cfg.has_section(section):
                issues.append(("ERROR", section, f"Section [{section}] is missing"))
                continue
            for key in req_keys:
                if not cfg.has_option(section, key):
                    issues.append(("ERROR", section, f"Required key '{key}' is missing"))
        for section in cfg.sections():
            if section not in example_keys:
                continue
            try:
                section_opts = cfg.options(section)
            except configparser.Error:
                continue
            for key in section_opts:
                if key not in example_keys.get(section, {}):
                    issues.append(("WARNING", section, f"Unknown key '{key}' (not in example)"))
        for section in example_keys:
            if not cfg.has_section(section):
                issues.append(("INFO", section, f"Optional section [{section}] not configured"))
    except Exception as e:
        issues.append(("ERROR", "", f"Validation error: {e}"))
    if not issues:
        issues.append(("INFO", "", "Config looks good — no errors found"))
    return issues


def migrate_config(
    cfg: configparser.ConfigParser,
    example_keys: Dict[str, Dict[str, str]],
    example_comments: Dict[str, Dict[str, str]],
) -> List[str]:
    changes: List[str] = []
    for section, keys in example_keys.items():
        if not cfg.has_section(section):
            try:
                cfg.add_section(section)
                changes.append(f"Added section [{section}]")
            except configparser.DuplicateSectionError:
                pass
            except configparser.Error as e:
                changes.append(f"Error adding [{section}]: {e}")
                continue
        for key, default in keys.items():
            if not cfg.has_option(section, key):
                try:
                    cfg.set(section, key, default or "")
                    changes.append(f"Added [{section}] {key} = {default!r}")
                except configparser.Error as e:
                    changes.append(f"Error setting [{section}] {key}: {e}")
    return changes


def save_config(cfg: configparser.ConfigParser, path: Path) -> None:
    try:
        path.parent.mkdir(parents=True, exist_ok=True)
    except (IOError, OSError, PermissionError) as e:
        raise IOError(f"Cannot create directory {path.parent}: {e}") from e
    try:
        with open(path, "w", encoding="utf-8") as fh:
            cfg.write(fh)
    except (IOError, OSError, PermissionError) as e:
        raise IOError(f"Cannot write {path}: {e}") from e


# ---------------------------------------------------------------------------
# TUI state
# ---------------------------------------------------------------------------

class TUIState:
    def __init__(
        self,
        cfg: configparser.ConfigParser,
        path: Path,
        example_keys: Dict[str, Dict[str, str]],
        example_comments: Dict[str, Dict[str, str]],
        example_lines: Dict[str, Dict[str, str]],
    ) -> None:
        self.cfg = cfg
        self.path = path
        self.example_keys = example_keys
        self.example_comments = example_comments
        self.example_lines = example_lines
        self.dirty = False
        self.sections: List[str] = []
        try:
            self.sections = cfg.sections()
        except Exception:
            self.sections = []
        self.section_idx = 0
        self.key_idx = 0
        self.focus: str = "sections"  # "sections" or "keys"
        self.status_msg = ""
        self.status_attr = 0

    def current_section(self) -> str:
        if not self.sections or self.section_idx >= len(self.sections):
            return ""
        return self.sections[self.section_idx]

    def current_keys(self) -> List[str]:
        s = self.current_section()
        if not s:
            return []
        try:
            if self.cfg.has_section(s):
                return list(self.cfg.options(s))
        except configparser.Error:
            pass
        return []

    def clamp(self) -> None:
        if self.sections:
            self.section_idx = max(0, min(self.section_idx, len(self.sections) - 1))
        else:
            self.section_idx = 0
        keys = self.current_keys()
        if keys:
            self.key_idx = max(0, min(self.key_idx, len(keys) - 1))
        else:
            self.key_idx = 0

    def set_status(self, msg: str, error: bool = False) -> None:
        self.status_msg = msg
        try:
            self.status_attr = curses.color_pair(3) if error else curses.color_pair(2)
        except Exception:
            self.status_attr = 0


# ---------------------------------------------------------------------------
# Drawing helpers
# ---------------------------------------------------------------------------

def _safe_addstr(win, row: int, col: int, text: str, attr: int = 0) -> None:
    """addstr that silently ignores out-of-bounds writes."""
    try:
        h, w = win.getmaxyx()
        if row < 0 or row >= h or col < 0 or col >= w:
            return
        available = w - col - 1
        if available <= 0:
            return
        if attr:
            win.addstr(row, col, text[:available], attr)
        else:
            win.addstr(row, col, text[:available])
    except curses.error:
        pass
    except Exception:
        pass


def _color(pair: int, fallback: int = 0) -> int:
    """Return color_pair(pair), falling back to fallback on terminals without color."""
    try:
        return curses.color_pair(pair)
    except Exception:
        return fallback


def draw_header(win, path: Path, dirty: bool) -> None:
    try:
        h, w = win.getmaxyx()
        flag = " [modified]" if dirty else ""
        header = f"  meshcore-bot config — {path.name}{flag}"
        _safe_addstr(win, 0, 0, header.ljust(w - 1), _color(1) | curses.A_BOLD)
    except Exception:
        pass


def draw_footer(win, state: TUIState) -> None:
    try:
        h, w = win.getmaxyx()
        if state.status_msg and h > 2:
            _safe_addstr(win, h - 2, 0, f" {state.status_msg} ".ljust(w - 1), state.status_attr)
        if state.focus == "sections":
            help_line = "  ↑↓:section  Tab/→:keys pane  PgUp/Dn:cycle sections  Enter:select  s:save  q:quit"
        else:
            help_line = "  ↑↓:key  Tab/←:sections  Enter:edit  r:rename  a:add  d:delete  ?:help  s:save  v:validate  m:migrate  q:quit"
        if h > 1:
            _safe_addstr(win, h - 1, 0, help_line.ljust(w - 1), _color(1))
    except Exception:
        pass


def draw_sections_pane(win, state: TUIState, top: int, left: int, height: int, width: int, scroll: int) -> int:
    """Draw sections list. Returns updated scroll offset."""
    try:
        if state.section_idx < scroll:
            scroll = state.section_idx
        if state.section_idx >= scroll + height:
            scroll = state.section_idx - height + 1

        focused = (state.focus == "sections")
        for i, section in enumerate(state.sections):
            vis = i - scroll
            if vis < 0 or vis >= height:
                continue
            row = top + vis
            label = f" [{section}] "
            if i == state.section_idx:
                if focused:
                    _safe_addstr(win, row, left, label.ljust(width), _color(4) | curses.A_BOLD)
                else:
                    # Dimmer selection indicator when pane is not focused
                    _safe_addstr(win, row, left, label.ljust(width), curses.A_BOLD)
            else:
                _safe_addstr(win, row, left, label.ljust(width))
    except Exception:
        pass
    return scroll


def draw_keys_pane(
    win, state: TUIState, top: int, left: int, height: int, width: int, scroll: int
) -> int:
    """Draw keys pane. Returns updated scroll offset."""
    try:
        keys = state.current_keys()
        if not keys:
            _safe_addstr(win, top, left, " (no keys) ")
            return 0

        if state.key_idx < scroll:
            scroll = state.key_idx
        if state.key_idx >= scroll + height:
            scroll = state.key_idx - height + 1

        section = state.current_section()
        ex_sec = state.example_keys.get(section, {})
        # Dynamic sections (no fixed keys in example) — never flag keys as unknown
        dynamic_section = section in state.example_keys and not ex_sec

        for i, key in enumerate(keys):
            vis = i - scroll
            if vis < 0 or vis >= height:
                continue
            row = top + vis
            try:
                val = state.cfg.get(section, key, fallback="")
            except configparser.Error:
                val = "(error)"
            in_example = dynamic_section or key in ex_sec
            marker = " " if in_example else "?"
            line = f"{marker} {key} = {val}"

            if i == state.key_idx:
                _safe_addstr(win, row, left, line.ljust(width), _color(5) | curses.A_BOLD)
            elif not in_example:
                _safe_addstr(win, row, left, line, _color(3))
            else:
                _safe_addstr(win, row, left, line)
    except Exception:
        pass
    return scroll


def draw_status_bar(win, state: TUIState, top: int, left: int, width: int, attr: int = 0) -> None:
    """Show section count / key count in the keys pane title bar."""
    try:
        section = state.current_section()
        keys = state.current_keys()
        n_sec = len(state.sections)
        n_key = len(keys)
        focus_marker = ">" if state.focus == "keys" else " "
        title = f"{focus_marker}[{section}]  key {state.key_idx + 1}/{n_key}  (section {state.section_idx + 1}/{n_sec}) "
        _safe_addstr(win, top, left, title.ljust(width), attr or _color(1))
    except Exception:
        pass


def draw_hint_line(win, state: TUIState, top: int, left: int, width: int) -> None:
    """Show a one-line hint for the selected key below the keys pane."""
    try:
        section = state.current_section()
        keys = state.current_keys()
        if not keys or state.key_idx >= len(keys):
            return
        key = keys[state.key_idx]
        comment = state.example_comments.get(section, {}).get(key, "")
        max_w = max(4, width - 3)
        if comment and len(comment) > max_w:
            hint = textwrap.shorten(comment, max_w, placeholder="…")
        elif comment:
            hint = comment
        else:
            hint = "(no description — press ? for full help)"
        _safe_addstr(win, top, left, f"  {hint}", _color(2))
    except Exception:
        pass


# ---------------------------------------------------------------------------
# Overlays
# ---------------------------------------------------------------------------

def show_overlay(stdscr, title: str, items: List[Tuple[str, str, str]]) -> None:
    """Generic scrollable list overlay. Items: (tag, section, message)."""
    try:
        curses.curs_set(0)
    except curses.error:
        pass
    scroll = 0
    while True:
        try:
            h, w = stdscr.getmaxyx()
        except curses.error:
            return

        if h < 6 or w < 20:
            try:
                stdscr.getch()
            except curses.error:
                pass
            return

        oh = max(4, min(h - 4, max(10, len(items) + 4)))
        ow = max(10, min(w - 4, 92))
        dy = max(0, (h - oh) // 2)
        dx = max(0, (w - ow) // 2)

        # Ensure window fits within screen
        if dy + oh > h:
            oh = h - dy
        if dx + ow > w:
            ow = w - dx
        if oh < 4 or ow < 10:
            try:
                stdscr.getch()
            except curses.error:
                pass
            return

        try:
            win = curses.newwin(oh, ow, dy, dx)
        except curses.error:
            try:
                stdscr.getch()
            except curses.error:
                pass
            return

        try:
            win.keypad(True)
            win.clear()
            try:
                win.border()
            except curses.error:
                pass
            _safe_addstr(win, 0, 2, f" {title} (↑↓:scroll  q/Esc/Enter:close) ", _color(1))
            visible = max(1, oh - 2)
            for i, (tag, sec, msg) in enumerate(items):
                vis = i - scroll
                if vis < 0 or vis >= visible:
                    continue
                row = 1 + vis
                if tag == "ERROR":
                    attr = _color(3)
                elif tag == "WARNING":
                    attr = _color(6)
                else:
                    attr = _color(2)
                label = f" [{tag}] {sec}: {msg}" if sec else f" [{tag}] {msg}"
                _safe_addstr(win, row, 1, label, attr)
            win.refresh()
        except curses.error:
            pass

        try:
            ch = win.getch()
        except curses.error:
            ch = -1

        try:
            del win
            stdscr.touchwin()
        except curses.error:
            pass

        if ch == curses.KEY_RESIZE:
            scroll = 0
            continue
        elif ch in (ord("q"), ord("Q"), 27, 10, 13, curses.KEY_ENTER):
            break
        elif ch == curses.KEY_DOWN:
            scroll = min(scroll + 1, max(0, len(items) - visible))
        elif ch == curses.KEY_UP:
            scroll = max(0, scroll - 1)
        elif ch == curses.KEY_NPAGE:
            scroll = min(scroll + visible, max(0, len(items) - visible))
        elif ch == curses.KEY_PPAGE:
            scroll = max(0, scroll - visible)

    try:
        stdscr.touchwin()
    except curses.error:
        pass


def show_key_help(stdscr, state: TUIState) -> None:
    """Show full help for the currently selected key."""
    try:
        section = state.current_section()
        keys = state.current_keys()
        if not keys or state.key_idx >= len(keys):
            return
        key = keys[state.key_idx]
        comment = state.example_comments.get(section, {}).get(key, "(no description available)")
        example = state.example_lines.get(section, {}).get(key, "")
        try:
            current_val = state.cfg.get(section, key, fallback="")
        except configparser.Error:
            current_val = "(error reading value)"
        default_val = state.example_keys.get(section, {}).get(key, "")

        lines: List[Tuple[str, str, str]] = [
            ("INFO", "Section", section),
            ("INFO", "Key", key),
            ("INFO", "Current value", repr(current_val)),
            ("INFO", "Default (example)", repr(default_val)),
            ("INFO", "", ""),
            ("INFO", "Description", ""),
        ]
        for para in textwrap.wrap(comment, 72) or ["(none)"]:
            lines.append(("INFO", "", f"  {para}"))
        if example:
            lines.append(("INFO", "", ""))
            lines.append(("INFO", "Example line", ""))
            lines.append(("INFO", "", f"  {example}"))

        show_overlay(stdscr, f"Help: [{section}] {key}", lines)
    except Exception as e:
        state.set_status(f"Help error: {e}", error=True)


# ---------------------------------------------------------------------------
# Inline editor
# ---------------------------------------------------------------------------

_EDIT_VALUE_DEPTH = 0
_EDIT_VALUE_MAX_DEPTH = 20


def edit_value(stdscr, prompt: str, current: str) -> Optional[str]:
    """One-line editor dialog. Returns new value or None if cancelled."""
    global _EDIT_VALUE_DEPTH
    _EDIT_VALUE_DEPTH += 1
    if _EDIT_VALUE_DEPTH > _EDIT_VALUE_MAX_DEPTH:
        _EDIT_VALUE_DEPTH -= 1
        return None

    try:
        return _edit_value_impl(stdscr, prompt, current)
    finally:
        _EDIT_VALUE_DEPTH -= 1


def _edit_value_impl(stdscr, prompt: str, current: str) -> Optional[str]:
    while True:
        try:
            h, w = stdscr.getmaxyx()
        except curses.error:
            return None

        dw = max(30, min(w - 4, 84))
        dh = 6
        dy = max(0, (h - dh) // 2)
        dx = max(0, (w - dw) // 2)

        if dy + dh > h or dx + dw > w or dh < 4 or dw < 10:
            return None

        try:
            win = curses.newwin(dh, dw, dy, dx)
        except curses.error:
            return None

        try:
            win.keypad(True)
        except curses.error:
            pass

        try:
            try:
                win.border()
            except curses.error:
                pass
            _safe_addstr(win, 0, 2, " Edit Value ", _color(1) | curses.A_BOLD)
            _safe_addstr(win, 1, 2, prompt[:dw - 4])
            _safe_addstr(win, 2, 2, "─" * max(0, dw - 4))
            _safe_addstr(win, 4, 2, "Enter=confirm   Esc=cancel   Ctrl-A=home   Ctrl-E=end   Ctrl-K=clear", _color(2))
            win.refresh()
        except curses.error:
            pass

        buf = list(current)
        pos = len(buf)
        inner_w = max(1, dw - 4)
        result: Optional[str] = None

        try:
            curses.curs_set(1)
        except curses.error:
            pass

        def redraw_input() -> None:
            try:
                win.move(3, 2)
                win.clrtoeol()
                start = max(0, pos - inner_w + 1)
                display = "".join(buf)[start:start + inner_w]
                cursor_col = pos - start
                try:
                    win.addstr(3, 2, display)
                    win.move(3, 2 + cursor_col)
                except curses.error:
                    pass
                win.refresh()
            except curses.error:
                pass

        try:
            redraw_input()
        except Exception:
            pass

        done = False
        resize_requested = False
        while not done:
            try:
                ch = win.getch()
            except curses.error:
                done = True
                break

            if ch == curses.KEY_RESIZE:
                resize_requested = True
                done = True
            elif ch in (curses.KEY_ENTER, 10, 13):
                result = "".join(buf)
                done = True
            elif ch == 27:  # Esc
                done = True
            elif ch in (curses.KEY_BACKSPACE, 127, 8):
                if pos > 0:
                    buf.pop(pos - 1)
                    pos -= 1
            elif ch == curses.KEY_DC:
                if pos < len(buf):
                    buf.pop(pos)
            elif ch == curses.KEY_LEFT:
                pos = max(0, pos - 1)
            elif ch == curses.KEY_RIGHT:
                pos = min(len(buf), pos + 1)
            elif ch == curses.KEY_HOME or ch == 1:  # Ctrl-A
                pos = 0
            elif ch == curses.KEY_END or ch == 5:  # Ctrl-E
                pos = len(buf)
            elif ch == 11:  # Ctrl-K — clear to end
                buf = buf[:pos]
            elif ch == 21:  # Ctrl-U — clear whole line
                buf = []
                pos = 0
            elif 32 <= ch < 256:
                try:
                    buf.insert(pos, chr(ch))
                    pos += 1
                except Exception:
                    pass
            if not done:
                try:
                    redraw_input()
                except Exception:
                    pass

        try:
            curses.curs_set(0)
        except curses.error:
            pass
        try:
            del win
            stdscr.touchwin()
            stdscr.refresh()
        except curses.error:
            pass

        if resize_requested:
            # Terminal resized during edit — restart dialog preserving buffer
            return edit_value(stdscr, prompt, "".join(buf))

        return result


# ---------------------------------------------------------------------------
# Key management helpers (add / rename / delete)
# ---------------------------------------------------------------------------

def action_add_key(stdscr, state: TUIState) -> None:
    """Prompt for a new key name and value, then add it to the current section."""
    section = state.current_section()
    if not section:
        return
    new_key = edit_value(stdscr, f"[{section}]  New key name", "")
    if not new_key:
        state.set_status("Add cancelled — no key name entered")
        return
    new_key = new_key.strip()
    if not new_key:
        state.set_status("Add cancelled — key name was blank")
        return
    if state.cfg.has_option(section, new_key):
        state.set_status(f"Key '{new_key}' already exists", error=True)
        return
    new_val = edit_value(stdscr, f"[{section}]  {new_key}  (value)", "")
    if new_val is None:
        state.set_status("Add cancelled")
        return
    try:
        state.cfg.set(section, new_key, new_val)
        state.dirty = True
        # Move selection to the newly added key
        keys = list(state.cfg.options(section))
        try:
            state.key_idx = keys.index(new_key)
        except ValueError:
            pass
        state.set_status(f"Added [{section}] {new_key}")
    except configparser.Error as e:
        state.set_status(f"Cannot add key: {e}", error=True)


def action_rename_key(stdscr, state: TUIState) -> None:
    """Rename the currently selected key (useful to change a scheduled-message time)."""
    section = state.current_section()
    keys = state.current_keys()
    if not keys or state.key_idx >= len(keys):
        return
    old_key = keys[state.key_idx]
    new_key = edit_value(stdscr, f"[{section}]  Rename key (was: {old_key})", old_key)
    if new_key is None:
        state.set_status("Rename cancelled")
        return
    new_key = new_key.strip()
    if not new_key or new_key == old_key:
        state.set_status("Rename cancelled — unchanged")
        return
    if state.cfg.has_option(section, new_key):
        state.set_status(f"Key '{new_key}' already exists", error=True)
        return
    try:
        old_val = state.cfg.get(section, old_key, fallback="")
    except configparser.Error:
        old_val = ""
    try:
        state.cfg.remove_option(section, old_key)
        state.cfg.set(section, new_key, old_val)
        state.dirty = True
        # Re-select the renamed key
        new_keys = list(state.cfg.options(section))
        try:
            state.key_idx = new_keys.index(new_key)
        except ValueError:
            state.key_idx = max(0, min(state.key_idx, len(new_keys) - 1))
        state.set_status(f"Renamed '{old_key}' → '{new_key}'")
    except configparser.Error as e:
        state.set_status(f"Cannot rename key: {e}", error=True)


def action_delete_key(stdscr, state: TUIState) -> None:
    """Delete the currently selected key after confirmation."""
    section = state.current_section()
    keys = state.current_keys()
    if not keys or state.key_idx >= len(keys):
        return
    key = keys[state.key_idx]
    if not confirm(stdscr, f"Delete [{section}] {key}?"):
        state.set_status("Delete cancelled")
        return
    try:
        state.cfg.remove_option(section, key)
        state.dirty = True
        new_keys = state.current_keys()
        state.key_idx = max(0, min(state.key_idx, len(new_keys) - 1))
        state.set_status(f"Deleted [{section}] {key}")
    except configparser.Error as e:
        state.set_status(f"Cannot delete key: {e}", error=True)


# ---------------------------------------------------------------------------
# Confirmation dialog
# ---------------------------------------------------------------------------

def confirm(stdscr, question: str) -> bool:
    """Y/N prompt. Returns True if user presses y/Y."""
    try:
        h, w = stdscr.getmaxyx()
        dw = max(20, min(w - 4, 60))
        dh = 4
        dy = max(0, (h - dh) // 2)
        dx = max(0, (w - dw) // 2)

        if dy + dh > h or dx + dw > w:
            return False

        try:
            win = curses.newwin(dh, dw, dy, dx)
        except curses.error:
            return False

        try:
            try:
                win.border()
            except curses.error:
                pass
            _safe_addstr(win, 1, 2, question[:dw - 4], _color(6) | curses.A_BOLD)
            _safe_addstr(win, 2, 2, "Press Y to confirm, any other key to cancel.", _color(2))
            win.refresh()
            ch = win.getch()
        except curses.error:
            ch = -1
        finally:
            try:
                del win
                stdscr.touchwin()
                stdscr.refresh()
            except curses.error:
                pass

        return ch in (ord("y"), ord("Y"))
    except Exception:
        return False


# ---------------------------------------------------------------------------
# Main TUI loop
# ---------------------------------------------------------------------------

def tui_main(stdscr, state: TUIState) -> None:
    try:
        curses.curs_set(0)
    except curses.error:
        pass

    try:
        curses.start_color()
        curses.use_default_colors()
        curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLUE)    # header / footer / titles
        curses.init_pair(2, curses.COLOR_BLACK, curses.COLOR_GREEN)   # ok / hint / status
        curses.init_pair(3, curses.COLOR_WHITE, curses.COLOR_RED)     # error / unknown key
        curses.init_pair(4, curses.COLOR_BLACK, curses.COLOR_CYAN)    # selected section
        curses.init_pair(5, curses.COLOR_BLACK, curses.COLOR_YELLOW)  # selected key
        curses.init_pair(6, curses.COLOR_BLACK, curses.COLOR_YELLOW)  # warning / confirm
    except curses.error:
        pass  # monochrome terminal — continue without color

    try:
        stdscr.keypad(True)
    except curses.error:
        pass

    # Per-pane scroll offsets
    sec_scroll = 0
    key_scroll = 0

    while True:
        try:
            stdscr.clear()
            h, w = stdscr.getmaxyx()
        except curses.error:
            continue

        if h < 12 or w < 50:
            _safe_addstr(stdscr, 0, 0, "Terminal too small — resize and press any key")
            try:
                stdscr.refresh()
                stdscr.getch()
            except curses.error:
                pass
            continue

        # ── Layout ──────────────────────────────────────────────────────────
        #  Row 0            : header
        #  Row 1            : section pane title | keys pane title bar
        #  Rows 2..body_h+1 : section list | keys list  (body_h rows)
        #  body_h+2         : hint line
        #  h-2              : status message
        #  h-1              : key bindings footer
        # Total: 1+1+body_h+1+1+1 = body_h+5 = h  →  body_h = h-5

        section_w = max(16, min(26, w // 5))
        divider = section_w          # column of the vertical divider
        keys_left = divider + 1
        keys_w = max(1, w - keys_left - 1)

        body_h = max(1, h - 5)       # rows of pane content
        hint_row = body_h + 2        # one row below the last pane row

        # ── Draw phase — wrapped so a single bad render doesn't abort ───────
        try:
            draw_header(stdscr, state.path, state.dirty)
            sec_title_attr = (_color(1) | curses.A_BOLD) if state.focus == "sections" else _color(1)
            keys_title_attr = (_color(1) | curses.A_BOLD) if state.focus == "keys" else _color(1)
            focus_marker = ">" if state.focus == "sections" else " "
            _safe_addstr(stdscr, 1, 0, f"{focus_marker}Sections ({len(state.sections)}) ".ljust(section_w), sec_title_attr)
            draw_status_bar(stdscr, state, 1, keys_left, keys_w, keys_title_attr)

            for row in range(2, body_h + 2):
                _safe_addstr(stdscr, row, divider, "│")

            sec_scroll = draw_sections_pane(stdscr, state, 2, 0, body_h, section_w, sec_scroll)
            key_scroll = draw_keys_pane(stdscr, state, 2, keys_left, body_h, keys_w, key_scroll)
            draw_hint_line(stdscr, state, hint_row, 0, w)
            draw_footer(stdscr, state)
        except curses.error:
            pass
        except Exception:
            pass

        try:
            stdscr.refresh()
        except curses.error:
            pass

        # ── Input ─────────────────────────────────────────────────────────────
        try:
            ch = stdscr.getch()
        except curses.error:
            continue
        except KeyboardInterrupt:
            if state.dirty:
                try:
                    if confirm(stdscr, "Unsaved changes — quit without saving?"):
                        break
                except Exception:
                    break
            else:
                break
            continue

        if ch == curses.KEY_RESIZE:
            key_scroll = 0
            sec_scroll = 0
            state.status_msg = ""

        # ── Tab: toggle focus between panes ─────────────────────────────────
        elif ch in (ord("\t"), curses.KEY_BTAB):
            if ch == curses.KEY_BTAB or state.focus == "keys":
                state.focus = "sections"
            else:
                state.focus = "keys"
            state.status_msg = ""

        # ── Arrow up/down: navigate within the focused pane ─────────────────
        elif ch == curses.KEY_UP:
            if state.focus == "sections":
                state.section_idx = max(0, state.section_idx - 1)
                state.key_idx = 0
                key_scroll = 0
            else:
                state.key_idx = max(0, state.key_idx - 1)
            state.status_msg = ""

        elif ch == curses.KEY_DOWN:
            if state.focus == "sections":
                state.section_idx = min(max(0, len(state.sections) - 1), state.section_idx + 1)
                state.key_idx = 0
                key_scroll = 0
            else:
                keys = state.current_keys()
                if keys:
                    state.key_idx = min(len(keys) - 1, state.key_idx + 1)
            state.status_msg = ""

        # ── Left: from keys pane → focus sections pane ──────────────────────
        elif ch == curses.KEY_LEFT:
            if state.focus == "keys":
                state.focus = "sections"
            else:
                # Already in sections pane — cycle to previous section
                state.section_idx = (state.section_idx - 1) % max(1, len(state.sections))
                state.key_idx = 0
                key_scroll = 0
            state.status_msg = ""

        # ── Right: from sections pane → focus keys pane ─────────────────────
        elif ch == curses.KEY_RIGHT:
            if state.focus == "sections":
                state.focus = "keys"
            else:
                # Already in keys pane — cycle to next section
                state.section_idx = (state.section_idx + 1) % max(1, len(state.sections))
                state.key_idx = 0
                key_scroll = 0
            state.status_msg = ""

        # ── PgUp/PgDn: cycle sections from either pane ──────────────────────
        elif ch == curses.KEY_PPAGE:
            state.section_idx = (state.section_idx - 1) % max(1, len(state.sections))
            state.key_idx = 0
            key_scroll = 0
            state.status_msg = ""

        elif ch == curses.KEY_NPAGE:
            state.section_idx = (state.section_idx + 1) % max(1, len(state.sections))
            state.key_idx = 0
            key_scroll = 0
            state.status_msg = ""

        elif ch in (curses.KEY_HOME,):
            state.section_idx = 0
            state.key_idx = 0
            key_scroll = sec_scroll = 0

        # ── Enter: on sections pane → move focus to keys; on keys → edit ────
        elif ch in (curses.KEY_ENTER, 10, 13):
            if state.focus == "sections":
                state.focus = "keys"
                state.status_msg = ""
            else:
                try:
                    section = state.current_section()
                    keys = state.current_keys()
                    if keys and state.key_idx < len(keys):
                        key = keys[state.key_idx]
                        try:
                            current_val = state.cfg.get(section, key, fallback="")
                        except configparser.Error:
                            current_val = ""
                        new_val = edit_value(stdscr, f"[{section}]  {key}", current_val)
                        if new_val is not None and new_val != current_val:
                            try:
                                state.cfg.set(section, key, new_val)
                                state.dirty = True
                                state.set_status(f"Updated [{section}] {key}")
                            except configparser.Error as e:
                                state.set_status(f"Cannot set value: {e}", error=True)
                except Exception as e:
                    state.set_status(f"Edit error: {e}", error=True)

        elif ch in (ord("?"),):
            try:
                show_key_help(stdscr, state)
            except Exception as e:
                state.set_status(f"Help error: {e}", error=True)

        elif ch in (ord("a"), ord("A")):
            if state.focus == "keys":
                try:
                    action_add_key(stdscr, state)
                except Exception as e:
                    state.set_status(f"Add error: {e}", error=True)

        elif ch in (ord("r"), ord("R")):
            if state.focus == "keys":
                try:
                    action_rename_key(stdscr, state)
                except Exception as e:
                    state.set_status(f"Rename error: {e}", error=True)

        elif ch in (ord("d"), ord("D"), curses.KEY_DC):
            if state.focus == "keys":
                try:
                    action_delete_key(stdscr, state)
                except Exception as e:
                    state.set_status(f"Delete error: {e}", error=True)

        elif ch in (ord("s"), ord("S")):
            try:
                save_config(state.cfg, state.path)
                state.dirty = False
                state.set_status(f"Saved → {state.path}")
            except Exception as e:
                state.set_status(f"Save failed: {e}", error=True)

        elif ch in (ord("v"), ord("V")):
            try:
                issues = validate_config(state.cfg, state.example_keys)
                show_overlay(stdscr, "Validation Results", issues)
            except Exception as e:
                state.set_status(f"Validate error: {e}", error=True)

        elif ch in (ord("m"), ord("M")):
            try:
                changes = migrate_config(state.cfg, state.example_keys, state.example_comments)
                try:
                    state.sections = state.cfg.sections()
                except Exception:
                    pass
                if changes:
                    state.dirty = True
                    show_overlay(
                        stdscr,
                        f"Migration — {len(changes)} change(s)",
                        [("INFO", "", c) for c in changes],
                    )
                    state.set_status(f"Migrated {len(changes)} item(s) — press s to save")
                else:
                    state.set_status("Config is up-to-date — nothing to migrate")
            except Exception as e:
                state.set_status(f"Migrate error: {e}", error=True)

        elif ch in (ord("q"), ord("Q"), 27):
            try:
                if state.dirty:
                    if confirm(stdscr, "Unsaved changes — quit without saving?"):
                        break
                else:
                    break
            except Exception:
                break

        try:
            state.clamp()
        except Exception:
            pass


# ---------------------------------------------------------------------------
# Entry point
# ---------------------------------------------------------------------------

def main() -> None:
    try:
        project_root = find_project_root()
    except Exception:
        project_root = Path.cwd()

    config_path = Path(sys.argv[1]).resolve() if len(sys.argv) > 1 else project_root / "config.ini"
    example_path = project_root / "config.ini.example"

    if not config_path.exists():
        if not example_path.exists():
            print(
                f"ERROR: Neither {config_path} nor {example_path} found.\n"
                "Run this from the meshcore-bot project root.",
                file=sys.stderr,
            )
            sys.exit(1)
        try:
            import shutil
            print(f"config.ini not found — creating from {example_path.name}…")
            shutil.copy(str(example_path), str(config_path))
            print(f"Created {config_path}")
        except (IOError, OSError, shutil.Error) as e:
            print(f"ERROR: Could not create config from example: {e}", file=sys.stderr)
            sys.exit(1)

    try:
        cfg = load_config(config_path)
    except Exception as e:
        print(f"ERROR: Could not load config: {e}", file=sys.stderr)
        sys.exit(1)

    # Warn if the config had a parse error but continue with whatever was loaded
    load_error = getattr(cfg, "_load_error", None)
    if load_error:
        print(f"WARNING: Config parse error (partial load): {load_error}", file=sys.stderr)

    try:
        example_keys = load_example_keys(example_path)
        example_comments = load_example_comments(example_path)
        example_lines = load_example_lines(example_path)
    except Exception as e:
        print(f"WARNING: Could not load example file ({e}); help/migrate features disabled.", file=sys.stderr)
        example_keys = {}
        example_comments = {}
        example_lines = {}

    try:
        state = TUIState(cfg, config_path, example_keys, example_comments, example_lines)
    except Exception as e:
        print(f"ERROR: Could not initialise TUI state: {e}", file=sys.stderr)
        sys.exit(1)

    try:
        curses.wrapper(tui_main, state)
    except KeyboardInterrupt:
        pass
    except curses.error as e:
        print(f"ERROR: Terminal error: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"ERROR: Unexpected error: {e}", file=sys.stderr)
        sys.exit(1)

    print("Exited config editor.")
    if state.dirty:
        try:
            answer = input("Unsaved changes. Save now? [y/N] ").strip().lower()
            if answer in ("y", "yes"):
                save_config(state.cfg, config_path)
                print(f"Saved to {config_path}")
        except (KeyboardInterrupt, EOFError):
            print()  # clean newline
        except Exception as e:
            print(f"Save failed: {e}", file=sys.stderr)


if __name__ == "__main__":
    main()