atomic_http 0.14.1

pub trait SplitBytes {
    /// 슬라이스를 delimiter로 분할하여 부분 슬라이스를 반환 (할당 없음).
    /// 끝의 multipart 종료 마커 `--\r\n`은 결과에서 제외.
    fn split_bytes<'a>(&'a self, delimiter: &[u8]) -> Vec<&'a [u8]>;
    fn split_header_body(&self) -> (Vec<u8>, Vec<u8>);
}

/// HTTP 헤더 끝(`\r\n\r\n`) 위치를 찾는 통합 진입점.
/// `simd` 피쳐 활성 시 SSE2/AVX2 fast-path, 미활성 시 스칼라.
/// 반환 위치는 `\r\n\r\n`의 첫 `\r` 인덱스.
pub fn find_header_end(data: &[u8]) -> Option<usize> {
    #[cfg(feature = "simd")]
    {
        return simd::find_header_end_simd(data);
    }
    #[cfg(not(feature = "simd"))]
    {
        data.windows(4).position(|w| w == b"\r\n\r\n")
    }
}

#[cfg(feature = "simd")]
mod simd {
    #[cfg(target_arch = "x86_64")]
    use std::arch::x86_64::*;

    /// SIMD를 사용하여 \r\n\r\n 패턴을 빠르게 찾기
    #[cfg(target_arch = "x86_64")]
    #[target_feature(enable = "sse2")]
    pub unsafe fn find_header_end_sse2(data: &[u8]) -> Option<usize> {
        if data.len() < 16 {
            return find_header_end_scalar(data);
        }

        let pattern = [b'\r', b'\n', b'\r', b'\n'];
        let _pattern_vec = _mm_set_epi8(
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            pattern[3] as i8,
            pattern[2] as i8,
            pattern[1] as i8,
            pattern[0] as i8,
        );

        let mut i = 0;
        let end = data.len() - 15;

        while i < end {
            let chunk = _mm_loadu_si128(data.as_ptr().add(i) as *const __m128i);

            // \r 검색
            let cr_cmp = _mm_cmpeq_epi8(chunk, _mm_set1_epi8(b'\r' as i8));
            let cr_mask = _mm_movemask_epi8(cr_cmp) as u16;

            if cr_mask != 0 {
                // \r이 발견된 위치들을 확인
                for bit_pos in 0..16 {
                    if (cr_mask & (1 << bit_pos)) != 0 {
                        let pos = i + bit_pos;
                        if pos + 4 <= data.len() && data[pos..pos + 4] == pattern {
                            return Some(pos);
                        }
                    }
                }
            }
            i += 16;
        }

        // 남은 부분은 스칼라로 처리
        find_header_end_scalar(&data[i..]).map(|pos| pos + i)
    }

    #[cfg(target_arch = "x86_64")]
    #[target_feature(enable = "avx2")]
    pub unsafe fn find_header_end_avx2(data: &[u8]) -> Option<usize> {
        if data.len() < 32 {
            return find_header_end_sse2(data);
        }

        let pattern = [b'\r', b'\n', b'\r', b'\n'];

        let mut i = 0;
        let end = data.len() - 31;

        while i < end {
            let chunk = _mm256_loadu_si256(data.as_ptr().add(i) as *const __m256i);

            // \r 검색
            let cr_cmp = _mm256_cmpeq_epi8(chunk, _mm256_set1_epi8(b'\r' as i8));
            let cr_mask = _mm256_movemask_epi8(cr_cmp) as u32;

            if cr_mask != 0 {
                // \r이 발견된 위치들을 확인
                for bit_pos in 0..32 {
                    if (cr_mask & (1 << bit_pos)) != 0 {
                        let pos = i + bit_pos;
                        if pos + 4 <= data.len() && data[pos..pos + 4] == pattern {
                            return Some(pos);
                        }
                    }
                }
            }
            i += 32;
        }

        // 남은 부분은 SSE2로 처리
        find_header_end_sse2(&data[i..]).map(|pos| pos + i)
    }

    fn find_header_end_scalar(data: &[u8]) -> Option<usize> {
        if data.len() < 4 {
            return None;
        }
        data.windows(4).position(|w| w == b"\r\n\r\n")
    }

    pub fn find_header_end_simd(data: &[u8]) -> Option<usize> {
        #[cfg(target_arch = "x86_64")]
        {
            if is_x86_feature_detected!("avx2") {
                return unsafe { find_header_end_avx2(data) };
            } else if is_x86_feature_detected!("sse2") {
                return unsafe { find_header_end_sse2(data) };
            }
        }

        // Fallback to scalar implementation
        find_header_end_scalar(data)
    }
}

impl SplitBytes for [u8] {
    fn split_bytes<'a>(&'a self, delimiter: &[u8]) -> Vec<&'a [u8]> {
        // 슬라이스 기반 분할 — 각 파트는 입력의 부분 슬라이스 (복사 없음).
        // 동일 위치 다중 매치는 발생하지 않으므로 i를 delimiter.len()만큼 진행.
        let mut result = Vec::new();
        if delimiter.is_empty() || self.len() < delimiter.len() {
            return result;
        }
        let mut start = 0;
        let mut i = 0;
        let end = self.len() - delimiter.len();
        while i <= end {
            if &self[i..i + delimiter.len()] == delimiter {
                let part = &self[start..i];
                if !part.is_empty() {
                    result.push(part);
                }
                i += delimiter.len();
                start = i;
            } else {
                i += 1;
            }
        }
        // 마지막 segment: multipart 종료 마커 `--\r\n` 은 제외
        let last = &self[start..];
        if !last.is_empty() && last != b"--\r\n" {
            result.push(last);
        }
        result
    }

    fn split_header_body(&self) -> (Vec<u8>, Vec<u8>) {
        // 통합 find_header_end 재사용 — simd/scalar 분기는 한 곳에서.
        if let Some(pos) = find_header_end(self) {
            (self[..pos].to_vec(), self[pos + 4..].to_vec())
        } else {
            // 마커를 찾지 못한 경우 전체를 헤더로 처리
            (self.to_vec(), Vec::new())
        }
    }
}

#[cfg(feature = "arena")]
pub trait SplitBytesArena {
    fn split_bytes_arena(&self, delimiter: &[u8]) -> Vec<&[u8]>;
    fn split_header_body_arena(&self) -> (&[u8], &[u8]);
}

#[cfg(feature = "arena")]
impl SplitBytesArena for &[u8] {
    fn split_bytes_arena(&self, delimiter: &[u8]) -> Vec<&[u8]> {
        let mut result = Vec::new();
        let mut start = 0;

        for i in 0..self.len() {
            if i + delimiter.len() <= self.len() && &self[i..i + delimiter.len()] == delimiter {
                if start < i {
                    let slice = &self[start..i];
                    if !slice.is_empty() {
                        result.push(slice);
                    }
                }
                start = i + delimiter.len();
            }
        }

        // 마지막 부분 처리
        if start < self.len() {
            let last_slice = &self[start..];
            // multipart 끝 마커 "--\r\n" 체크
            if last_slice != [45, 45, 13, 10] && !last_slice.is_empty() {
                result.push(last_slice);
            }
        }

        result
    }

    fn split_header_body_arena(&self) -> (&[u8], &[u8]) {
        #[cfg(feature = "simd")]
        {
            if let Some(pos) = simd::find_header_end_simd(self) {
                let header = &self[..pos];
                let body = &self[pos + 4..];
                return (header, body);
            }
        }

        #[cfg(not(feature = "simd"))]
        {
            // "\r\n\r\n" 찾기 (기존 스칼라 방식)
            let delimiter = b"\r\n\r\n";

            for i in 0..self.len() {
                if i + delimiter.len() <= self.len() && &self[i..i + delimiter.len()] == delimiter {
                    let header = &self[..i];
                    let body = &self[i + delimiter.len()..];
                    return (header, body);
                }
            }
        }

        // 구분자를 찾지 못한 경우 전체를 헤더로 처리
        (self, &[])
    }
}