anitomy-ng 1.0.1

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

//! Port of `include/anitomy/detail/parser/release_group.hpp`.
//!
//! The upstream recursion (`find_release_group` calling itself on a
//! shrinking suffix) is tail recursion, so it's a loop here instead;
//! indices stay absolute into the original `tokens`. But upstream's
//! `find_prev_token(tokens, first, pred)` call inside the recursive
//! function *is* bounded to the current recursive call's span — C++
//! `std::span::begin()` shifts with each recursive slice, and
//! `find_prev_token` explicitly refuses to look before `container.begin()`
//! — so the "is this range preceded by something other than its own open
//! bracket" check must only look back as far as `search_start`, not to the
//! start of the whole file. (The *fallback* branch's plain `std::prev`,
//! unlike `find_prev_token`, isn't bounded this way — it's raw pointer
//! arithmetic on the shared backing storage — so that one stays unbounded.)

use crate::detail::container::{find_from, find_prev_token, mark};
use crate::detail::element::build_element_value;
use crate::detail::token::{
    is_close_bracket_token, is_dash_token, is_delimiter_token, is_free_token, is_identified_token,
    is_not_delimiter_token, is_open_bracket_token, Token,
};
use crate::element::{Element, ElementKind};

/// Returns (first, last) token indices (last exclusive), or `(len, len)` if
/// no release group span was found.
fn find_release_group(tokens: &[Token]) -> (usize, usize) {
    let len = tokens.len();
    let mut search_start = 0usize;

    loop {
        // Find the first enclosed unidentified range, e.g. `[Group] Title - Episode [Info]`.
        let first = find_from(tokens, search_start, |t| {
            t.is_enclosed && !is_identified_token(t)
        });
        let last = if first == len {
            len
        } else {
            find_from(tokens, first, |t| {
                is_close_bracket_token(t) || is_identified_token(t)
            })
        };

        if first != len {
            // Skip if the range contains other tokens. Bounded to [search_start, first) —
            // see module docs.
            let blocked_by_prev = tokens
                .get(search_start..first)
                .and_then(|s| s.iter().rposition(is_not_delimiter_token))
                .is_some_and(|rel| {
                    !tokens
                        .get(search_start + rel)
                        .is_some_and(is_open_bracket_token)
                });
            if blocked_by_prev {
                search_start = last;
                continue;
            }
            if last != len && !tokens.get(last).is_some_and(is_close_bracket_token) {
                search_start = last;
                continue;
            }
            return (first, last);
        }

        // Fall back to the last token before file extension, e.g. `Title.Episode.Info-Group.mkv`.
        let region = tokens.get(search_start..).unwrap_or(&[]);
        let fallback = find_prev_token(region, region.len(), |t| {
            t.element_kind != Some(ElementKind::FileExtension) && is_not_delimiter_token(t)
        });
        if let Some(local_idx) = fallback {
            let idx = search_start + local_idx;
            if idx > 0 && tokens.get(idx).is_some_and(is_free_token) {
                let prev_idx = idx - 1;
                if tokens
                    .get(prev_idx)
                    .is_some_and(|t| is_delimiter_token(t) && is_dash_token(t))
                {
                    return (idx, idx + 1);
                }
            }
        }
        return (len, len);
    }
}

pub(super) fn parse_release_group(tokens: &mut [Token]) -> Option<Element> {
    let (first, last) = find_release_group(tokens);
    if first >= last {
        return None;
    }

    let value = build_element_value(tokens.get(first..last)?, true);
    if value.is_empty() {
        return None;
    }

    let position = tokens.get(first)?.position;
    for i in first..last {
        mark(tokens, i, ElementKind::ReleaseGroup);
    }

    Some(Element {
        kind: ElementKind::ReleaseGroup,
        value,
        position,
    })
}