export.rs

use crate::editor_window::WindowEditorInstance;
use crate::{FramesRendered, get_video_metadata};
use cap_export::ExporterBase;
use cap_project::{RecordingMeta, XY};
use cap_rendering::{
    FrameRenderer, ProjectRecordingsMeta, ProjectUniforms, RenderSegment, RenderVideoConstants,
    RendererLayers,
};
use image::codecs::jpeg::JpegEncoder;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::{path::PathBuf, sync::Arc};
use tracing::{info, instrument};

#[derive(Deserialize, Clone, Copy, Debug, Type)]
#[serde(tag = "format")]
pub enum ExportSettings {
    Mp4(cap_export::mp4::Mp4ExportSettings),
    Gif(cap_export::gif::GifExportSettings),
}

impl ExportSettings {
    fn fps(&self) -> u32 {
        match self {
            ExportSettings::Mp4(settings) => settings.fps,
            ExportSettings::Gif(settings) => settings.fps,
        }
    }
}

#[tauri::command]
#[specta::specta]
#[instrument(skip(progress))]
pub async fn export_video(
    project_path: PathBuf,
    progress: tauri::ipc::Channel<FramesRendered>,
    settings: ExportSettings,
) -> Result<PathBuf, String> {
    let exporter_base = ExporterBase::builder(project_path)
        .build()
        .await
        .map_err(|e| {
            sentry::capture_message(&e.to_string(), sentry::Level::Error);
            e.to_string()
        })?;

    let total_frames = exporter_base.total_frames(settings.fps());

    let _ = progress.send(FramesRendered {
        rendered_count: 0,
        total_frames,
    });

    let output_path = match settings {
        ExportSettings::Mp4(settings) => {
            settings
                .export(exporter_base, move |frame_index| {
                    // Ensure progress never exceeds total frames
                    progress
                        .send(FramesRendered {
                            rendered_count: (frame_index + 1).min(total_frames),
                            total_frames,
                        })
                        .is_ok()
                })
                .await
        }
        ExportSettings::Gif(settings) => {
            settings
                .export(exporter_base, move |frame_index| {
                    // Ensure progress never exceeds total frames
                    progress
                        .send(FramesRendered {
                            rendered_count: (frame_index + 1).min(total_frames),
                            total_frames,
                        })
                        .is_ok()
                })
                .await
        }
    }
    .map_err(|e| {
        sentry::capture_message(&e.to_string(), sentry::Level::Error);
        e.to_string()
    })?;

    info!("Exported to {} completed", output_path.display());

    Ok(output_path)
}

#[derive(Debug, serde::Serialize, specta::Type)]
pub struct ExportEstimates {
    pub duration_seconds: f64,
    pub estimated_time_seconds: f64,
    pub estimated_size_mb: f64,
}

#[tauri::command]
#[specta::specta]
#[instrument]
pub async fn get_export_estimates(
    path: PathBuf,
    settings: ExportSettings,
) -> Result<ExportEstimates, String> {
    let metadata = get_video_metadata(path.clone()).await?;

    let meta = RecordingMeta::load_for_project(&path).map_err(|e| e.to_string())?;
    let project_config = meta.project_config();
    let duration_seconds = if let Some(timeline) = &project_config.timeline {
        timeline.segments.iter().map(|s| s.duration()).sum()
    } else {
        metadata.duration
    };

    let (resolution, fps) = match &settings {
        ExportSettings::Mp4(s) => (s.resolution_base, s.fps),
        ExportSettings::Gif(s) => (s.resolution_base, s.fps),
    };

    let (width, height) = (resolution.x, resolution.y);
    let total_pixels = (width * height) as f64;
    let fps_f64 = fps as f64;
    let total_frames = (duration_seconds * fps_f64).ceil();

    let (estimated_size_mb, time_factor) = match &settings {
        ExportSettings::Mp4(mp4_settings) => {
            let bits_per_pixel = mp4_settings.compression.bits_per_pixel() as f64;
            let video_bitrate = total_pixels * bits_per_pixel * fps_f64;
            let audio_bitrate = 192_000.0;
            let total_bitrate = video_bitrate + audio_bitrate;
            let size_mb = (total_bitrate * duration_seconds) / (8.0 * 1024.0 * 1024.0);

            let base_time_factor = match (width, height) {
                (w, h) if w <= 1280 && h <= 720 => 0.35,
                (w, h) if w <= 1920 && h <= 1080 => 0.50,
                (w, h) if w <= 2560 && h <= 1440 => 0.65,
                _ => 0.80,
            };

            let compression_factor = match mp4_settings.compression {
                cap_export::mp4::ExportCompression::Minimal => 1.0,
                cap_export::mp4::ExportCompression::Social => 1.1,
                cap_export::mp4::ExportCompression::Web => 1.15,
                cap_export::mp4::ExportCompression::Potato => 1.2,
            };

            (size_mb, base_time_factor * compression_factor)
        }
        ExportSettings::Gif(_) => {
            let bytes_per_frame = total_pixels * 0.5;
            let size_mb = (bytes_per_frame * total_frames) / (1024.0 * 1024.0);

            let base_time_factor = match (width, height) {
                (w, h) if w <= 1280 && h <= 720 => 0.8,
                (w, h) if w <= 1920 && h <= 1080 => 1.2,
                _ => 1.5,
            };

            (size_mb, base_time_factor)
        }
    };

    let fps_factor = fps_f64 / 30.0;
    let estimated_time_seconds = duration_seconds * time_factor * fps_factor;

    Ok(ExportEstimates {
        duration_seconds,
        estimated_time_seconds,
        estimated_size_mb,
    })
}

#[derive(Debug, Deserialize, Type)]
pub struct ExportPreviewSettings {
    pub fps: u32,
    pub resolution_base: XY<u32>,
    pub compression_bpp: f32,
}

#[derive(Debug, Serialize, Type)]
pub struct ExportPreviewResult {
    pub jpeg_base64: String,
    pub estimated_size_mb: f64,
    pub actual_width: u32,
    pub actual_height: u32,
    pub frame_render_time_ms: f64,
    pub total_frames: u32,
}

fn bpp_to_jpeg_quality(bpp: f32) -> u8 {
    ((bpp - 0.04) / (0.3 - 0.04) * (95.0 - 40.0) + 40.0).clamp(40.0, 95.0) as u8
}

#[tauri::command]
#[specta::specta]
#[instrument(skip_all)]
pub async fn generate_export_preview(
    project_path: PathBuf,
    frame_time: f64,
    settings: ExportPreviewSettings,
) -> Result<ExportPreviewResult, String> {
    use base64::{Engine, engine::general_purpose::STANDARD};
    use cap_editor::create_segments;
    use std::time::Instant;

    let recording_meta = RecordingMeta::load_for_project(&project_path)
        .map_err(|e| format!("Failed to load recording meta: {e}"))?;

    let cap_project::RecordingMetaInner::Studio(studio_meta) = &recording_meta.inner else {
        return Err("Cannot preview non-studio recordings".to_string());
    };

    let project_config = recording_meta.project_config();

    let recordings = Arc::new(
        ProjectRecordingsMeta::new(&recording_meta.project_path, studio_meta)
            .map_err(|e| format!("Failed to load recordings: {e}"))?,
    );

    let render_constants = Arc::new(
        RenderVideoConstants::new(
            &recordings.segments,
            recording_meta.clone(),
            studio_meta.clone(),
        )
        .await
        .map_err(|e| format!("Failed to create render constants: {e}"))?,
    );

    let segments = create_segments(&recording_meta, studio_meta)
        .await
        .map_err(|e| format!("Failed to create segments: {e}"))?;

    let render_segments: Vec<RenderSegment> = segments
        .iter()
        .map(|s| RenderSegment {
            cursor: s.cursor.clone(),
            decoders: s.decoders.clone(),
        })
        .collect();

    let Some((segment_time, segment)) = project_config.get_segment_time(frame_time) else {
        return Err("Frame time is outside video duration".to_string());
    };

    let render_segment = &render_segments[segment.recording_clip as usize];
    let clip_config = project_config
        .clips
        .iter()
        .find(|v| v.index == segment.recording_clip);

    let render_start = Instant::now();

    let segment_frames = render_segment
        .decoders
        .get_frames(
            segment_time as f32,
            !project_config.camera.hide,
            clip_config.map(|v| v.offsets).unwrap_or_default(),
        )
        .await
        .ok_or_else(|| "Failed to decode frame".to_string())?;

    let frame_number = (frame_time * settings.fps as f64).floor() as u32;

    let uniforms = ProjectUniforms::new(
        &render_constants,
        &project_config,
        frame_number,
        settings.fps,
        settings.resolution_base,
        &render_segment.cursor,
        &segment_frames,
    );

    let mut frame_renderer = FrameRenderer::new(&render_constants);
    let mut layers = RendererLayers::new_with_options(
        &render_constants.device,
        &render_constants.queue,
        render_constants.is_software_adapter,
    );

    let frame = frame_renderer
        .render(
            segment_frames,
            uniforms,
            &render_segment.cursor,
            &mut layers,
        )
        .await
        .map_err(|e| format!("Failed to render frame: {e}"))?;

    let frame_render_time_ms = render_start.elapsed().as_secs_f64() * 1000.0;

    let width = frame.width;
    let height = frame.height;

    let rgb_data: Vec<u8> = frame
        .data
        .chunks(frame.padded_bytes_per_row as usize)
        .flat_map(|row| {
            row[0..(frame.width * 4) as usize]
                .chunks(4)
                .flat_map(|chunk| [chunk[0], chunk[1], chunk[2]])
        })
        .collect();

    let jpeg_quality = bpp_to_jpeg_quality(settings.compression_bpp);
    let mut jpeg_buffer = Vec::new();
    {
        let mut encoder = JpegEncoder::new_with_quality(&mut jpeg_buffer, jpeg_quality);
        encoder
            .encode(&rgb_data, width, height, image::ExtendedColorType::Rgb8)
            .map_err(|e| format!("Failed to encode JPEG: {e}"))?;
    }

    let jpeg_base64 = STANDARD.encode(&jpeg_buffer);

    let total_pixels = (settings.resolution_base.x * settings.resolution_base.y) as f64;
    let fps_f64 = settings.fps as f64;

    let metadata = get_video_metadata(project_path.clone()).await?;
    let duration_seconds = if let Some(timeline) = &project_config.timeline {
        timeline.segments.iter().map(|s| s.duration()).sum()
    } else {
        metadata.duration
    };
    let total_frames = (duration_seconds * fps_f64).ceil() as u32;

    let video_bitrate = total_pixels * settings.compression_bpp as f64 * fps_f64;
    let audio_bitrate = 192_000.0;
    let total_bitrate = video_bitrate + audio_bitrate;
    let estimated_size_mb = (total_bitrate * duration_seconds) / (8.0 * 1024.0 * 1024.0);

    Ok(ExportPreviewResult {
        jpeg_base64,
        estimated_size_mb,
        actual_width: width,
        actual_height: height,
        frame_render_time_ms,
        total_frames,
    })
}

#[tauri::command]
#[specta::specta]
#[instrument(skip_all)]
pub async fn generate_export_preview_fast(
    editor: WindowEditorInstance,
    frame_time: f64,
    settings: ExportPreviewSettings,
) -> Result<ExportPreviewResult, String> {
    use base64::{Engine, engine::general_purpose::STANDARD};
    use std::time::Instant;

    let project_config = editor.project_config.1.borrow().clone();

    let Some((segment_time, segment)) = project_config.get_segment_time(frame_time) else {
        return Err("Frame time is outside video duration".to_string());
    };

    let segment_media = &editor.segment_medias[segment.recording_clip as usize];
    let clip_config = project_config
        .clips
        .iter()
        .find(|v| v.index == segment.recording_clip);

    let render_start = Instant::now();

    let segment_frames = segment_media
        .decoders
        .get_frames(
            segment_time as f32,
            !project_config.camera.hide,
            clip_config.map(|v| v.offsets).unwrap_or_default(),
        )
        .await
        .ok_or_else(|| "Failed to decode frame".to_string())?;

    let frame_number = (frame_time * settings.fps as f64).floor() as u32;

    let uniforms = ProjectUniforms::new(
        &editor.render_constants,
        &project_config,
        frame_number,
        settings.fps,
        settings.resolution_base,
        &segment_media.cursor,
        &segment_frames,
    );

    let mut frame_renderer = FrameRenderer::new(&editor.render_constants);
    let mut layers = RendererLayers::new_with_options(
        &editor.render_constants.device,
        &editor.render_constants.queue,
        editor.render_constants.is_software_adapter,
    );

    let frame = frame_renderer
        .render(segment_frames, uniforms, &segment_media.cursor, &mut layers)
        .await
        .map_err(|e| format!("Failed to render frame: {e}"))?;

    let frame_render_time_ms = render_start.elapsed().as_secs_f64() * 1000.0;

    let width = frame.width;
    let height = frame.height;

    let rgb_data: Vec<u8> = frame
        .data
        .chunks(frame.padded_bytes_per_row as usize)
        .flat_map(|row| {
            row[0..(frame.width * 4) as usize]
                .chunks(4)
                .flat_map(|chunk| [chunk[0], chunk[1], chunk[2]])
        })
        .collect();

    let jpeg_quality = bpp_to_jpeg_quality(settings.compression_bpp);
    let mut jpeg_buffer = Vec::new();
    {
        let mut encoder = JpegEncoder::new_with_quality(&mut jpeg_buffer, jpeg_quality);
        encoder
            .encode(&rgb_data, width, height, image::ExtendedColorType::Rgb8)
            .map_err(|e| format!("Failed to encode JPEG: {e}"))?;
    }

    let jpeg_base64 = STANDARD.encode(&jpeg_buffer);

    let total_pixels = (settings.resolution_base.x * settings.resolution_base.y) as f64;
    let fps_f64 = settings.fps as f64;

    let duration_seconds = editor.recordings.duration();
    let total_frames = (duration_seconds * fps_f64).ceil() as u32;

    let video_bitrate = total_pixels * settings.compression_bpp as f64 * fps_f64;
    let audio_bitrate = 192_000.0;
    let total_bitrate = video_bitrate + audio_bitrate;
    let estimated_size_mb = (total_bitrate * duration_seconds) / (8.0 * 1024.0 * 1024.0);

    Ok(ExportPreviewResult {
        jpeg_base64,
        estimated_size_mb,
        actual_width: width,
        actual_height: height,
        frame_render_time_ms,
        total_frames,
    })
}