coreutils_rs/wc/

core.rs

use memchr::memchr_iter;
use rayon::prelude::*;

/// Minimum data size to use parallel processing (2MB).
/// Lower threshold lets us exploit 4 cores on smaller files.
const PARALLEL_THRESHOLD: usize = 2 * 1024 * 1024;

/// Results from counting a byte slice.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct WcCounts {
    pub lines: u64,
    pub words: u64,
    pub bytes: u64,
    pub chars: u64,
    pub max_line_length: u64,
}

/// Non-word lookup table for UTF-8 locale word boundary detection.
/// In UTF-8 locale, GNU wc uses mbrtowc() + iswspace(). Non-word bytes:
/// - C0 control chars (0x00-0x1F): non-printable, iswprint() = false
/// - Space (0x20): iswspace() = true
/// - DEL (0x7F): non-printable
/// - Invalid standalone UTF-8: 0xC0, 0xC1, 0xFE, 0xFF (mbrtowc fails)
/// Valid UTF-8 continuation (0x80-0xBF) and leader bytes (0xC2-0xFD) remain as word content.
const fn make_ws_table_utf8() -> [u8; 256] {
    let mut t = [0u8; 256];
    // All C0 control characters (0x00-0x1F) are non-word
    let mut i = 0u16;
    while i <= 0x1F {
        t[i as usize] = 1;
        i += 1;
    }
    t[0x20] = 1; // space
    t[0x7F] = 1; // DEL
    // Invalid UTF-8 standalone bytes
    t[0xC0] = 1; // overlong encoding
    t[0xC1] = 1; // overlong encoding
    t[0xFE] = 1; // invalid UTF-8
    t[0xFF] = 1; // invalid UTF-8
    t
}

/// Non-word lookup table for C/POSIX locale word boundary detection.
/// In C locale, GNU wc uses mbrtowc() which fails on bytes >= 0x80, treating them
/// as non-word characters. Also treats all control chars (0x01-0x08, 0x0E-0x1F, 0x7F)
/// as non-word, matching the behavior where only printable ASCII forms words.
const fn make_ws_table_c() -> [u8; 256] {
    let mut t = [1u8; 256]; // default: non-word
    // Only printable ASCII (0x21-0x7E) are word characters (not space 0x20)
    let mut i = 0x21u16;
    while i <= 0x7E {
        t[i as usize] = 0;
        i += 1;
    }
    t
}

/// UTF-8 locale: only standard whitespace + null are non-word
const WS_TABLE_UTF8: [u8; 256] = make_ws_table_utf8();

/// C locale: all non-printable-ASCII bytes are non-word (bytes >= 0x80, controls, etc.)
const WS_TABLE_C: [u8; 256] = make_ws_table_c();

/// Get the appropriate word-boundary table for the current locale.
/// This is set once at startup and used throughout.
#[inline]
pub fn ws_table(utf8: bool) -> &'static [u8; 256] {
    if utf8 { &WS_TABLE_UTF8 } else { &WS_TABLE_C }
}

/// Printable ASCII lookup table: 0x20 (space) through 0x7E (~) are printable.
const fn make_printable_table() -> [u8; 256] {
    let mut t = [0u8; 256];
    let mut i = 0x20u16;
    while i <= 0x7E {
        t[i as usize] = 1;
        i += 1;
    }
    t
}

const PRINTABLE_TABLE: [u8; 256] = make_printable_table();

/// Count newlines using SIMD-accelerated memchr.
/// GNU wc counts newline bytes (`\n`), not logical lines.
#[inline]
pub fn count_lines(data: &[u8]) -> u64 {
    memchr_iter(b'\n', data).count() as u64
}

/// Count bytes. Trivial but included for API consistency.
#[inline]
pub fn count_bytes(data: &[u8]) -> u64 {
    data.len() as u64
}

/// Count words using locale-aware whitespace detection.
///
/// A word is a maximal run of word-character bytes.
/// In UTF-8 locale: word chars are non-whitespace bytes (high bytes are part of multi-byte chars).
/// In C locale: word chars are only printable ASCII (0x21-0x7E). High bytes are non-word.
///
/// On x86_64 in UTF-8 mode, uses SSE2 SIMD acceleration.
/// In C locale or non-x86_64, uses scalar table lookup with 64-byte block bitmasks.
pub fn count_words(data: &[u8]) -> u64 {
    count_words_locale(data, true)
}

/// Count words with explicit locale control.
/// C locale uses scalar table-based path.
/// UTF-8 locale uses a state machine for correct multi-byte sequence handling.
pub fn count_words_locale(data: &[u8], utf8: bool) -> u64 {
    if utf8 {
        count_words_utf8(data)
    } else {
        count_words_with_table(data, &WS_TABLE_C)
    }
}

/// Count words in UTF-8 locale using a state machine.
/// Correctly handles:
/// - Valid multi-byte UTF-8 sequences (word content)
/// - Invalid standalone continuation bytes (non-word, mbrtowc fails)
/// - Control characters (non-word)
/// - Invalid UTF-8 leaders without proper continuations (non-word)
fn count_words_utf8(data: &[u8]) -> u64 {
    let mut words = 0u64;
    let mut in_word = false;
    let mut i = 0;

    while i < data.len() {
        let b = data[i];

        if b <= 0x20 || b == 0x7F {
            // Control chars (0x00-0x1F), space (0x20), DEL (0x7F): non-word
            in_word = false;
            i += 1;
        } else if b < 0x80 {
            // Printable ASCII (0x21-0x7E): word content
            if !in_word {
                in_word = true;
                words += 1;
            }
            i += 1;
        } else if b < 0xC2 {
            // 0x80-0xBF: standalone continuation byte (invalid UTF-8)
            // 0xC0-0xC1: overlong 2-byte (invalid UTF-8)
            in_word = false;
            i += 1;
        } else if b < 0xE0 {
            // 2-byte sequence: need 1 continuation byte
            if i + 1 < data.len() && (data[i + 1] & 0xC0) == 0x80 {
                if !in_word {
                    in_word = true;
                    words += 1;
                }
                i += 2;
            } else {
                in_word = false;
                i += 1;
            }
        } else if b < 0xF0 {
            // 3-byte sequence: need 2 continuation bytes
            if i + 2 < data.len() && (data[i + 1] & 0xC0) == 0x80 && (data[i + 2] & 0xC0) == 0x80 {
                if !in_word {
                    in_word = true;
                    words += 1;
                }
                i += 3;
            } else {
                in_word = false;
                i += 1;
            }
        } else if b < 0xF5 {
            // 4-byte sequence: need 3 continuation bytes
            if i + 3 < data.len()
                && (data[i + 1] & 0xC0) == 0x80
                && (data[i + 2] & 0xC0) == 0x80
                && (data[i + 3] & 0xC0) == 0x80
            {
                if !in_word {
                    in_word = true;
                    words += 1;
                }
                i += 4;
            } else {
                in_word = false;
                i += 1;
            }
        } else {
            // 0xF5-0xFF: invalid UTF-8
            in_word = false;
            i += 1;
        }
    }

    words
}

/// Scalar word counting with a given non-word lookup table.
fn count_words_with_table(data: &[u8], table: &[u8; 256]) -> u64 {
    let mut words = 0u64;
    let mut prev_ws_bit = 1u64;

    let chunks = data.chunks_exact(64);
    let remainder = chunks.remainder();

    for chunk in chunks {
        let mut ws_mask = 0u64;
        let mut i = 0;
        while i + 7 < 64 {
            ws_mask |= (table[chunk[i] as usize] as u64) << i;
            ws_mask |= (table[chunk[i + 1] as usize] as u64) << (i + 1);
            ws_mask |= (table[chunk[i + 2] as usize] as u64) << (i + 2);
            ws_mask |= (table[chunk[i + 3] as usize] as u64) << (i + 3);
            ws_mask |= (table[chunk[i + 4] as usize] as u64) << (i + 4);
            ws_mask |= (table[chunk[i + 5] as usize] as u64) << (i + 5);
            ws_mask |= (table[chunk[i + 6] as usize] as u64) << (i + 6);
            ws_mask |= (table[chunk[i + 7] as usize] as u64) << (i + 7);
            i += 8;
        }

        let prev_mask = (ws_mask << 1) | prev_ws_bit;
        let word_starts = prev_mask & !ws_mask;
        words += word_starts.count_ones() as u64;
        prev_ws_bit = (ws_mask >> 63) & 1;
    }

    let mut prev_ws = prev_ws_bit as u8;
    for &b in remainder {
        let curr_ws = table[b as usize];
        words += (prev_ws & (curr_ws ^ 1)) as u64;
        prev_ws = curr_ws;
    }
    words
}

/// SSE2-accelerated word counting (UTF-8 locale only).
/// NOTE: Currently unused in favor of scalar table-based approach for correctness.
/// Kept for potential future re-enablement after updating to handle all non-word bytes.
#[cfg(target_arch = "x86_64")]
#[target_feature(enable = "sse2")]
#[allow(dead_code)]
unsafe fn count_words_sse2(data: &[u8]) -> u64 {
    use std::arch::x86_64::*;

    unsafe {
        // Whitespace = (b == 0x00) || (0x09 <= b <= 0x0D) || (b == 0x20)
        // Null bytes are word separators in GNU wc.
        // Using signed comparison: cmpgt(b, 0x08) && cmpgt(0x0E, b) || cmpeq(b, 0x20) || cmpeq(b, 0x00)
        let zero = _mm_setzero_si128();
        let min_ws = _mm_set1_epi8(0x08); // one below \t
        let max_ws = _mm_set1_epi8(0x0E); // one above \r
        let space = _mm_set1_epi8(0x20);

        let mut words = 0u64;
        let mut prev_ws_bit = 1u64; // treat start-of-data as whitespace

        let chunks = data.chunks_exact(64);
        let remainder = chunks.remainder();

        for chunk in chunks {
            let ptr = chunk.as_ptr();

            // Load 4 x 16-byte vectors
            let v0 = _mm_loadu_si128(ptr as *const __m128i);
            let v1 = _mm_loadu_si128(ptr.add(16) as *const __m128i);
            let v2 = _mm_loadu_si128(ptr.add(32) as *const __m128i);
            let v3 = _mm_loadu_si128(ptr.add(48) as *const __m128i);

            // Detect whitespace in each vector: range check + space + null
            macro_rules! detect_ws {
                ($v:expr) => {{
                    let ge_9 = _mm_cmpgt_epi8($v, min_ws);
                    let le_d = _mm_cmpgt_epi8(max_ws, $v);
                    let in_range = _mm_and_si128(ge_9, le_d);
                    let is_sp = _mm_cmpeq_epi8($v, space);
                    let is_null = _mm_cmpeq_epi8($v, zero);
                    let ws = _mm_or_si128(in_range, is_sp);
                    _mm_or_si128(ws, is_null)
                }};
            }

            let ws0 = detect_ws!(v0);
            let ws1 = detect_ws!(v1);
            let ws2 = detect_ws!(v2);
            let ws3 = detect_ws!(v3);

            // Combine 4 x 16-bit movemasks into one 64-bit whitespace mask
            let m0 = (_mm_movemask_epi8(ws0) as u16) as u64;
            let m1 = (_mm_movemask_epi8(ws1) as u16) as u64;
            let m2 = (_mm_movemask_epi8(ws2) as u16) as u64;
            let m3 = (_mm_movemask_epi8(ws3) as u16) as u64;
            let ws_mask = m0 | (m1 << 16) | (m2 << 32) | (m3 << 48);

            // Word starts: where previous byte was whitespace AND current is NOT
            let prev_mask = (ws_mask << 1) | prev_ws_bit;
            let word_starts = prev_mask & !ws_mask;
            words += word_starts.count_ones() as u64;

            prev_ws_bit = (ws_mask >> 63) & 1;
        }

        // Handle 16-byte sub-chunks of remainder
        let sub_chunks = remainder.chunks_exact(16);
        let sub_remainder = sub_chunks.remainder();
        let mut prev_ws_u32 = prev_ws_bit as u32;

        for chunk in sub_chunks {
            let v = _mm_loadu_si128(chunk.as_ptr() as *const __m128i);
            let ge_9 = _mm_cmpgt_epi8(v, min_ws);
            let le_d = _mm_cmpgt_epi8(max_ws, v);
            let in_range = _mm_and_si128(ge_9, le_d);
            let is_sp = _mm_cmpeq_epi8(v, space);
            let is_null = _mm_cmpeq_epi8(v, zero);
            let ws_vec = _mm_or_si128(_mm_or_si128(in_range, is_sp), is_null);
            let ws_mask = _mm_movemask_epi8(ws_vec) as u32;

            let prev_mask = (ws_mask << 1) | prev_ws_u32;
            let word_starts = prev_mask & (!ws_mask & 0xFFFF);
            words += word_starts.count_ones() as u64;
            prev_ws_u32 = (ws_mask >> 15) & 1;
        }

        // Scalar for final <16 bytes
        let mut prev_ws = prev_ws_u32 as u8;
        for &b in sub_remainder {
            let curr_ws = WS_TABLE_UTF8[b as usize];
            words += (prev_ws & (curr_ws ^ 1)) as u64;
            prev_ws = curr_ws;
        }
        words
    }
}

/// Count lines and words in a single pass using 64-byte bitmask blocks.
pub fn count_lines_words(data: &[u8], utf8: bool) -> (u64, u64) {
    let table = ws_table(utf8);
    let mut words = 0u64;
    let mut lines = 0u64;
    let mut prev_ws_bit = 1u64;

    let chunks = data.chunks_exact(64);
    let remainder = chunks.remainder();

    for chunk in chunks {
        let mut ws_mask = 0u64;
        let mut nl_mask = 0u64;
        let mut i = 0;
        while i + 7 < 64 {
            let b0 = chunk[i];
            let b1 = chunk[i + 1];
            let b2 = chunk[i + 2];
            let b3 = chunk[i + 3];
            let b4 = chunk[i + 4];
            let b5 = chunk[i + 5];
            let b6 = chunk[i + 6];
            let b7 = chunk[i + 7];
            ws_mask |= (table[b0 as usize] as u64) << i;
            ws_mask |= (table[b1 as usize] as u64) << (i + 1);
            ws_mask |= (table[b2 as usize] as u64) << (i + 2);
            ws_mask |= (table[b3 as usize] as u64) << (i + 3);
            ws_mask |= (table[b4 as usize] as u64) << (i + 4);
            ws_mask |= (table[b5 as usize] as u64) << (i + 5);
            ws_mask |= (table[b6 as usize] as u64) << (i + 6);
            ws_mask |= (table[b7 as usize] as u64) << (i + 7);
            nl_mask |= ((b0 == b'\n') as u64) << i;
            nl_mask |= ((b1 == b'\n') as u64) << (i + 1);
            nl_mask |= ((b2 == b'\n') as u64) << (i + 2);
            nl_mask |= ((b3 == b'\n') as u64) << (i + 3);
            nl_mask |= ((b4 == b'\n') as u64) << (i + 4);
            nl_mask |= ((b5 == b'\n') as u64) << (i + 5);
            nl_mask |= ((b6 == b'\n') as u64) << (i + 6);
            nl_mask |= ((b7 == b'\n') as u64) << (i + 7);
            i += 8;
        }

        let prev_mask = (ws_mask << 1) | prev_ws_bit;
        let word_starts = prev_mask & !ws_mask;
        words += word_starts.count_ones() as u64;
        lines += nl_mask.count_ones() as u64;
        prev_ws_bit = (ws_mask >> 63) & 1;
    }

    let mut prev_ws = prev_ws_bit as u8;
    for &b in remainder {
        if b == b'\n' {
            lines += 1;
        }
        let curr_ws = table[b as usize];
        words += (prev_ws & (curr_ws ^ 1)) as u64;
        prev_ws = curr_ws;
    }
    (lines, words)
}

/// Count lines, words, and chars in a single pass using 64-byte bitmask blocks.
pub fn count_lines_words_chars(data: &[u8], utf8: bool) -> (u64, u64, u64) {
    let table = ws_table(utf8);
    let mut words = 0u64;
    let mut lines = 0u64;
    let mut chars = 0u64;
    let mut prev_ws_bit = 1u64;

    let chunks = data.chunks_exact(64);
    let remainder = chunks.remainder();

    for chunk in chunks {
        let mut ws_mask = 0u64;
        let mut nl_mask = 0u64;
        let mut char_mask = 0u64;
        let mut i = 0;
        while i + 7 < 64 {
            let b0 = chunk[i];
            let b1 = chunk[i + 1];
            let b2 = chunk[i + 2];
            let b3 = chunk[i + 3];
            let b4 = chunk[i + 4];
            let b5 = chunk[i + 5];
            let b6 = chunk[i + 6];
            let b7 = chunk[i + 7];

            ws_mask |= (table[b0 as usize] as u64) << i
                | (table[b1 as usize] as u64) << (i + 1)
                | (table[b2 as usize] as u64) << (i + 2)
                | (table[b3 as usize] as u64) << (i + 3)
                | (table[b4 as usize] as u64) << (i + 4)
                | (table[b5 as usize] as u64) << (i + 5)
                | (table[b6 as usize] as u64) << (i + 6)
                | (table[b7 as usize] as u64) << (i + 7);

            nl_mask |= ((b0 == b'\n') as u64) << i
                | ((b1 == b'\n') as u64) << (i + 1)
                | ((b2 == b'\n') as u64) << (i + 2)
                | ((b3 == b'\n') as u64) << (i + 3)
                | ((b4 == b'\n') as u64) << (i + 4)
                | ((b5 == b'\n') as u64) << (i + 5)
                | ((b6 == b'\n') as u64) << (i + 6)
                | ((b7 == b'\n') as u64) << (i + 7);

            if utf8 {
                char_mask |= (((b0 & 0xC0) != 0x80) as u64) << i
                    | (((b1 & 0xC0) != 0x80) as u64) << (i + 1)
                    | (((b2 & 0xC0) != 0x80) as u64) << (i + 2)
                    | (((b3 & 0xC0) != 0x80) as u64) << (i + 3)
                    | (((b4 & 0xC0) != 0x80) as u64) << (i + 4)
                    | (((b5 & 0xC0) != 0x80) as u64) << (i + 5)
                    | (((b6 & 0xC0) != 0x80) as u64) << (i + 6)
                    | (((b7 & 0xC0) != 0x80) as u64) << (i + 7);
            }

            i += 8;
        }
        let prev_mask = (ws_mask << 1) | prev_ws_bit;
        let word_starts = prev_mask & !ws_mask;
        words += word_starts.count_ones() as u64;
        lines += nl_mask.count_ones() as u64;
        chars += char_mask.count_ones() as u64;
        prev_ws_bit = (ws_mask >> 63) & 1;
    }

    let mut prev_ws = prev_ws_bit as u8;
    for &b in remainder {
        if b == b'\n' {
            lines += 1;
        }
        let curr_ws = table[b as usize];
        words += (prev_ws & (curr_ws ^ 1)) as u64;
        prev_ws = curr_ws;
        if utf8 {
            chars += ((b & 0xC0) != 0x80) as u64;
        }
    }
    if !utf8 {
        chars = data.len() as u64;
    }
    (lines, words, chars)
}

/// Count UTF-8 characters by counting non-continuation bytes.
/// A continuation byte has the bit pattern `10xxxxxx` (0x80..0xBF).
/// Every other byte starts a new character (ASCII, multi-byte leader, or invalid).
///
/// Uses 64-byte block processing with popcount for ~4x throughput vs scalar.
pub fn count_chars_utf8(data: &[u8]) -> u64 {
    let mut count = 0u64;
    let chunks = data.chunks_exact(64);
    let remainder = chunks.remainder();

    for chunk in chunks {
        // Build 64-bit mask: bit i = 1 if chunk[i] is NOT a continuation byte
        let mut char_mask = 0u64;
        let mut i = 0;
        while i + 7 < 64 {
            char_mask |= (((chunk[i] & 0xC0) != 0x80) as u64) << i;
            char_mask |= (((chunk[i + 1] & 0xC0) != 0x80) as u64) << (i + 1);
            char_mask |= (((chunk[i + 2] & 0xC0) != 0x80) as u64) << (i + 2);
            char_mask |= (((chunk[i + 3] & 0xC0) != 0x80) as u64) << (i + 3);
            char_mask |= (((chunk[i + 4] & 0xC0) != 0x80) as u64) << (i + 4);
            char_mask |= (((chunk[i + 5] & 0xC0) != 0x80) as u64) << (i + 5);
            char_mask |= (((chunk[i + 6] & 0xC0) != 0x80) as u64) << (i + 6);
            char_mask |= (((chunk[i + 7] & 0xC0) != 0x80) as u64) << (i + 7);
            i += 8;
        }
        count += char_mask.count_ones() as u64;
    }

    for &b in remainder {
        count += ((b & 0xC0) != 0x80) as u64;
    }
    count
}

/// Count characters in C/POSIX locale (each byte is one character).
#[inline]
pub fn count_chars_c(data: &[u8]) -> u64 {
    data.len() as u64
}

/// Count characters, choosing behavior based on locale.
#[inline]
pub fn count_chars(data: &[u8], utf8: bool) -> u64 {
    if utf8 {
        count_chars_utf8(data)
    } else {
        count_chars_c(data)
    }
}

/// Detect if the current locale uses UTF-8 encoding.
pub fn is_utf8_locale() -> bool {
    for var in &["LC_ALL", "LC_CTYPE", "LANG"] {
        if let Ok(val) = std::env::var(var) {
            if !val.is_empty() {
                let lower = val.to_ascii_lowercase();
                return lower.contains("utf-8") || lower.contains("utf8");
            }
        }
    }
    false
}

/// Decode one UTF-8 character from a byte slice.
/// Returns (codepoint, byte_length). On invalid UTF-8, returns (byte as u32, 1).
#[inline]
fn decode_utf8(bytes: &[u8]) -> (u32, usize) {
    let b0 = bytes[0];
    if b0 < 0x80 {
        return (b0 as u32, 1);
    }
    if b0 < 0xC2 {
        // Continuation byte or overlong 2-byte — invalid as start
        return (b0 as u32, 1);
    }
    if b0 < 0xE0 {
        if bytes.len() < 2 || bytes[1] & 0xC0 != 0x80 {
            return (b0 as u32, 1);
        }
        let cp = ((b0 as u32 & 0x1F) << 6) | (bytes[1] as u32 & 0x3F);
        return (cp, 2);
    }
    if b0 < 0xF0 {
        if bytes.len() < 3 || bytes[1] & 0xC0 != 0x80 || bytes[2] & 0xC0 != 0x80 {
            return (b0 as u32, 1);
        }
        let cp =
            ((b0 as u32 & 0x0F) << 12) | ((bytes[1] as u32 & 0x3F) << 6) | (bytes[2] as u32 & 0x3F);
        return (cp, 3);
    }
    if b0 < 0xF5 {
        if bytes.len() < 4
            || bytes[1] & 0xC0 != 0x80
            || bytes[2] & 0xC0 != 0x80
            || bytes[3] & 0xC0 != 0x80
        {
            return (b0 as u32, 1);
        }
        let cp = ((b0 as u32 & 0x07) << 18)
            | ((bytes[1] as u32 & 0x3F) << 12)
            | ((bytes[2] as u32 & 0x3F) << 6)
            | (bytes[3] as u32 & 0x3F);
        return (cp, 4);
    }
    (b0 as u32, 1)
}

/// Check if a Unicode codepoint is an East Asian Wide/Fullwidth character (display width 2).
#[inline]
fn is_wide_char(cp: u32) -> bool {
    matches!(cp,
        0x1100..=0x115F   // Hangul Jamo
        | 0x231A..=0x231B // Watch, Hourglass
        | 0x2329..=0x232A // Angle Brackets
        | 0x23E9..=0x23F3 // Various symbols
        | 0x23F8..=0x23FA
        | 0x25FD..=0x25FE
        | 0x2614..=0x2615
        | 0x2648..=0x2653
        | 0x267F
        | 0x2693
        | 0x26A1
        | 0x26AA..=0x26AB
        | 0x26BD..=0x26BE
        | 0x26C4..=0x26C5
        | 0x26CE
        | 0x26D4
        | 0x26EA
        | 0x26F2..=0x26F3
        | 0x26F5
        | 0x26FA
        | 0x26FD
        | 0x2702
        | 0x2705
        | 0x2708..=0x270D
        | 0x270F
        | 0x2712
        | 0x2714
        | 0x2716
        | 0x271D
        | 0x2721
        | 0x2728
        | 0x2733..=0x2734
        | 0x2744
        | 0x2747
        | 0x274C
        | 0x274E
        | 0x2753..=0x2755
        | 0x2757
        | 0x2763..=0x2764
        | 0x2795..=0x2797
        | 0x27A1
        | 0x27B0
        | 0x27BF
        | 0x2934..=0x2935
        | 0x2B05..=0x2B07
        | 0x2B1B..=0x2B1C
        | 0x2B50
        | 0x2B55
        | 0x2E80..=0x303E  // CJK Radicals, Kangxi Radicals, Ideographic Description
        | 0x3041..=0x33BF  // Hiragana, Katakana, Bopomofo, Hangul Compat Jamo, Kanbun, CJK
        | 0x3400..=0x4DBF  // CJK Unified Ideographs Extension A
        | 0x4E00..=0xA4CF  // CJK Unified Ideographs, Yi
        | 0xA960..=0xA97C  // Hangul Jamo Extended-A
        | 0xAC00..=0xD7A3  // Hangul Syllables
        | 0xF900..=0xFAFF  // CJK Compatibility Ideographs
        | 0xFE10..=0xFE19  // Vertical Forms
        | 0xFE30..=0xFE6F  // CJK Compatibility Forms
        | 0xFF01..=0xFF60  // Fullwidth Latin, Halfwidth Katakana
        | 0xFFE0..=0xFFE6  // Fullwidth Signs
        | 0x1F004
        | 0x1F0CF
        | 0x1F170..=0x1F171
        | 0x1F17E..=0x1F17F
        | 0x1F18E
        | 0x1F191..=0x1F19A
        | 0x1F1E0..=0x1F1FF // Regional Indicators
        | 0x1F200..=0x1F202
        | 0x1F210..=0x1F23B
        | 0x1F240..=0x1F248
        | 0x1F250..=0x1F251
        | 0x1F260..=0x1F265
        | 0x1F300..=0x1F64F // Misc Symbols, Emoticons
        | 0x1F680..=0x1F6FF // Transport Symbols
        | 0x1F900..=0x1F9FF // Supplemental Symbols
        | 0x1FA00..=0x1FA6F
        | 0x1FA70..=0x1FAFF
        | 0x20000..=0x2FFFD // CJK Unified Ideographs Extension B-F
        | 0x30000..=0x3FFFD // CJK Unified Ideographs Extension G
    )
}

/// Compute maximum display width of any line (C/POSIX locale).
///
/// GNU wc -L behavior in C locale:
/// - `\n`: line terminator (records max, resets position)
/// - `\t`: advances to next tab stop (multiple of 8)
/// - `\r`: carriage return (resets position to 0, same line)
/// - `\f`: form feed (acts as line terminator like \n)
/// - Printable ASCII (0x20..0x7E): width 1
/// - Everything else (controls, high bytes): width 0
pub fn max_line_length_c(data: &[u8]) -> u64 {
    let mut max_len: u64 = 0;
    let mut line_len: u64 = 0; // max position seen on current line
    let mut linepos: u64 = 0; // current cursor position

    for &b in data {
        match b {
            b'\n' => {
                if line_len > max_len {
                    max_len = line_len;
                }
                linepos = 0;
                line_len = 0;
            }
            b'\t' => {
                linepos = (linepos + 8) & !7;
                if linepos > line_len {
                    line_len = linepos;
                }
            }
            b'\r' => {
                linepos = 0;
            }
            0x0C => {
                // Form feed: acts as line terminator
                if line_len > max_len {
                    max_len = line_len;
                }
                linepos = 0;
                line_len = 0;
            }
            _ => {
                if PRINTABLE_TABLE[b as usize] != 0 {
                    linepos += 1;
                    if linepos > line_len {
                        line_len = linepos;
                    }
                }
                // Non-printable: width 0
            }
        }
    }

    // Handle last line (may not end with \n)
    if line_len > max_len {
        max_len = line_len;
    }

    max_len
}

/// Compute maximum display width of any line (UTF-8 locale).
///
/// GNU wc -L in UTF-8 locale uses mbrtowc() + wcwidth() for display width.
/// East Asian Wide/Fullwidth characters get width 2, most others get width 1.
pub fn max_line_length_utf8(data: &[u8]) -> u64 {
    let mut max_len: u64 = 0;
    let mut line_len: u64 = 0;
    let mut linepos: u64 = 0;
    let mut i = 0;

    while i < data.len() {
        let b = data[i];

        // Fast path for common ASCII
        if b < 0x80 {
            match b {
                b'\n' => {
                    if line_len > max_len {
                        max_len = line_len;
                    }
                    linepos = 0;
                    line_len = 0;
                }
                b'\t' => {
                    linepos = (linepos + 8) & !7;
                    if linepos > line_len {
                        line_len = linepos;
                    }
                }
                b'\r' => {
                    linepos = 0;
                }
                0x0C => {
                    // Form feed: line terminator
                    if line_len > max_len {
                        max_len = line_len;
                    }
                    linepos = 0;
                    line_len = 0;
                }
                0x20..=0x7E => {
                    // Printable ASCII
                    linepos += 1;
                    if linepos > line_len {
                        line_len = linepos;
                    }
                }
                _ => {
                    // Non-printable ASCII control chars: width 0
                }
            }
            i += 1;
        } else {
            // Multibyte UTF-8
            let (cp, len) = decode_utf8(&data[i..]);

            // C1 control characters (0x80..0x9F): non-printable
            if cp <= 0x9F {
                // width 0
            } else if is_wide_char(cp) {
                linepos += 2;
                if linepos > line_len {
                    line_len = linepos;
                }
            } else {
                // Regular printable Unicode character: width 1
                linepos += 1;
                if linepos > line_len {
                    line_len = linepos;
                }
            }
            i += len;
        }
    }

    // Handle last line
    if line_len > max_len {
        max_len = line_len;
    }

    max_len
}

/// Compute maximum display width, choosing behavior based on locale.
#[inline]
pub fn max_line_length(data: &[u8], utf8: bool) -> u64 {
    if utf8 {
        max_line_length_utf8(data)
    } else {
        max_line_length_c(data)
    }
}

/// Count all metrics using optimized individual passes.
///
/// Each metric uses its own optimized algorithm:
/// - Lines: SIMD-accelerated memchr
/// - Words: branchless lookup table
/// - Chars: non-continuation byte counting (UTF-8) or byte counting (C locale)
/// - Max line length: locale-aware display width tracking
///
/// Multi-pass is faster than single-pass because each pass has a tight,
/// specialized loop. After the first pass, data is hot in L2/L3 cache,
/// making subsequent passes nearly free for memory bandwidth.
pub fn count_all(data: &[u8], utf8: bool) -> WcCounts {
    WcCounts {
        lines: count_lines(data),
        words: count_words_locale(data, utf8),
        bytes: data.len() as u64,
        chars: count_chars(data, utf8),
        max_line_length: max_line_length(data, utf8),
    }
}

// ──────────────────────────────────────────────────
// Parallel counting for large files
// ──────────────────────────────────────────────────

/// Count newlines in parallel using SIMD memchr + rayon.
pub fn count_lines_parallel(data: &[u8]) -> u64 {
    if data.len() < PARALLEL_THRESHOLD {
        return count_lines(data);
    }

    let num_threads = rayon::current_num_threads().max(1);
    let chunk_size = (data.len() / num_threads).max(1024 * 1024);

    data.par_chunks(chunk_size)
        .map(|chunk| memchr_iter(b'\n', chunk).count() as u64)
        .sum()
}

/// Count words in parallel with boundary adjustment.
pub fn count_words_parallel(data: &[u8], utf8: bool) -> u64 {
    if utf8 || data.len() < PARALLEL_THRESHOLD {
        // UTF-8 word counting uses a state machine that can't be trivially parallelized
        // (multi-byte sequences may span chunk boundaries).
        return count_words_locale(data, utf8);
    }

    let table = &WS_TABLE_C;
    let num_threads = rayon::current_num_threads().max(1);
    let chunk_size = (data.len() / num_threads).max(1024 * 1024);

    let chunks: Vec<&[u8]> = data.chunks(chunk_size).collect();

    let results: Vec<(u64, bool, bool)> = chunks
        .par_iter()
        .map(|chunk| {
            let words = count_words_with_table(chunk, table);
            let starts_non_ws = chunk.first().is_some_and(|&b| table[b as usize] == 0);
            let ends_non_ws = chunk.last().is_some_and(|&b| table[b as usize] == 0);
            (words, starts_non_ws, ends_non_ws)
        })
        .collect();

    let mut total = 0u64;
    for i in 0..results.len() {
        total += results[i].0;
        if i > 0 && results[i].1 && results[i - 1].2 {
            total -= 1;
        }
    }
    total
}

/// Count UTF-8 characters in parallel.
pub fn count_chars_parallel(data: &[u8], utf8: bool) -> u64 {
    if !utf8 {
        return data.len() as u64;
    }
    if data.len() < PARALLEL_THRESHOLD {
        return count_chars_utf8(data);
    }

    let num_threads = rayon::current_num_threads().max(1);
    let chunk_size = (data.len() / num_threads).max(1024 * 1024);

    data.par_chunks(chunk_size).map(count_chars_utf8).sum()
}

/// Combined parallel counting of lines + words + chars.
pub fn count_lwc_parallel(data: &[u8], utf8: bool) -> (u64, u64, u64) {
    if data.len() < PARALLEL_THRESHOLD {
        let lines = count_lines(data);
        let words = count_words_locale(data, utf8);
        let chars = count_chars(data, utf8);
        return (lines, words, chars);
    }

    // Word counting: sequential for UTF-8 (state machine), parallel for C locale
    let words = count_words_parallel(data, utf8);

    // Lines and chars can always be parallelized safely
    let num_threads = rayon::current_num_threads().max(1);
    let chunk_size = (data.len() / num_threads).max(1024 * 1024);

    let lines: u64 = data
        .par_chunks(chunk_size)
        .map(|chunk| memchr_iter(b'\n', chunk).count() as u64)
        .sum();

    let chars = if utf8 {
        data.par_chunks(chunk_size).map(count_chars_utf8).sum()
    } else {
        data.len() as u64
    };

    (lines, words, chars)
}