quoter/src/handlers/proxy.rs

use actix_web::{error::ErrorInternalServerError, web, HttpRequest, HttpResponse, Result};
use log::warn;

use crate::app_state::AppState;
use crate::handlers::serve_file::serve_file;
use crate::s3_utils::{check_file_exists, load_file_from_s3, upload_to_s3};
use crate::thumbnail::{find_closest_width, generate_thumbnails, parse_image_request};

/// Обработчик для скачивания файла и генерации миниатюры, если она недоступна.
pub async fn proxy_handler(
    _req: HttpRequest,
    requested_res: web::Path<String>,
    state: web::Data<AppState>,
) -> Result<HttpResponse, actix_web::Error> {
    warn!("\t>>>\tGET {}", requested_res);
    let normalized_path = match requested_res.ends_with("/webp") {
        true => requested_res.replace("/webp", ""),
        false => requested_res.to_string(),
    };

    // парсим GET запрос
    if let Some((base_filename, requested_width, extension)) = parse_image_request(&normalized_path)
    {
        let filekey = format!("{}.{}", base_filename, extension);
        let content_type = match extension.as_str() {
            "jpg" | "jpeg" => "image/jpeg",
            "png" => "image/png",
            "webp" => "image/webp",
            "gif" => "image/gif",
            "mp3" => "audio/mpeg",
            "wav" => "audio/x-wav",
            "ogg" => "audio/ogg",
            "aac" => "audio/aac",
            "m4a" => "audio/m4a",
            "flac" => "audio/flac",
            _ => return Err(ErrorInternalServerError("unsupported file format")),
        };

        warn!("content_type: {}", content_type);

        return match state.get_path(&filekey).await {
            Ok(Some(stored_path)) => {
                warn!("stored_path: {}", stored_path);
                // we have stored file path in storj
                if check_file_exists(&state.storj_client, &state.bucket, &stored_path).await? {
                    if content_type.starts_with("image") {
                        return match requested_width == 0 {
                            true => serve_file(&stored_path, &state).await,
                            false => {
                                // find closest thumb width
                                let closest: u32 = find_closest_width(requested_width as u32);
                                let thumb_filename =
                                    &format!("{}_{}.{}", base_filename, closest, extension);

                                return match check_file_exists(
                                    &state.storj_client,
                                    &state.bucket,
                                    thumb_filename,
                                )
                                .await
                                {
                                    Ok(true) => {
                                        warn!("serve existed thumb file: {}", thumb_filename);
                                        serve_file(thumb_filename, &state).await
                                    },
                                    Ok(false) => {
                                        warn!("generate new thumb files: {}", stored_path);
                                        if let Ok(filedata) = load_file_from_s3(
                                            &state.storj_client,
                                            &state.bucket,
                                            &stored_path,
                                        )
                                        .await
                                        {
                                            warn!("original file loaded: {} bytes", filedata.len());
                                            warn!("generate new thumb files");
                                            thumbdata_save(
                                                filedata.clone(),
                                                &state,
                                                &filekey,
                                                content_type.to_string(),
                                            )
                                            .await;
                                            warn!("serve new thumb file: {}", thumb_filename);
                                            serve_file(thumb_filename, &state).await
                                        } else {
                                            Err(ErrorInternalServerError(
                                                "cannot generate thumbnail",
                                            ))
                                        }
                                    }
                                    Err(_) => {
                                        Err(ErrorInternalServerError("failed to load thumbnail"))
                                    }
                                };
                            }
                        };
                    }
                    // not image passing thumb generation
                }

                // we need to download what stored_path keeping in aws
                return match load_file_from_s3(&state.aws_client, &state.bucket, &stored_path).await
                {
                    Ok(filedata) => {
                        warn!("download stored_path from aws: {:?}", stored_path);
                        if let Err(e) = upload_to_s3(
                            &state.storj_client,
                            &state.bucket,
                            &filekey,
                            filedata.clone(),
                            content_type,
                        )
                        .await {
                            warn!("cannot upload to storj: {}", e);
                        } else {
                            warn!("file {} uploaded to storj", filekey);
                        }
                        thumbdata_save(filedata.clone(), &state, &filekey, content_type.to_string())
                            .await;

                        Ok(HttpResponse::Ok().content_type(content_type).body(filedata))
                    }
                    Err(err) => Err(ErrorInternalServerError(err)),
                };
            }
            Ok(None) => Err(ErrorInternalServerError(
                "requested file path was not found",
            )),
            Err(e) => Err(ErrorInternalServerError(e)),
        };
    }

    Err(ErrorInternalServerError("invalid file key"))
}
async fn thumbdata_save(
    original_data: Vec<u8>,
    state: &AppState,
    original_filename: &str,
    content_type: String,
) {
    let state = state.clone();
    if content_type.starts_with("image") {
        warn!("original file name: {}", original_filename);
        let filename = original_filename.to_string();
        let ext = match filename.split(".").last() {
            Some(ext) => ext.to_string(),
            None => "".to_string(),
        };

        warn!("file extension: {}", ext);

        let img = match image::load_from_memory(&original_data) {
            Ok(img) => img,
            Err(e) => {
                warn!("cannot load image from memory: {}", e);
                return;
            }
        };

        actix::spawn(async move {
            match generate_thumbnails(&img).await {
                Ok(thumbnails_bytes) => {
                    for (thumb_width, thumbnail) in thumbnails_bytes {
                        let thumb_filename = format!("{}_{}.{}", filename, thumb_width, ext);
                        // Загружаем миниатюру в S3
                        if let Err(e) = upload_to_s3(
                            &state.storj_client,
                            &state.bucket,
                            &thumb_filename,
                            thumbnail,
                            &content_type,
                        )
                        .await
                        {
                            warn!("cannot load thumb {}: {}", thumb_filename, e);
                        } else {
                            warn!("thumb {} uploaded to storj", thumb_filename);
                        }
                    }
                }
                Err(e) => {
                    warn!("cannot generate thumbnails for {}: {}", filename, e);
                }
            }
        });
    }
}