!/usr/bin/env python3

if not config_path or not os.path.exists(config_path):
    return {"family": {"members": []}, "rejections": []}

with open(config_path, "r") as f:
    return yaml.safe_load(f) or {"family": {"members": []}, "rejections": []}

if not config_path:
    raise FileNotFoundError("Cannot find family.yaml to save rejection rules")

with open(config_path, "w") as f:
    yaml.dump(config, f, default_flow_style=False, sort_keys=False)

Args:
    pattern: Event summary pattern to reject (substring match)
    reason: Human-readable reason for the rejection
    scope: "all", "event", or "newsletter"

Returns:
    The new rule dict
"""
config = _load_family_config()
if "rejections" not in config:
    config["rejections"] = []

# Check for duplicate
for existing in config["rejections"]:
    if existing.get("pattern", "").lower() == pattern.lower():
        # Update existing rule
        existing["reason"] = reason
        existing["scope"] = scope
        existing["updated"] = date.today().isoformat()
        _save_family_config(config)
        return existing

rule = {
    "pattern": pattern,
    "reason": reason,
    "scope": scope,
    "created": date.today().isoformat(),
}
config["rejections"].append(rule)
_save_family_config(config)
return rule

Args:
    item: Dict with at least 'summary' key
    scope: Check against this scope ("event" or "newsletter")

Returns:
    Matching rule dict if rejected, None if not rejected
"""
rules = get_rejection_rules()
summary = item.get("summary", "").lower()

for rule in rules:
    pattern = rule.get("pattern", "").lower()
    rule_scope = rule.get("scope", "all")

    # Check if pattern matches (substring match)
    if pattern and pattern in summary:
        # Check scope: "all" matches any scope, otherwise must match exactly
        if rule_scope == "all" or rule_scope == scope:
            return rule

return None

Instead, rejected items are flagged as low_relevance with a note about
which rule caught them. This ensures the user still sees what was filtered
and can restore items if needed.

Args:
    items: List of newsletter item dicts
    scope: "event" or "newsletter"

Returns:
    List of items with rejected ones flagged as low_relevance
"""
rules = get_rejection_rules()
result = []
for item in items:
    rule = should_reject(item, scope=scope)
    if rule:
        # Downgrade to low_relevance info instead of removing
        item = dict(item)  # shallow copy
        item["original_type"] = item.get("type", "info")
        item["original_relevance"] = item.get("relevance", "high")
        item["type"] = "info"
        item["relevance"] = "low"
        item["reason"] = f"Auto-filtered: {rule.get('pattern', '')} ({rule.get('reason', '')})"
        item["_auto_filtered"] = True
    result.append(item)
return result

Args:
    items: List of item dicts with 'summary' keys
    scope: "event" or "newsletter"

Returns:
    Tuple of (kept_items, rejected_items_with_rules)
"""
kept = []
rejected = []

for item in items:
    rule = should_reject(item, scope=scope)
    if rule:
        rejected.append({"item": item, "rule": rule})
    else:
        kept.append(item)

return kept, rejected

Args:
    text: User's rejection message (e.g., "we don't need that mass, ignore it")
    event_summary: The event being rejected (for context)

Returns:
    Dict with pattern, reason, scope keys, or None on failure
"""
import requests

system_msg = (
    "You are a calendar rejection parser. Given a user's message about an event "
    "they want to reject from their family calendar, extract a structured rejection rule.\n\n"
    "Rules:\n"
    "- 'pattern' MUST be a short, specific substring extracted directly from the event summary — "
    "do NOT generalize or infer. Use the exact wording from the event name.\n"
    "  Good: 'First Communion Mass', 'STAR Testing', 'WI Tornado Drill'\n"
    "  Bad: 'communion', 'testing', 'drill' (too broad, will over-match)\n"
    "- If the user says 'just this one', 'skip this time', or 'remove this event', set scope to 'event' "
    "(only skip calendar creation for this specific occurrence, still show in newsletter).\n"
    "- If the user explicitly says 'always skip', 'ignore future', 'we don't do that', or 'never again', "
    "set scope to 'all' (skip from both calendar and newsletter extraction).\n"
    "- DEFAULT to scope 'event' — do NOT set scope 'all' unless the user explicitly says so.\n"
    "- If the user says 'not relevant to newsletter', set scope to 'newsletter'.\n"
    "- 'reason' should be a brief human-readable explanation.\n"
    "- Return ONLY a JSON object with keys: pattern, reason, scope. No markdown, no explanation."
)

user_msg = f"Event: {event_summary}\nUser message: {text}"

try:
    # LLM_URL already includes the full path (e.g., http://host:11434/v1/chat/completions)
    resp = requests.post(
        LLM_URL,
        json={
            "model": LLM_MODEL,
            "messages": [
                {"role": "system", "content": system_msg},
                {"role": "user", "content": user_msg},
            ],
            "temperature": 0.1,
            "max_tokens": 256,
        },
        timeout=LLM_TIMEOUT,
    )

    if resp.status_code != 200:
        print(f"[Rejection] LLM error: HTTP {resp.status_code}", file=sys.stderr)
        return None

    content = resp.json()["choices"][0]["message"]["content"].strip()

    # Strip code fences if present
    if content.startswith("```"):
        content = re.sub(r"^```(?:json)?\s*\n?", "", content)
        content = re.sub(r"\n?```\s*$", "", content)
        content = content.strip()

    parsed = json.loads(content)
    if "pattern" in parsed and "reason" in parsed:
        parsed.setdefault("scope", "all")
        return parsed

except json.JSONDecodeError:
    # Try to extract JSON from the response
    match = re.search(r"\{.*\}", content, re.DOTALL)
    if match:
        try:
            parsed = json.loads(match.group(0))
            if "pattern" in parsed and "reason" in parsed:
                parsed.setdefault("scope", "all")
                return parsed
        except json.JSONDecodeError:
            pass
except Exception as e:
    print(f"[Rejection] Error: {e}", file=sys.stderr)

return None

Args:
    event_summary: The calendar event summary to reject
    user_message: Natural language rejection reason
    delete_from_calendar: If True, also delete the event from Google Calendar

Returns:
    Dict with status, rule, and any calendar deletion results
"""
# 1. Parse the user's intent with LLM
rule = parse_rejection_intent(user_message, event_summary)

if not rule:
    # Fallback: use the event summary as pattern, user message as reason
    rule = {
        "pattern": event_summary,
        "reason": user_message,
        "scope": "event",  # Default to one-time skip, not permanent
    }

# 2. Save the rule
saved_rule = add_rejection_rule(
    pattern=rule["pattern"],
    reason=rule["reason"],
    scope=rule.get("scope", "all"),
)

result = {
    "status": "rejected",
    "rule": saved_rule,
    "calendar_deleted": False,
}

# 3. Optionally delete from calendar
if delete_from_calendar:
    from .calendar_sync import get_calendar_service, _event_to_dict, _delete_event
    from .config import CHICAGO_TZ
    from datetime import timedelta

    calendar = get_calendar_service()
    now = datetime.now(CHICAGO_TZ)

    # Search for matching events in the next 90 days
    try:
        event_objs = calendar.date_search(start=now, end=now + timedelta(days=90))
    except Exception:
        event_objs = calendar.events()

    pattern = rule["pattern"].lower()
    deleted_ids = []

    for obj in event_objs:
        evt = _event_to_dict(obj)
        if pattern in evt.get("summary", "").lower():
            try:
                _delete_event(evt["id"])
                deleted_ids.append(evt["id"])
            except Exception as e:
                print(f"[Rejection] Failed to delete {evt['id']}: {e}", file=sys.stderr)

    result["calendar_deleted"] = len(deleted_ids) > 0
    result["deleted_count"] = len(deleted_ids)
    result["deleted_ids"] = deleted_ids

return result

parser = argparse.ArgumentParser(description="Rejection engine")
sub = parser.add_subparsers(dest="command")

list_cmd = sub.add_parser("list", help="List current rejection rules")
add_cmd = sub.add_parser("add", help="Add a rejection rule")
add_cmd.add_argument("pattern", help="Event pattern to reject")
add_cmd.add_argument("--reason", default="User rejected", help="Reason")
add_cmd.add_argument("--scope", choices=["all", "event", "newsletter"], default="all")

reject_cmd = sub.add_parser("reject", help="Reject an event with natural language")
reject_cmd.add_argument("event_summary", help="Event summary to reject")
reject_cmd.add_argument("message", help="Natural language rejection reason")
reject_cmd.add_argument("--no-delete", action="store_true", help="Don't delete from calendar")

test_cmd = sub.add_parser("test", help="Test if an event would be rejected")
test_cmd.add_argument("summary", help="Event summary to test")

args = parser.parse_args()

if args.command == "list":
    rules = get_rejection_rules()
    if not rules:
        print("No rejection rules")
    else:
        for r in rules:
            print(f"  [{r.get('scope','?')}] {r['pattern']} — {r.get('reason','')}")

elif args.command == "add":
    rule = add_rejection_rule(args.pattern, args.reason, args.scope)
    print(f"Added: {rule}")

elif args.command == "reject":
    result = reject_event(args.event_summary, args.message, delete_from_calendar=not args.no_delete)
    print(json.dumps(result, indent=2, default=str))

elif args.command == "test":
    rule = should_reject({"summary": args.summary})
    if rule:
        print(f"REJECTED by rule: [{rule.get('scope','?')}] {rule['pattern']} — {rule.get('reason','')}")
    else:
        print("Not rejected")

else:
    parser.print_help()