Pkg.add("FFMPEG")
Pkg.add("ProgressMeter")
Pkg.add("ColorTypes")
Pkg.add("FixedPointNumbers")

using VideoIO, Images, ImageFiltering, FileIO, ColorTypes, FixedPointNumbers
using ProgressMeter
import ColorTypes: red, green, blue

function prepare_frame(frame)
    if typeof(frame) <: PermutedDimsArray
        return collect(frame)
    else
        return frame
    end
end
function to_video_format(frame::AbstractArray{<:AbstractRGB})
    return RGB{N0f8}.(frame)
end
function to_video_format(frame::AbstractArray{<:Gray})
    return Gray{N0f8}.(frame)
end

function process_video_with_effect(
    input_path::String, 
    output_path::String;
    effect_function::Function,
    max_frames::Int=0,
    effect_params...
)
    video = VideoIO.openvideo(input_path)
    frame_count = counttotalframes(video)
    max_frames > 0 && (frame_count = min(frame_count, max_frames))
    first_frame = read(video)
    seek(video, 1)
    h, w = size(first_frame)
    fps = VideoIO.framerate(video)
    println("Обработка: ", input_path)
    println("Размер: ", w, "x", h, ", FPS: ", fps, ", Кадров: ", frame_count)
    first_processed = effect_function(prepare_frame(first_frame); effect_params...)
    first_processed_video = to_video_format(first_processed)
    
    open_video_out(output_path, first_processed_video, framerate=fps) do writer
        p = Progress(frame_count, 1, "Применение эффекта...")
        for i in 1:frame_count
            frame = read(video)
            processed_frame = effect_function(prepare_frame(frame); effect_params...)
            processed_frame_video = to_video_format(processed_frame)
            write(writer, processed_frame_video)
            next!(p)
        end
    end
    
    close(video)
    println("\nВидео сохранено: ", output_path)
end

function simple_cartoon_effect(frame::AbstractArray{<:AbstractRGB}; edge_threshold=0.1)
    frame = prepare_frame(frame)
    gray = Gray.(frame)
    edges = imfilter(gray, Kernel.sobel()[1]).^2 + imfilter(gray, Kernel.sobel()[2]).^2
    edges = edges .> edge_threshold
    blurred = imfilter(frame, Kernel.gaussian(3))
    result = copy(blurred)
    result[edges] .= RGB{N0f8}(0,0,0)
    return result
end

function energy_effect(frame::AbstractArray{<:AbstractRGB}; sobel_x=nothing, sobel_y=nothing)
    frame = prepare_frame(frame)
    h, w = size(frame)
    gray_buffer = Matrix{Float32}(undef, h, w)
    energy_buffer = Matrix{Float32}(undef, h, w)
    
    if sobel_x === nothing
        sobel_x, sobel_y = Kernel.sobel()
    end
    
    for i in eachindex(frame)
        pixel = frame[i]
        gray_buffer[i] = 0.299f0 * red(pixel) + 0.587f0 * green(pixel) + 0.114f0 * blue(pixel)
    end
    
    gradient_x = imfilter(gray_buffer, sobel_x)
    gradient_y = imfilter(gray_buffer, sobel_y)
    
    for i in eachindex(energy_buffer)
        energy_buffer[i] = sqrt(gradient_x[i]^2 + gradient_y[i]^2)
    end
    
    energy_normalized = energy_buffer ./ maximum(energy_buffer)
    return Gray.(energy_normalized)
end

function sepia_effect(frame::AbstractArray{<:AbstractRGB})
    frame = prepare_frame(frame)
    result = similar(frame)
    for i in eachindex(frame)
        pixel = frame[i]
        r_val = red(pixel)
        g_val = green(pixel)
        b_val = blue(pixel)
        r = 0.393 * r_val + 0.769 * g_val + 0.189 * b_val
        g = 0.349 * r_val + 0.686 * g_val + 0.168 * b_val
        b = 0.272 * r_val + 0.534 * g_val + 0.131 * b_val
        result[i] = RGB{N0f8}(min(r,1.0), min(g,1.0), min(b,1.0))
    end
    return result
end

function blur_effect(frame::AbstractArray{<:AbstractRGB}; kernel_size=5)
    frame = prepare_frame(frame)
    blurred = imfilter(frame, Kernel.gaussian(kernel_size))
    return RGB{N0f8}.(blurred)
end

function sharpen_effect(frame::AbstractArray{<:AbstractRGB})
    frame = prepare_frame(frame)
    kernel = [-1 -1 -1; -1 9 -1; -1 -1 -1] / 1.0
    sharpened = imfilter(frame, kernel)
    sharpened = clamp.(sharpened, 0.0, 1.0)
    return RGB{N0f8}.(sharpened)
end

function safe_cartoon_effect(frame::AbstractArray{<:AbstractRGB}; edge_threshold=0.1)
    frame = prepare_frame(frame)
    frame_rgb = RGB{N0f8}.(frame)
    gray = Gray.(frame_rgb)
    edges = imfilter(gray, Kernel.sobel()[1]).^2 + imfilter(gray, Kernel.sobel()[2]).^2
    edges = edges .> edge_threshold
    blurred = imfilter(frame_rgb, Kernel.gaussian(3))
    result = copy(blurred)
    result[edges] .= RGB{N0f8}(0,0,0)
    return result
end

process_video_with_effect("input.mp4", "energy_analysis.mp4",
    effect_function=energy_effect, max_frames=50)

process_video_with_effect("input.mp4", "cartoon_safe.mp4",
    effect_function=safe_cartoon_effect, edge_threshold=0.15, max_frames=50)

process_video_with_effect("input.mp4", "sepia.mp4",
    effect_function=sepia_effect, max_frames=50)

process_video_with_effect("input.mp4", "blur.mp4",
    effect_function=blur_effect, kernel_size=7, max_frames=50)

include("player.jl")
media_player(@__DIR__, mode="video")