macltok

use std::time::Duration;

use matrix_sdk::{

    attachment::{

        AttachmentConfig, AttachmentInfo, BaseAudioInfo, BaseFileInfo, BaseImageInfo,

        BaseVideoInfo, Thumbnail,

    },

    ruma::events::room::message::TextMessageEventContent,

};

use crate::{AttachmentUpload, Error, ErrorKind, UploadDetails};

pub(crate) fn prepare_upload(

    mut upload: AttachmentUpload,

    max_media_bytes: usize,

) -> Result<(AttachmentUpload, mime::Mime, AttachmentConfig), Error> {

    if upload.bytes.len() > max_media_bytes {

        return Err(Error::new(

            ErrorKind::MediaTooLarge,

            "attachment exceeds the configured byte limit",

        ));

    }

    let mimetype: mime::Mime = upload

        .mimetype

        .parse()

        .map_err(|_| Error::new(ErrorKind::Invalid, "media MIME type is invalid"))?;

    let size = ruma::UInt::try_from(upload.bytes.len()).map_err(|_| {

        Error::new(

            ErrorKind::MediaTooLarge,

            "attachment size is not representable",

        )

    })?;

    let info = match upload.details.as_ref() {

        Some(UploadDetails::Image {

            width,

            height,

            blurhash,

        }) if mimetype.type_() == mime::IMAGE => AttachmentInfo::Image(BaseImageInfo {

            width: width.map(Into::into),

            height: height.map(Into::into),

            size: Some(size),

            blurhash: blurhash.clone(),

            ..Default::default()

        }),

        Some(UploadDetails::Video {

            width,

            height,

            duration_ms,

            blurhash,

        }) if mimetype.type_() == mime::VIDEO => AttachmentInfo::Video(BaseVideoInfo {

            width: width.map(Into::into),

            height: height.map(Into::into),

            duration: duration_ms.map(Duration::from_millis),

            size: Some(size),

            blurhash: blurhash.clone(),

        }),

        Some(UploadDetails::Audio { duration_ms }) if mimetype.type_() == mime::AUDIO => {

            AttachmentInfo::Audio(BaseAudioInfo {

                duration: duration_ms.map(Duration::from_millis),

                size: Some(size),

                ..Default::default()

            })

        }

        Some(UploadDetails::Voice {

            duration_ms,

            waveform,

        }) if mimetype.type_() == mime::AUDIO => {

            if waveform.iter().any(|sample| *sample > 1024) {

                return Err(Error::new(

                    ErrorKind::Invalid,

                    "voice waveform samples must be at most 1024",

                ));

            }

            AttachmentInfo::Voice(BaseAudioInfo {

                duration: Some(Duration::from_millis(*duration_ms)),

                size: Some(size),

                waveform: Some(

                    waveform

                        .iter()

                        .map(|sample| f32::from(*sample) / 1024.0)

                        .collect(),

                ),

            })

        }

        Some(UploadDetails::File)

            if mimetype.type_() != mime::IMAGE

                && mimetype.type_() != mime::VIDEO

                && mimetype.type_() != mime::AUDIO =>

        {

            AttachmentInfo::File(BaseFileInfo { size: Some(size) })

        }

        None => match mimetype.type_() {

            mime::IMAGE => AttachmentInfo::Image(BaseImageInfo {

                size: Some(size),

                ..Default::default()

            }),

            mime::VIDEO => AttachmentInfo::Video(BaseVideoInfo {

                size: Some(size),

                ..Default::default()

            }),

            mime::AUDIO => AttachmentInfo::Audio(BaseAudioInfo {

                size: Some(size),

                ..Default::default()

            }),

            _ => AttachmentInfo::File(BaseFileInfo { size: Some(size) }),

        },

        _ => {

            return Err(Error::new(

                ErrorKind::Invalid,

                "attachment metadata does not match its MIME type",

            ));

        }

    };

    if upload.thumbnail.is_some() && mimetype.type_() == mime::AUDIO {

        return Err(Error::new(

            ErrorKind::Invalid,

            "audio attachments do not support thumbnails",

        ));

    }

    let thumbnail = upload

        .thumbnail

        .take()

        .map(|thumbnail| {

            if thumbnail.bytes.len() > max_media_bytes

                || thumbnail.width == 0

                || thumbnail.height == 0

            {

                return Err(Error::new(

                    if thumbnail.bytes.len() > max_media_bytes {

                        ErrorKind::MediaTooLarge

                    } else {

                        ErrorKind::Invalid

                    },

                    "thumbnail size or dimensions are invalid",

                ));

            }

            let content_type: mime::Mime = thumbnail

                .mimetype

                .parse()

                .map_err(|_| Error::new(ErrorKind::Invalid, "thumbnail MIME type is invalid"))?;

            if content_type.type_() != mime::IMAGE {

                return Err(Error::new(

                    ErrorKind::Invalid,

                    "thumbnail MIME type must be an image",

                ));

            }

            let size = ruma::UInt::try_from(thumbnail.bytes.len()).map_err(|_| {

                Error::new(

                    ErrorKind::MediaTooLarge,

                    "thumbnail size is not representable",

                )

            })?;

            Ok(Thumbnail {

                data: thumbnail.bytes,

                content_type,

                width: thumbnail.width.into(),

                height: thumbnail.height.into(),

                size,

            })

        })

        .transpose()?;

    let config = AttachmentConfig::new()

        .info(info)

        .thumbnail(thumbnail)

        .caption(upload.caption.clone().map(TextMessageEventContent::plain));

    Ok((upload, mimetype, config))

}