quoter/src/handlers/proxy.rs

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

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

/// Обработчик для скачивания файла и генерации миниатюры, если она недоступна.
pub async fn proxy_handler(
    _req: HttpRequest,
    requested_res: web::Path<String>,
    state: web::Data<AppState>,
) -> Result<HttpResponse, actix_web::Error> {
    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"))
        };

        return match state.get_path(&filekey).await {
            Ok(Some(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) => serve_file(thumb_filename, &state).await,
                                    Ok(false) => {
                                        if let Ok(filedata) = load_file_from_s3(
                                            &state.storj_client, &state.bucket, &stored_path).await {
                                                thumbdata_save(&filedata, &state, &base_filename, content_type).await;
                                                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) => {
                            let _ = upload_to_s3(&state.storj_client, &state.bucket, &filekey, filedata.clone(), content_type).await;
                            thumbdata_save(&filedata, &state, &base_filename, content_type).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: &[u8], state: &AppState, original_filename: &str, content_type: &str) {
    if content_type.starts_with("image") {
        let ext = original_filename.split('.').last().unwrap();
        let img = image::load_from_memory(&original_data).unwrap();
        
        if let Ok(thumbnails_bytes) = generate_thumbnails(&img).await {
            for (thumb_width, thumbnail) in thumbnails_bytes {
                let thumb_filename = &format!("{}_{}.{}", original_filename, thumb_width, ext);
                let thumbnail_bytes = thumbnail.clone();
                // Загружаем миниатюру в S3
                let _ = upload_to_s3(
                    &state.storj_client,
                    &state.bucket,
                    thumb_filename,
                    thumbnail_bytes,
                    content_type,
                )
                .await;
            }
        }
    }
}