#!/usr/bin/env python3
import argparse
import logging
import re
import textwrap
from dataclasses import dataclass
from pathlib import Path

# lowercase tokens (en, tr) whose trailing period does not end a sentence
ABBREVIATIONS = {"mr", "mrs", "ms", "dr", "prof", "e.g", "i.e", "vs", "etc", "doç", "av", "sn", "vb", "bkz"}
# Finds candidate sentence boundaries: end punctuation, optional closers, then whitespace.
# Matches in "He left.  Then" -> ".  " and in 'He said "no." Then' -> '." '.
SENTENCE_END = re.compile(
    r"""
    [.!?…]+         # one or more end marks: "." "?!" "..." or the ellipsis character
    [\"'”’)\]]*     # closing quotes or brackets that belong to the finished sentence
    \s+             # whitespace after it; one or more, so double spaces work too
    """,
    re.VERBOSE,
)
# Matches an SRT time line such as "00:01:02,345 --> 00:01:04,000" and captures the 8 time fields.
TIMELINE_PATTERN = re.compile(
    r"""
    (\d+):(\d{2}):(\d{2})[,.](\d{3})    # start: hours, minutes, seconds, milliseconds (comma or dot)
    \s*-->\s*                           # arrow, with optional spaces around it
    (\d+):(\d{2}):(\d{2})[,.](\d{3})    # end, same layout
    """,
    re.VERBOSE,
)
# Matches a whole cue that is only a sound description or music, e.g. "[Music]", "(laughing)", "♪ la la ♪".
NONSPEECH_PATTERN = re.compile(
    r"""
    ^(
        \[[^\]]*\]      # [ ... ]
      | \([^)]*\)       # ( ... )
      | ♪[^♪]*♪?       # ♪ ... ♪, closing note optional
      | ♫[^♫]*♫?       # ♫ ... ♫, closing note optional
    )$
    """,
    re.VERBOSE,
)
# Matches inline markup to strip: HTML tags like <i> and </i>, and ASS/SSA overrides like {\an8}.
MARKUP_PATTERN = re.compile(
    r"""
    <[^>]+>         # < ... >
  | \{[^}]*\}       # { ... }
    """,
    re.VERBOSE,
)
MIN_CUE_DURATION = 0.2

logger = logging.getLogger(__name__)


@dataclass
class Cue:
    """A subtitle cue or piece of one; times in seconds. `dialogue` marks cues holding several '- ' speaker lines."""

    start: float
    end: float
    text: str
    dialogue: bool = False


def parse_args() -> argparse.Namespace:
    """Parse command-line arguments."""
    parser = argparse.ArgumentParser(
        description="Re-time and re-segment an SRT file mechanically: merge by sentence, split long cues, wrap lines, enforce reading speed.",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )
    parser.add_argument("subtitle", type=Path, help="Input SRT file")
    parser.add_argument("--output", "-o", type=Path, help="Output SRT path (default: <name>.rewritten.srt)")
    parser.add_argument("--max-line-length", type=int, default=42, help="Max characters per line")
    parser.add_argument("--max-lines", type=int, default=2, help="Max lines per cue")
    parser.add_argument("--max-cps", type=float, default=17.0, help="Max characters per second before a cue's end is extended")
    parser.add_argument("--min-duration", type=float, default=1.0, help="Cues shorter than this (seconds) are merged into a neighbour")
    parser.add_argument("--max-duration", type=float, default=7.0, help="Cues longer than this (seconds) are split")
    parser.add_argument("--min-gap", type=float, default=0.04, help="Minimum gap between cues in seconds")
    parser.add_argument("--drop-nonspeech", action="store_true", help="Remove cues that are only [..], (..) or music notes")
    return parser.parse_args()


def parse_timestamp(hours: str, minutes: str, seconds: str, milliseconds: str) -> float:
    """Convert the four captured time fields of TIMELINE_PATTERN to seconds."""
    return int(hours) * 3600 + int(minutes) * 60 + int(seconds) + int(milliseconds) / 1000


def parse_srt(content: str) -> list[Cue]:
    """Parse SRT text into cues sorted by start time.

    Tolerates CRLF line endings and a missing index line. Text lines are flattened into one line and markup is
    stripped. A cue with two or more lines starting with '- ' is flagged as dialogue. Empty cues are dropped.
    """
    cues = []
    # \n\s*\n = a blank line (possibly containing spaces) separates SRT blocks
    for block in re.split(r"\n\s*\n", content.replace("\r\n", "\n").replace("\r", "\n").strip()):
        lines = block.split("\n")
        match = next((found for line in lines[:3] if (found := TIMELINE_PATTERN.search(line))), None)
        if match is None:
            raise ValueError(f"Invalid SRT block: {block[:80]!r}")
        position = next(position for position, line in enumerate(lines[:3]) if TIMELINE_PATTERN.search(line))
        body = [line.strip() for line in lines[position + 1 :] if line.strip()]
        # \s+ -> " " collapses runs of whitespace (including the gaps left by removed markup) to one space
        text = re.sub(r"\s+", " ", MARKUP_PATTERN.sub("", " ".join(body))).strip()
        if text:
            cues.append(
                Cue(
                    start=parse_timestamp(*match.group(1, 2, 3, 4)),
                    end=parse_timestamp(*match.group(5, 6, 7, 8)),
                    text=text,
                    dialogue=sum(line.startswith("- ") for line in body) >= 2,
                )
            )
    if not cues:
        raise ValueError("SRT contains no cues")
    cues.sort(key=lambda cue: cue.start)
    return cues


def format_timestamp(seconds: float) -> str:
    """Format seconds as an SRT timestamp, HH:MM:SS,mmm."""
    total_milliseconds = round(seconds * 1000)
    hours, remainder = divmod(total_milliseconds, 3_600_000)
    minutes, remainder = divmod(remainder, 60_000)
    secs, milliseconds = divmod(remainder, 1000)
    return f"{hours:02d}:{minutes:02d}:{secs:02d},{milliseconds:03d}"


def split_sentences(text: str) -> list[str]:
    """Split text into sentences at SENTENCE_END matches.

    A boundary is kept only if the next character starts a sentence (uppercase, digit, opening quote/bracket or a
    '- ' speaker dash) and the word before a period is not a known abbreviation or a single-letter initial.
    Decimals such as "3.5" never match because no whitespace follows the period.
    """
    sentences = []
    start = 0
    for match in SENTENCE_END.finditer(text):
        following = text[match.end() : match.end() + 1]
        starts_sentence = following.isupper() or following.isdigit() or following in "\"'“‘([" or text.startswith("- ", match.end())
        if not following or not starts_sentence:
            continue
        punctuation = match.group().strip()
        # (\S+)$ = the last whitespace-delimited word before the punctuation, e.g. "Dr" in "... Dr."
        word = re.search(r"(\S+)$", text[start : match.start()])
        token = word.group(1).lower().lstrip("\"'“‘([") if word else ""
        if punctuation.startswith(".") and (token in ABBREVIATIONS or (len(token) == 1 and token.isalpha())):
            continue
        sentences.append(text[start : match.start() + len(match.group().rstrip())].strip())
        start = match.end()
    sentences.append(text[start:].strip())
    return [sentence for sentence in sentences if sentence]


def wrap_text(text: str, width: int, max_lines: int) -> list[str] | None:
    """Wrap text to at most `max_lines` lines of at most `width` characters, preferring balanced lines.

    Text of the form "- a - b" is split into one line per speaker when each fits. Returns None if no wrapping fits.
    """
    if len(text) <= width:
        return [text]
    if text.startswith("- ") and " - " in text:
        # \s+(?=- ) = whitespace followed by a dash-space (lookahead, not consumed): splits before each speaker dash
        speakers = re.split(r"\s+(?=- )", text)
        if len(speakers) <= max_lines and all(len(line) <= width for line in speakers):
            return speakers
    for count in range(2, max_lines + 1):
        lines = textwrap.wrap(text, width=-(-len(text) // count), break_long_words=False, break_on_hyphens=False)
        if len(lines) <= max_lines and all(len(line) <= width for line in lines):
            return lines
    lines = textwrap.wrap(text, width=width, break_long_words=False, break_on_hyphens=False)
    return lines if len(lines) <= max_lines and all(len(line) <= width for line in lines) else None


def wrap_dialogue(text: str, width: int) -> list[str]:
    """Wrap a dialogue cue, one or more lines per speaker. The number of lines is not limited."""
    lines = []
    # \s+(?=- ) = whitespace followed by a dash-space (lookahead, not consumed): splits before each speaker dash
    for speaker in re.split(r"\s+(?=- )", text):
        lines.extend(textwrap.wrap(speaker, width=width, break_long_words=False, break_on_hyphens=False))
    return lines


def time_at(spans: list[tuple[int, Cue]], offset: int, is_end: bool) -> float:
    """Map a character offset in the joined text to a time, interpolating linearly inside the cue that holds it.

    `spans` are (offset of cue text in the joined text, cue). For an end offset the cue boundary belongs to the
    earlier cue, for a start offset to the later one. Offsets in the joining gap snap to the nearest cue edge.
    """
    for span_offset, cue in spans:
        length = len(cue.text)
        inside = span_offset < offset <= span_offset + length if is_end else span_offset <= offset < span_offset + length
        if inside:
            return cue.start + (cue.end - cue.start) * (offset - span_offset) / length
    span_offset, cue = min(spans, key=lambda span: min(abs(offset - span[0]), abs(offset - span[0] - len(span[1].text))))
    return cue.start if offset <= span_offset else cue.end


def sentences_with_times(cues: list[Cue]) -> list[Cue]:
    """Join the cues' text, split it into sentences and give each sentence a start and end time.

    A sentence spanning several cues starts where its first character is spoken and ends where its last one is.
    """
    joined = " ".join(cue.text for cue in cues)
    spans = []
    offset = 0
    for cue in cues:
        spans.append((offset, cue))
        offset += len(cue.text) + 1
    pieces = []
    cursor = 0
    for sentence in split_sentences(text=joined):
        position = joined.index(sentence, cursor)
        cursor = position + len(sentence)
        pieces.append(
            Cue(
                start=time_at(spans=spans, offset=position, is_end=False),
                end=time_at(spans=spans, offset=cursor, is_end=True),
                text=sentence,
            )
        )
    return pieces


def fits(text: str, duration: float, args: argparse.Namespace) -> bool:
    """Whether one cue can hold `text`: within --max-duration and wrappable into --max-lines lines."""
    return duration <= args.max_duration and wrap_text(text=text, width=args.max_line_length, max_lines=args.max_lines) is not None


def merge_short(pieces: list[Cue], args: argparse.Namespace) -> list[Cue]:
    """Merge a piece into the previous one when either is shorter than --min-duration and the result still fits."""
    merged: list[Cue] = []
    for piece in pieces:
        if merged:
            previous = merged[-1]
            short = piece.end - piece.start < args.min_duration or previous.end - previous.start < args.min_duration
            text = f"{previous.text} {piece.text}"
            if short and fits(text=text, duration=piece.end - previous.start, args=args):
                previous.end = piece.end
                previous.text = text
                continue
        merged.append(piece)
    return merged


def find_split(text: str) -> int | None:
    """Pick the index at which to cut `text` in two, or None if it is a single word.

    Prefers the start of the word after a comma, semicolon or colon if it is within 25% of the length from the
    middle; otherwise the word start nearest the middle.
    """
    middle = len(text) / 2
    # \s+ = any whitespace run; match.end() is where the next word starts (interior only, not at either edge)
    word_starts = [match.end() for match in re.finditer(r"\s+", text) if 0 < match.start() and match.end() < len(text)]
    if not word_starts:
        return None
    # [,;:]\s+ = a clause mark followed by whitespace; match.end() is the start of the next clause
    clause_starts = [match.end() for match in re.finditer(r"[,;:]\s+", text) if match.end() < len(text)]
    if clause_starts:
        best = min(clause_starts, key=lambda index: abs(index - middle))
        if abs(best - middle) <= len(text) * 0.25:
            return best
    return min(word_starts, key=lambda index: abs(index - middle))


def split_piece(piece: Cue, args: argparse.Namespace) -> list[Cue]:
    """Recursively split a piece until every part fits, dividing its time in proportion to character length."""
    if fits(text=piece.text, duration=piece.end - piece.start, args=args):
        return [piece]
    index = find_split(text=piece.text)
    if index is None:
        return [piece]
    left, right = piece.text[:index].strip(), piece.text[index:].strip()
    middle = piece.start + (piece.end - piece.start) * len(left) / (len(left) + len(right))
    return split_piece(piece=Cue(start=piece.start, end=middle, text=left), args=args) + split_piece(
        piece=Cue(start=middle, end=piece.end, text=right), args=args
    )


def retime(pieces: list[Cue], args: argparse.Namespace) -> list[int]:
    """Fix timing in place: remove overlaps, keep --min-gap, and extend a cue's end to meet --max-cps.

    An end is only extended into free time before the next cue and never beyond --max-duration.
    Returns the 1-based numbers of cues still above --max-cps.
    """
    over_budget = []
    for index, piece in enumerate(pieces):
        if index and piece.start < pieces[index - 1].end:
            piece.start = pieces[index - 1].end
        limit = pieces[index + 1].start - args.min_gap if index + 1 < len(pieces) else float("inf")
        wanted = piece.start + len(piece.text) / args.max_cps
        ceiling = min(piece.start + args.max_duration, limit)
        if wanted > piece.end:
            piece.end = max(piece.end, min(wanted, ceiling))
        if piece.end > limit:
            piece.end = max(limit, piece.start + MIN_CUE_DURATION)
        if piece.end <= piece.start:
            piece.end = piece.start + MIN_CUE_DURATION
        if len(piece.text) / (piece.end - piece.start) > args.max_cps + 0.01:
            over_budget.append(index + 1)
    return over_budget


def rewrite(cues: list[Cue], args: argparse.Namespace) -> tuple[list[Cue], list[int]]:
    """Run the full pipeline. Dialogue and non-speech cues act as barriers and pass through unchanged;
    the speech between them is merged into sentences, short pieces are merged, long ones split, then retimed.

    Returns (pieces, numbers of cues still above --max-cps).
    """
    pieces: list[Cue] = []
    run: list[Cue] = []

    def flush() -> None:
        if run:
            pieces.extend(
                part
                for piece in merge_short(pieces=sentences_with_times(cues=run), args=args)
                for part in split_piece(piece=piece, args=args)
            )
            run.clear()

    for cue in cues:
        if cue.dialogue or NONSPEECH_PATTERN.match(cue.text):
            flush()
            if cue.dialogue or not args.drop_nonspeech:
                pieces.append(Cue(start=cue.start, end=cue.end, text=cue.text, dialogue=cue.dialogue))
        else:
            run.append(cue)
    flush()
    return pieces, retime(pieces=pieces, args=args)


def build_srt(pieces: list[Cue], args: argparse.Namespace) -> str:
    """Render the pieces as SRT, wrapping each to --max-line-length (dialogue cues one speaker per line)."""
    blocks = []
    for index, piece in enumerate(pieces, start=1):
        if piece.dialogue:
            lines = wrap_dialogue(text=piece.text, width=args.max_line_length)
        else:
            lines = wrap_text(text=piece.text, width=args.max_line_length, max_lines=args.max_lines) or [piece.text]
        blocks.append(f"{index}\n{format_timestamp(piece.start)} --> {format_timestamp(piece.end)}\n" + "\n".join(lines) + "\n")
    return "\n".join(blocks)


def main() -> None:
    """Read the SRT, rewrite it and write the result next to it, refusing to overwrite the input."""
    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s: %(message)s")
    args = parse_args()
    if min(args.max_line_length, args.max_lines) < 1 or args.max_cps <= 0:
        raise SystemExit("--max-line-length, --max-lines and --max-cps must be positive")
    output = args.output or args.subtitle.with_name(f"{args.subtitle.stem}.rewritten.srt")
    if output.resolve() == args.subtitle.resolve():
        raise SystemExit("Refusing to overwrite the input file")

    cues = parse_srt(content=args.subtitle.read_text(encoding="utf-8-sig"))
    pieces, over_budget = rewrite(cues=cues, args=args)
    output.write_text(build_srt(pieces=pieces, args=args), encoding="utf-8")
    logger.info("Wrote %d cues (from %d) to %s", len(pieces), len(cues), output)
    if over_budget:
        logger.warning("%d cue(s) still above %.1f chars/s (text is not shortened): %s", len(over_budget), args.max_cps, over_budget[:20])


if __name__ == "__main__":
    main()