quoter/src/handlers/proxy.rs

use actix_web::error::ErrorNotFound;
use actix_web::{error::ErrorInternalServerError, web, HttpRequest, HttpResponse, Result};
use log::{error, 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, parse_file_path, thumbdata_save};

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

    // парсим GET запрос
    let (base_filename, requested_width, extension) = parse_file_path(&normalized_path);
    warn!("detected file extension: {}", extension);
    warn!("base_filename: {}", base_filename);
    warn!("requested width: {}", requested_width);
    let ext = extension.as_str().to_lowercase();
    warn!("normalized to lowercase: {}", ext);
    let filekey = format!("{}.{}", base_filename, &ext);
    warn!("filekey: {}", filekey);
    let content_type = match ext.as_str() {
        "jpg" | "jpeg" => "image/jpeg",
        "png" => "image/png",
        "webp" => "image/webp",
        "gif" => "image/gif",
        "jfif" => "image/jpeg",
        "mp3" => "audio/mpeg",
        "wav" => "audio/x-wav",
        "ogg" => "audio/ogg",
        "aac" => "audio/aac",
        "m4a" => "audio/m4a",
        "flac" => "audio/flac",
        _ => {
            error!("unsupported file format");
            return Err(ErrorInternalServerError("unsupported file format"));
        },
    };

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

    let shout_id = match req.query_string().contains("s=") {
        true => req.query_string().split("s=").collect::<Vec<&str>>().pop().unwrap_or(""),
        false => ""
    };

    return match state.get_path(&filekey).await {
        Ok(Some(stored_path)) => {
            warn!("Found stored path in DB: {}", stored_path);
            // Проверяем, существует ли файл в Storj
            warn!("Checking if file exists in Storj: {}", stored_path);
            if check_file_exists(&state.storj_client, &state.bucket, &stored_path).await? {
                warn!("File exists in Storj: {}", stored_path);
                if content_type.starts_with("image") {
                    warn!("Processing image file with width: {}", requested_width);
                    if requested_width == 0 {
                        warn!("Serving original file without resizing");
                        return serve_file(&stored_path, &state, shout_id).await;
                    } else {
                        let closest: u32 = find_closest_width(requested_width as u32);
                        warn!("Calculated closest width: {} for requested: {}", closest, requested_width);
                        let thumb_filename = &format!("{}_{}.{}", base_filename, closest, ext);
                        warn!("Generated thumbnail filename: {}", thumb_filename);

                        // Проверяем, существует ли уже миниатюра в Storj
                        match check_file_exists(&state.storj_client, &state.bucket, thumb_filename).await {
                            Ok(true) => {
                                warn!("serve existed thumb file: {}", thumb_filename);
                                return serve_file(thumb_filename, &state, shout_id).await;
                            },
                            Ok(false) => {
                                // Миниатюра не существует, возвращаем оригинал и запускаем генерацию миниатюры
                                let original_file = serve_file(&stored_path, &state, shout_id).await?;
                                
                                // Запускаем асинхронную задачу для генерации миниатюры
                                let state_clone = state.clone();
                                let stored_path_clone = stored_path.clone();
                                let filekey_clone = filekey.clone();
                                let content_type_clone = content_type.to_string();

                                actix_web::rt::spawn(async move {
                                    if let Ok(filedata) = load_file_from_s3(&state_clone.storj_client, &state_clone.bucket, &stored_path_clone).await {
                                        warn!("generate new thumb files: {}", stored_path_clone);
                                        if let Err(e) = thumbdata_save(filedata, &state_clone, &filekey_clone, content_type_clone).await {
                                            error!("Failed to generate thumbnail: {}", e);
                                        }
                                    }
                                });

                                return Ok(original_file);
                            }
                            Err(e) => {
                                error!("ошибка при проверке существования миниатюры: {}", e);
                                return Err(ErrorInternalServerError("failed to load thumbnail"));
                            }
                        }
                    }
                }
                warn!("File is not an image, proceeding with normal serving");
            } else {
                warn!("File does not exist in Storj: {}", stored_path);
            }

            // 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 {
                        error!("cannot upload to storj: {}", e);
                    } else {
                        warn!("file {} uploaded to storj", filekey);
                        state.set_path(&filekey, &filekey).await;
                    }
                    let _ = thumbdata_save(filedata.clone(), &state, &filekey, content_type.to_string())
                        .await;

                    Ok(HttpResponse::Ok().content_type(content_type).body(filedata))
                }
                Err(err) => {
                    error!("cannot download {} from aws: {}", stored_path, err);
                    Err(ErrorInternalServerError(err))
                },
            };
        }
        Ok(None) => {
            warn!("No stored path found in DB for: {}", filekey);
            let ct_parts = content_type.split("/").collect::<Vec<&str>>();
            let filepath = format!("production/{}/{}.{}", ct_parts[0], base_filename, extension);
            warn!("Generated filepath for lookup: {}", filepath);

            let exists_in_storj = check_file_exists(&state.storj_client, &state.bucket, &filepath).await?;
            warn!("Checking existence in Storj: {}", exists_in_storj);

            if exists_in_storj {
                warn!("file {} exists in storj, try to generate thumbnails", filepath);

                match load_file_from_s3(&state.aws_client, &state.bucket, &filepath).await {
                    Ok(filedata) => {
                        let _ = thumbdata_save(filedata.clone(), &state, &filekey, content_type.to_string()).await;
                    }
                    Err(e) => {
                        error!("cannot download {} from storj: {}", filekey, e);
                        return Err(ErrorInternalServerError(e));
                    }
                }
            } else {
                warn!("file {} does not exist in storj", filepath);
            }

            let exists_in_aws = check_file_exists(&state.aws_client, &state.bucket, &filepath).await?;
            warn!("Checking existence in AWS: {}", exists_in_aws);

            if exists_in_aws {
                warn!("File found in AWS, attempting to download: {}", filepath);
                match load_file_from_s3(&state.aws_client, &state.bucket, &filepath).await {
                    Ok(filedata) => {
                        warn!("Successfully downloaded file from AWS, size: {} bytes", filedata.len());
                        let _ = thumbdata_save(filedata.clone(), &state, &filekey, content_type.to_string())
                            .await;
                        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);
                            state.set_path(&filekey, &filepath).await;
                        }
                        Ok(HttpResponse::Ok().content_type(content_type).body(filedata))
                    },
                    Err(e) => {
                        error!("Failed to download from AWS: {} - Error: {}", filepath, e);
                        Err(ErrorInternalServerError(e))
                    },
                }
            } else {
                error!("File not found in either Storj or AWS: {}", filepath);
                Err(ErrorNotFound("file does not exist"))
            }
        },
        Err(e) => {
            error!("Database error while getting path: {}", e);
            Err(ErrorInternalServerError(e))
        }
    }
}