use std::collections::HashMap;

const DEFAULT_CHUNK_SIZE: usize = 1024 * 1024; // 1MB

fn get_chunk_size(params: &HashMap<&str, &str>) -> usize {
    params
        .get("size")
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_CHUNK_SIZE)
}

pub async fn chunk_fixed_size(raw_data: &[u8], params: &HashMap<&str, &str>) -> Vec<u32> {
    let chunk_size = get_chunk_size(params);
    (chunk_size..raw_data.len())
        .step_by(chunk_size)
        .map(|pos| pos as u32)
        .collect()
}

#[derive(Default)]
pub struct FixedSizeStream {
    processed_bytes: usize,
}

pub async fn chunk_fixed_size_stream(
    _current_data: &[u8],
    len: u32,
    stream: &mut FixedSizeStream,
    params: &HashMap<&str, &str>,
) -> Option<u32> {
    let chunk_size = get_chunk_size(params);
    let valid_len = len as usize;

    let prev_chunk = stream.processed_bytes / chunk_size;
    let new_processed = stream.processed_bytes + valid_len;
    let new_chunk = new_processed / chunk_size;

    if prev_chunk != new_chunk {
        // Find chunk boundary in current data, update processed bytes, return position
        let boundary_in_chunk = chunk_size - (stream.processed_bytes % chunk_size);
        stream.processed_bytes += boundary_in_chunk;
        Some(boundary_in_chunk.min(valid_len) as u32)
    } else {
        // Update bytes processed
        stream.processed_bytes = new_processed;
        None
    }
}