"""Recurrence rules.

Rules are stored as iCalendar RRULE strings without the 'RRULE:' prefix, e.g.
    FREQ=WEEKLY;BYDAY=MO,TH
    FREQ=MONTHLY;BYDAY=2TU
    FREQ=DAILY;INTERVAL=3
That is the standard calendar format, so calendar sync can be added later without converting anything.

This module turns plain English ("every other week on monday") into rules,
describes rules back in English, and works out the next due date of a task.
"""
import re
from datetime import date, datetime, timedelta

from dateutil.relativedelta import relativedelta
from dateutil.rrule import rrulestr

WEEKDAY_CODES = ["MO", "TU", "WE", "TH", "FR", "SA", "SU"]
WEEKDAY_NAMES = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

_WEEKDAY_WORDS = {
    "mon": 0, "monday": 0,
    "tue": 1, "tues": 1, "tuesday": 1,
    "wed": 2, "weds": 2, "wednesday": 2,
    "thu": 3, "thur": 3, "thurs": 3, "thursday": 3,
    "fri": 4, "friday": 4,
    "sat": 5, "saturday": 5,
    "sun": 6, "sunday": 6,
}
_ORDINAL_WORDS = {
    "first": 1, "1st": 1, "second": 2, "2nd": 2, "third": 3, "3rd": 3,
    "fourth": 4, "4th": 4, "fifth": 5, "5th": 5, "last": -1,
}
_UNITS = {"day": "DAILY", "week": "WEEKLY", "month": "MONTHLY", "year": "YEARLY"}
_NUMBER_WORDS = {"two": 2, "three": 3, "four": 4, "five": 5, "six": 6, "seven": 7,
                 "eight": 8, "nine": 9, "ten": 10, "twelve": 12}


def weekday_index(word: str):
    """'Mondays' -> 0, 'tue' -> 1, anything else -> None."""
    w = word.lower()
    if w in _WEEKDAY_WORDS:
        return _WEEKDAY_WORDS[w]
    if w.endswith("s") and w[:-1] in _WEEKDAY_WORDS:
        return _WEEKDAY_WORDS[w[:-1]]
    return None


def _unit(word: str):
    w = word.lower()
    if w in _UNITS:
        return _UNITS[w]
    if w.endswith("s") and w[:-1] in _UNITS:
        return _UNITS[w[:-1]]
    return None


def _month_day(word: str):
    m = re.fullmatch(r"(\d{1,2})(st|nd|rd|th)?", word.lower())
    if m and 1 <= int(m.group(1)) <= 31:
        return int(m.group(1))
    return None


# --------------------------------------------------------------------------
# English -> RRULE
# --------------------------------------------------------------------------

class _Tokens:
    def __init__(self, text):
        self.toks = [(m.group(0).lower(), m.start(), m.end())
                     for m in re.finditer(r"[A-Za-z0-9]+|[,&]", text)]
        self.i = 0

    def peek(self, k=0):
        j = self.i + k
        return self.toks[j][0] if j < len(self.toks) else None

    def take(self):
        tok = self.toks[self.i]
        self.i += 1
        return tok[0]

    def end_pos(self):
        return self.toks[self.i - 1][2]


def _weekday_list(t: _Tokens):
    """Consume 'mon, wed and fri' -> [0, 2, 4] (or [] if no weekday here)."""
    days = []
    if t.peek() is None or weekday_index(t.peek()) is None:
        return days
    days.append(weekday_index(t.take()))
    while True:
        k = 0
        while t.peek(k) in (",", "and", "&"):
            k += 1
        if k and t.peek(k) is not None and weekday_index(t.peek(k)) is not None:
            for _ in range(k):
                t.take()
            days.append(weekday_index(t.take()))
        else:
            break
    return sorted(set(days))


def _byday(days):
    return "BYDAY=" + ",".join(WEEKDAY_CODES[d] for d in days)


def _on_clause(t: _Tokens, freq: str):
    """Parse an optional 'on ...' after the unit. Returns extra RRULE parts or ''."""
    save = t.i
    if t.peek() != "on":
        return ""
    t.take()
    if t.peek() == "the":
        t.take()
    tok = t.peek()
    if tok is None:
        t.i = save
        return ""
    # on monday, thursday
    days = _weekday_list(t)
    if days:
        return _byday(days)
    # on the 2nd tuesday / on the last friday
    if tok in _ORDINAL_WORDS and t.peek(1) and weekday_index(t.peek(1)) is not None:
        n = _ORDINAL_WORDS[t.take()]
        d = weekday_index(t.take())
        return f"BYDAY={n}{WEEKDAY_CODES[d]}"
    # on the last day
    if tok == "last" and t.peek(1) == "day":
        t.take(); t.take()
        return "BYMONTHDAY=-1"
    # on the 15th
    md = _month_day(tok)
    if md and freq in ("MONTHLY", "YEARLY"):
        t.take()
        if t.peek() == "day":
            t.take()
        return f"BYMONTHDAY={md}"
    t.i = save
    return ""


def parse_recurrence(text: str):
    """Find a recurrence phrase in free text.

    Returns (rrule, recur_from, (start, end)) or None. (start, end) is the span
    of the phrase in `text` so the caller can cut it out of a task title.
    """
    t = _Tokens(text)
    while t.peek() is not None:
        start_i = t.i
        word = t.peek()
        rule = None

        if word in ("daily",):
            t.take(); rule = "FREQ=DAILY"
        elif word in ("weekly", "monthly", "yearly", "annually"):
            t.take()
            freq = {"weekly": "WEEKLY", "monthly": "MONTHLY",
                    "yearly": "YEARLY", "annually": "YEARLY"}[word]
            extra = _on_clause(t, freq)
            rule = f"FREQ={freq}" + (f";{extra}" if extra else "")
        elif word == "weekdays":
            t.take(); rule = "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR"
        elif word == "every" or word == "each":
            t.take()
            rule = _after_every(t)
            if rule is None:
                t.i = start_i + 1
                continue
        else:
            t.take()
            continue

        recur_from = default_mode(rule)
        if t.peek() == "when" and t.peek(1) == "done":
            t.take(); t.take()
            recur_from = "done"
        span = (t.toks[start_i][1], t.end_pos())
        return rule, recur_from, span
    return None


def _after_every(t: _Tokens):
    tok = t.peek()
    if tok is None:
        return None
    interval = 1
    if tok == "other":
        t.take(); interval = 2
    elif tok.isdigit():
        t.take(); interval = int(tok)
    elif tok in _NUMBER_WORDS:
        t.take(); interval = _NUMBER_WORDS[tok]
    tok = t.peek()
    if tok is None:
        return None

    iv = f";INTERVAL={interval}" if interval > 1 else ""

    if tok in ("weekday", "weekdays") and interval == 1:
        t.take(); return "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR"
    if tok in ("weekend", "weekends"):
        t.take(); return f"FREQ=WEEKLY{iv};BYDAY=SA,SU"

    freq = _unit(tok)
    if freq:
        t.take()
        extra = _on_clause(t, freq)
        return f"FREQ={freq}{iv}" + (f";{extra}" if extra else "")

    # every 2nd tuesday / every last friday  (monthly)
    if tok in _ORDINAL_WORDS and t.peek(1) and weekday_index(t.peek(1)) is not None:
        n = _ORDINAL_WORDS[t.take()]
        d = weekday_index(t.take())
        if t.peek() == "of" and t.peek(1) in ("the", "month"):
            t.take()
            if t.peek() == "the":
                t.take()
            if t.peek() == "month":
                t.take()
        return f"FREQ=MONTHLY{iv};BYDAY={n}{WEEKDAY_CODES[d]}"

    # every monday and thursday
    days = _weekday_list(t)
    if days:
        return f"FREQ=WEEKLY{iv};{_byday(days)}"
    return None


# --------------------------------------------------------------------------
# RRULE -> English
# --------------------------------------------------------------------------

def _parts(rule: str) -> dict:
    out = {}
    for piece in rule.replace("RRULE:", "").split(";"):
        if "=" in piece:
            k, v = piece.split("=", 1)
            out[k.upper()] = v.upper()
    return out


def _ordinal(n: int) -> str:
    if n == -1:
        return "last"
    if 10 <= n % 100 <= 20:
        suffix = "th"
    else:
        suffix = {1: "st", 2: "nd", 3: "rd"}.get(n % 10, "th")
    return f"{n}{suffix}"


def describe(rule, recur_from: str = "") -> str:
    """English for a rule, e.g. 'every 2nd Tuesday'. (The repeat mode is shown separately.)"""
    if not rule:
        return ""
    p = _parts(rule)
    freq = p.get("FREQ", "")
    n = int(p.get("INTERVAL", "1"))
    unit = {"DAILY": "day", "WEEKLY": "week", "MONTHLY": "month", "YEARLY": "year"}.get(freq, "?")
    base = f"every {unit}" if n == 1 else f"every {n} {unit}s"
    if n == 1 and freq == "DAILY":
        base = "every day"

    byday = p.get("BYDAY")
    if byday:
        items = byday.split(",")
        m = re.fullmatch(r"([+-]?\d+)([A-Z]{2})", items[0])
        if m and len(items) == 1:
            ordn, code = int(m.group(1)), m.group(2)
            day = WEEKDAY_NAMES[WEEKDAY_CODES.index(code)]
            base = (f"every {_ordinal(ordn)} {day}" if n == 1
                    else f"{base} on the {_ordinal(ordn)} {day}")
        elif set(items) == {"MO", "TU", "WE", "TH", "FR"} and n == 1:
            base = "every weekday"
        elif set(items) == {"SA", "SU"} and n == 1:
            base = "every weekend"
        else:
            names = [WEEKDAY_NAMES[WEEKDAY_CODES.index(c)] for c in items if c in WEEKDAY_CODES]
            if n == 1 and freq == "WEEKLY":
                base = "every " + _join(names)
            else:
                base = f"{base} on {_join(names)}"
    elif p.get("BYMONTHDAY"):
        md = int(p["BYMONTHDAY"])
        base += " on the last day" if md == -1 else f" on the {_ordinal(md)}"

    return base


def _join(items):
    if len(items) <= 2:
        return " and ".join(items)
    return ", ".join(items[:-1]) + " and " + items[-1]


# --------------------------------------------------------------------------
# Dates
# --------------------------------------------------------------------------

def _is_simple(p: dict) -> bool:
    return not any(k.startswith("BY") for k in p)


def _step(rule: str, after: date) -> date:
    """Next occurrence strictly after `after`, with `after` as the series anchor."""
    p = _parts(rule)
    if _is_simple(p):
        n = int(p.get("INTERVAL", "1"))
        freq = p.get("FREQ")
        delta = {"DAILY": relativedelta(days=n), "WEEKLY": relativedelta(weeks=n),
                 "MONTHLY": relativedelta(months=n), "YEARLY": relativedelta(years=n)}[freq]
        return after + delta
    r = rrulestr("RRULE:" + rule, dtstart=datetime.combine(after, datetime.min.time()))
    nxt = r.after(datetime.combine(after, datetime.min.time()))
    return nxt.date() if nxt else after + timedelta(days=1)


def first_on_or_after(rule: str, start: date) -> date:
    """First date on/after `start` that fits the rule (used when no date given)."""
    p = _parts(rule)
    if _is_simple(p):
        return start
    # The first one is simply the next matching day: "every 2 weeks on Saturday" starts
    # this coming Saturday. (With INTERVAL, dateutil would count whole weeks from the
    # start and could skip it.) Later dates step by the interval from there.
    first_rule = ";".join(f"{k}={v}" for k, v in p.items() if k != "INTERVAL")
    r = rrulestr("RRULE:" + first_rule, dtstart=datetime.combine(start, datetime.min.time()))
    first = r.after(datetime.combine(start, datetime.min.time()), inc=True)
    return first.date() if first else start


# Repeat modes (stored in tasks.recur_from):
MODES = {
    "fixed": "fixed",        # always on its schedule; finishing late never moves it
    "due":   "flexible",     # on schedule if on time; finishing late counts from that day
    "done":  "from finish",  # always counts from the day it was finished
}


def default_mode(rule) -> str:
    """Rules tied to particular days (Mondays, the 1st, 2nd Tuesday) or yearly dates
    default to fixed; plain intervals (every 3 days / 2 weeks / month) to flexible."""
    p = _parts(rule or "")
    if any(k.startswith("BY") for k in p) or p.get("FREQ") == "YEARLY":
        return "fixed"
    return "due"


def next_due(rule: str, recur_from: str, due, completed_on: date, today: date) -> date:
    """Next due date after a recurring task is completed.

    'fixed':  next occurrence on the schedule after the due date, skipping any that
              are already past. e.g. every Monday, finished Wednesday -> next Monday;
              every 2 weeks from Dec 1, finished Dec 4 -> Dec 15.
    'due' (flexible):
              finished on time or early -> next occurrence after the due date;
              finished late -> counted from the day it was finished.
              e.g. every 2 weeks due Dec 1: done Dec 1 -> Dec 15; done Dec 4 -> Dec 18.
    'done':   always counted from the day it was finished, even if early.
    """
    if recur_from == "fixed" and due is not None:
        nxt = _step(rule, due)
        guard = 0
        while nxt < today and guard < 5000:
            nxt = _step(rule, nxt)
            guard += 1
        return nxt
    if recur_from == "done" or due is None or completed_on > due:
        return _step(rule, completed_on)
    return _step(rule, due)


def validate(rule: str) -> str:
    """Normalise and sanity-check a rule; raises ValueError if unusable."""
    rule = rule.strip().replace("RRULE:", "").upper()
    p = _parts(rule)
    if p.get("FREQ") not in ("DAILY", "WEEKLY", "MONTHLY", "YEARLY"):
        raise ValueError("Repeat rule needs FREQ=DAILY/WEEKLY/MONTHLY/YEARLY")
    rrulestr("RRULE:" + rule, dtstart=datetime(2026, 1, 1))
    return rule
