fakejpeg 0.2.0

// SPDX-FileCopyrightText: Gergely Nagy
// SPDX-FileContributor: Gergely Nagy
//
// SPDX-License-Identifier: MIT

#![cfg(feature = "serde")]

use crate::{
    Template,
    template::{
        chunk::{Chunk, Marker},
        image_template::ImageTemplate,
    },
};

use serde::Deserialize;

#[doc(hidden)]
#[derive(Debug, Deserialize)]
pub struct Pickle {
    templates: Vec<PickleTemplate>,
}

#[derive(Debug, Deserialize)]
pub struct PickleTemplate(Vec<PickleChunk>);

#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub enum PickleChunk {
    Bytes(u16, bytes::Bytes),
    StartOfScan(u16, (bytes::Bytes, usize)),
}

impl From<PickleChunk> for Chunk {
    fn from(pickle_chunk: PickleChunk) -> Self {
        match pickle_chunk {
            PickleChunk::Bytes(marker, bytes) => {
                if marker == Marker::EOI {
                    Self::default()
                } else {
                    Self {
                        data: bytes.to_vec(),
                        size: bytes.len() + 4,
                        remaining: 0,
                    }
                }
            }
            PickleChunk::StartOfScan(_marker, (preamble, remaining)) => Self {
                data: preamble.to_vec(),
                size: preamble.len() + 4,
                remaining,
            },
        }
    }
}

impl From<PickleTemplate> for ImageTemplate {
    fn from(pickle_template: PickleTemplate) -> Self {
        let chunks: Vec<Chunk> = pickle_template.0.into_iter().map(Into::into).collect();
        let minimum_size = 4 + chunks
            .iter()
            .fold(0, |acc, chunk| acc + chunk.remaining + chunk.size);

        Self {
            chunks,
            minimum_size,
        }
    }
}

impl From<Pickle> for Template {
    fn from(pickle: Pickle) -> Self {
        Self {
            image_templates: pickle.templates.into_iter().map(Into::into).collect(),
            ..Default::default()
        }
    }
}