media.nu

export def "media help" [] {
  print ([
    "media manipulation and visualization tools: ffmpeg, sox, subsync and mpv required."
      "METHODS:"
      "- media video-info"
      "- media mpv-info"
      "- media sub-sync"
      "- media remove-noise"
      "- media remove-audio-noise"
      "- media screen-record"
      "- media remove-audio"
      "- media cut-video"
      "- media split-video"
      "- media cut-audio"
      "- media extract-audio"
      "- media merge-videos"
      "- media merge-videos-auto"
      "- media compress-video"
      "- media delete-non-compressed"
      "- media find"
      "- media myt"
      "- media delete-mps"
      "- media crop-video"
      "- media auto-remove-logo"
      "- media repeat"
      "- media add-audio"
      "- mpv (alias)"
      "- media to"
    ]
    | str join "\n"
    | nu-highlight
  ) 
}

#add audio track to video file
export def "media add-audio" [
  video_file: string      # input video file
  audio_file: string      # input audio file
  --volume-factor(-v): float = 0.5 # volume factor for background audio
  --output(-o): string     # optional output filename
  --notify(-n)             # notify to android via join/tasker
] {
  let v_info = media video-info $video_file
  let v_duration = $v_info.format.duration | into float
  let v_has_audio = $v_info.streams | where codec_type == "audio" | is-not-empty
  
  let a_duration = ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 $audio_file | str trim | into float

  let v_ext = $video_file | path parse | get extension
  let v_stem = $video_file | path parse | get stem
  let ofile = if ($output | is-empty) {
    $"($v_stem)_merged.($v_ext)"
  } else {
    $output
  }

  mut final_audio = $audio_file
  mut temp_files = []

  # Logic for duration adjustment
  if $a_duration < ($v_duration - 0.1) {
    # Case B: Looping audio
    let n_repeats = $v_duration / $a_duration | math ceil | into int
    let looped_audio = $"tmp_looped_($v_stem).($audio_file | path parse | get extension)"
    $temp_files = ($temp_files | append $looped_audio)
    
    media repeat $audio_file $n_repeats --output $looped_audio
    $final_audio = $looped_audio
    
    # Trim the looped audio to match video length
    let trimmed_audio = $"tmp_trimmed_($v_stem).($audio_file | path parse | get extension)"
    $temp_files = ($temp_files | append $trimmed_audio)
    media cut-audio $final_audio $trimmed_audio 0 ($v_duration | math round | into int)
    $final_audio = $trimmed_audio
  } else if $a_duration > ($v_duration + 0.1) {
    # Case A: Trimming longer audio
    let trimmed_audio = $"tmp_trimmed_($v_stem).($audio_file | path parse | get extension)"
    $temp_files = ($temp_files | append $trimmed_audio)
    media cut-audio $audio_file $trimmed_audio 0 ($v_duration | math round | into int)
    $final_audio = $trimmed_audio
  }

  print (echo-g $"Merging audio into video ($video_file)...")

  # Case C vs D: Mixing vs Simple Add
  let filter = if $v_has_audio {
    $"[1:a]volume=($volume_factor)[a1];[0:a][a1]amix=inputs=2:duration=first"
  } else {
    ""
  }

  # Final audio path for the try/catch blocks (must be immutable for capture)
  let final_audio_frozen = $final_audio
  let filter_frozen = $filter
  let ofile_frozen = $ofile

  try {
    print (echo-g "Trying with my-ffmpeg...")
    if $v_has_audio {
      my-ffmpeg -i $video_file -i $final_audio_frozen -filter_complex $filter_frozen -map 0:v -c:v copy -c:a aac -b:a 128k $ofile_frozen -y
    } else {
      my-ffmpeg -i $video_file -i $final_audio_frozen -map 0:v -map 1:a -c:v copy -c:a aac -b:a 128k $ofile_frozen -y
    }
  } catch {
    print (echo-y "my-ffmpeg failed, falling back to standard ffmpeg...")
    if $v_has_audio {
      ffmpeg -i $video_file -i $final_audio_frozen -filter_complex $filter_frozen -map 0:v -c:v copy -c:a aac -b:a 128k $ofile_frozen -y
    } else {
      ffmpeg -i $video_file -i $final_audio_frozen -map 0:v -map 1:a -c:v copy -c:a aac -b:a 128k $ofile_frozen -y
    }
  }

  # Cleanup temp files
  for f in $temp_files {
    if ($f | path exists) { rm $f }
  }

  if ($ofile | path exists) {
    print (echo-g $"SUCCESS: Audio merged. Output: ($ofile)")
    if $notify { "Audio merge finished!" | tasker send-notification }
  } else {
    return-error "FFmpeg failed to produce output file."
  }
}

#repeat audio file n times
export def "media repeat" [
  file: string          # audio file name
  n: int                # number of times to repeat
  --output(-o): string  # output file name
  --notify(-n)          # notify to android via join/tasker
] {
  let filename = $file | path parse | get stem
  let ext = $file | path parse | get extension
  let ofile = if ($output | is-empty) {
    $"($filename)_repeated_($n).($ext)"
  } else {
    $output
  }

  print (echo-g $"Repeating audio ($file) ($n) times...")
  
  # stream_loop uses 0 for infinite, -1 for no loop? 
  # Actually, -stream_loop N means loop N times. 0 means loop 0 times (play once). 1 means loop once (play twice).
  let loops = $n - 1
  
  try {
    print (echo-g "Trying with my-ffmpeg...")
    my-ffmpeg -stream_loop $loops -i $file -c copy $ofile -y
  } catch {
    print (echo-y "my-ffmpeg failed, falling back to standard ffmpeg...")
    ffmpeg -stream_loop $loops -i $file -c copy $ofile -y
  }

  if ($ofile | path exists) {
    print (echo-g $"SUCCESS: Audio repeated ($n) times. Output: ($ofile)")
    if $notify { "Audio repeat finished!" | tasker send-notification }
  } else {
    return-error "FFmpeg failed to produce output file."
  }
}

#cuda ffmpeg
export def --wrapped my-ffmpeg [...rest] {
  let ffmpeg = if (sys host | get name | str lowercase) == "windows" { "ffmpeg.exe" } else { ($env.HOME | path join "software" "nvidia" "ffmpeg" "ffmpeg") }
  ^$ffmpeg -hwaccel cuda ...$rest
}

#video info
export def "media video-info" [file?] {
  let video = if ($file | is-empty) {$in | get name} else {$file}
  ffprobe -v quiet -print_format json -show_format -show_streams $video | from json
}

#video info via mpv
export def "media mpv-info" [file?] {
  let video = if ($file | is-empty) {$in | get name} else {$file}
  ^mpv -vo null -ao null -frames 0 $video
}

#sync subtitles
#
#Examples
#sub-sync file.srt "-4"
#sub-sync file.srt "-4" --t1 00:02:33
#sub-sync file.srt "-4" --no_backup 1
export def "media sub-sync" [
  file:string      #subtitle file name to process
  d1:string        #delay at the beginning or at time specified by t1 (<0 adelantar, >0 retrasar)
  --t1:string      #time position of delay d1 (hh:mm:ss)
  --d2:string      #delay at the end or at time specified by t2
  --t2:string      #time position of delay d2 (hh:mm:ss)t
  --no_backup:int  #whether to not backup $file or yes (export default no:0, ie, it will backup)
] {
  if not ($env.PWD | path join $file | path exists) {
    return-error $"subtitle file ($file) doesn't exist in (pwd-short)"
  }

  if ($no_backup | is-empty) or $no_backup == 0 {
    cp $file $"($file).backup"
  }

  let t1 = get-input "@" $t1
  let d2 = get-input "" $d2
  let t2 = if ($d2 | is-empty) {""} else {get-input "@" $t2}
  
  bash -c $"subsync -e latin1 ($t1)($d1) ($t2)($d2) < \"($file)\" > output.srt; cp output.srt \"($file)\""

  rm output.srt | ignore
}

const formats = ["mp3", "wav"]
#remove audio noise 
export def "media remove-noise" [
  file                 #audio file name with extension
  start                #start (hh:mm:ss) of audio noise (no speaker)
  end                  #end (hh:mm:ss) of audio noise (no speaker)
  noiseLevel           #level reduction adjustment (0.2-0.3)
  output?              #output file name without extension, wav or mp3 produced
  --delete(-d) = true  #whether to delete existing tmp files or not
  --outExt(-E):string@$formats = "wav" #output format, mp3 or wav
  --notify(-n)         #notify to android via join/tasker
] {
  if $delete {
    try {
      ls ([$env.PWD tmp*] | path join) | rm-pipe
    }
  }

  let filename = $file | path parse | get stem
  let ext = $file | path parse | get extension

  if $ext not-like "wav" {
    print (echo-g "converting input file to wav format...")
    my-ffmpeg -loglevel 1 -i $file $"($filename).wav"
  }

  let output = if ($output | is-empty) {
      $"($filename)-clean.wav"
    } else {
      $"($output).wav"
    }
   

  print (echo-g "extracting noise segment...")
  my-ffmpeg -loglevel 1 -i $"($filename).wav" -acodec pcm_s16le -ar 128k -vn -ss $start -t $end $"tmpSeg($filename).wav"

  print (echo-g "creating noise profile...")
  sox $"tmpSeg($filename).wav" -n noiseprof $"tmp($filename).prof"

  print (echo-g "cleaning noise from audio file...")
  sox $"($filename).wav" $output noisered $"tmp($filename).prof" $noiseLevel

  if $outExt like "mp3" {
    print (echo-g "converting output file to mp3 format...")
    ffmpeg -loglevel 1 -i $output -acodec libmp3lame -ab 128k -vn $"($output | path parse | get stem).mp3"

    mv $output $"tmp($output)"
  }

  if $ext not-like "wav" {
    mv $"($filename).wav" $"tmp($filename).wav"
  }

  notify-send "noise removal done!"
  if $notify {"noise removal finished!" | tasker send-notification}
}

#remove audio noise from video
export def "media remove-audio-noise" [
  file            #video file name with extension
  start           #start (hh:mm:ss) of audio noise (no speaker)
  end             #end (hh:mm:ss) of audio noise (no speaker)
  noiseLevel      #level reduction adjustment (0.2-0.3)
  output?         #output file name with extension (same extension as $file)
  --merge = true  #whether to merge clean audio with video
  --notify(-n)    #notifua to android via join/tasker
] {
  try {
    ls ([$env.PWD tmp*] | path join) | rm-pipe
  }

  let filename = $file | path parse | get stem
  let ext = $file | path parse | get extension

  let output = if ($output | is-empty) {
      $"($filename)-clean.($ext)"
    } else {
      $output
    }
   

  let outputA = $"tmp($filename)-clean.wav"

  print (echo-g "extracting video...")
  my-ffmpeg -loglevel 1 -i $"($file)" -vcodec copy -an $"tmp($file)"

  print (echo-g "extracting audio...")
  my-ffmpeg -loglevel 1 -i $"($file)" -acodec pcm_s16le -ar 128k -vn $"tmp($filename).wav"

  media remove-noise $"tmp($filename).wav" $start $end $noiseLevel $outputA --delete false

  if $merge {
    print (echo-g "merging clean audio with video file...")
    my-ffmpeg -loglevel 1 -i $file -i $outputA -map 0:v -map 1:a -c:v copy -c:a aac -b:a 128k $output
  }

  print (echo-g "done!")
  notify-send "noise removal done!"
  if $notify {"noise removal finished!" | tasker send-notification}
}

# Helper to resolve PulseAudio/PipeWire sink monitor and source input
export def resolve-screen-record-audio [] {
  mut sink_monitor = "@DEFAULT_SINK@.monitor"
  mut source_input = "@DEFAULT_SOURCE@"
  mut sink_name = ""

  try {
    let raw_sink = (pactl get-default-sink | str trim)
    if ($raw_sink | is-not-empty) {
      $sink_name = $raw_sink
      $sink_monitor = $"($raw_sink).monitor"
    }
  } catch {
    # Fallback to virtual alias @DEFAULT_SINK@.monitor
  }

  try {
    let raw_source = (pactl get-default-source | str trim)
    if ($raw_source | is-not-empty) {
      $source_input = $raw_source
    }
  } catch {
    # Fallback to virtual alias @DEFAULT_SOURCE@
  }

  {
    sink_monitor: $sink_monitor,
    source_input: $source_input,
    sink_name: $sink_name
  }
}

# Helper to build screen recording arguments for FFmpeg
export def build-screen-record-args [
  resolution: string
  display: string
  file: string
  audio: bool = true
  no_mic: bool = false
  no_system: bool = false
  separate_tracks: bool = false
  sink_monitor: string = "@DEFAULT_SINK@.monitor"
  source_input: string = "@DEFAULT_SOURCE@"
  use_nvenc: bool = true
] {
  let ofile = $"($file).mp4"
  let video_input = [-thread_queue_size 1024 -video_size $resolution -framerate 24 -f x11grab -i $"($display).0+0,0"]
  let video_encode = if $use_nvenc {
    [-c:v h264_nvenc -preset p4 -cq 18 -pix_fmt yuv420p]
  } else {
    [-c:v libx264 -preset veryfast -crf 18 -pix_fmt yuv420p]
  }

  let capture_system = ($audio and (not $no_system))
  let capture_mic = ($audio and (not $no_mic))

  if ($capture_system and $capture_mic) {
    if $separate_tracks {
      [
        ...$video_input
        -thread_queue_size 1024 -f pulse -ac 2 -i $sink_monitor
        -thread_queue_size 1024 -f pulse -ac 2 -i $source_input
        -map 0:v -map 1:a -map 2:a
        ...$video_encode
        -c:a aac -b:a 192k -strict experimental
        $ofile
      ]
    } else {
      [
        ...$video_input
        -thread_queue_size 1024 -f pulse -ac 2 -i $sink_monitor
        -thread_queue_size 1024 -f pulse -ac 2 -i $source_input
        -filter_complex "[1:a][2:a]amix=inputs=2:duration=longest:dropout_transition=0[aout]"
        -map 0:v -map "[aout]"
        ...$video_encode
        -c:a aac -b:a 192k -strict experimental
        $ofile
      ]
    }
  } else if $capture_system {
    [
      ...$video_input
      -thread_queue_size 1024 -f pulse -ac 2 -i $sink_monitor
      -map 0:v -map 1:a
      ...$video_encode
      -c:a aac -b:a 192k -strict experimental
      $ofile
    ]
  } else if $capture_mic {
    [
      ...$video_input
      -thread_queue_size 1024 -f pulse -ac 2 -i $source_input
      -map 0:v -map 1:a
      ...$video_encode
      -c:a aac -b:a 192k -strict experimental
      $ofile
    ]
  } else {
    [
      ...$video_input
      ...$video_encode
      $ofile
    ]
  }
}

#screen record
export def "media screen-record" [
  file: string = "video"         # output filename without extension
  --audio = true                 # whether to record with audio or not
  --no-mic                       # do not record microphone (computer/system audio only)
  --no-system                    # do not record computer/system audio (microphone only)
  --separate-tracks              # record computer audio and microphone into separate audio streams
  --output(-o): string           # specific monitor/output to record on Hyprland (e.g. HDMI-A-1, DP-5)
  --select(-s)                   # interactively select a window or region to record (via slurp on Hyprland)
  --choose(-c)                   # interactively choose which screen/monitor to record
] {
  let is_hyprland = (($env.XDG_CURRENT_DESKTOP? | default "") == "Hyprland")

  if $is_hyprland {
    mut output_args = []

    if $select {
      try {
        let geometry = (slurp | str trim)
        if ($geometry | is-not-empty) {
          $output_args = [-g $geometry]
        }
      } catch {}
    } else if $choose {
      let monitors = try { hyprctl monitors -j | from json } catch { [] }
      if ($monitors | is-not-empty) {
        let options = ($monitors | each { |m| $"($m.name) - ($m.description)" })
        let chosen = ($options | input list "Select screen to record:")
        if ($chosen | is-not-empty) {
          let mon_name = ($chosen | split row " - " | first)
          $output_args = [-o $mon_name]
        }
      }
    } else if ($output | is-not-empty) {
      $output_args = [-o $output]
    } else {
      let focused_output = try {
        hyprctl monitors -j | from json | where focused | get 0.name
      } catch {
        try {
          hyprctl monitors -j | from json | get 0.name
        } catch {
          ""
        }
      }
      if ($focused_output | is-not-empty) {
        $output_args = [-o $focused_output]
      }
    }

    if ($audio and (not ($no_mic and $no_system))) {
      print (echo-g "recording screen with audio for Hyprland...")
      let audio_info = resolve-screen-record-audio
      print (echo-g $"[screen-record] Sink Monitor: ($audio_info.sink_monitor)")
      print (echo-g $"[screen-record] Mic Source:   ($audio_info.source_input)")

      if $no_mic {
        # Computer audio only
        wf-recorder ...$output_args $"--audio=($audio_info.sink_monitor)" -C aac -P b=192k -x yuv420p -f $"($file).mp4"
      } else if $no_system {
        # Microphone only
        wf-recorder ...$output_args $"--audio=($audio_info.source_input)" -C aac -P b=192k -x yuv420p -f $"($file).mp4"
      } else {
        # Dual audio: mix sink monitor and microphone via dynamic PipeWire null-sink
        let mix_name = $"sr_mix_(random chars -l 6)"
        let sink_mod = (pactl load-module module-null-sink $"sink_name=($mix_name)" | str trim)
        let lb_sink_mod = (pactl load-module module-loopback $"source=($audio_info.sink_monitor)" $"sink=($mix_name)" latency_msec=20 | str trim)
        let lb_src_mod = (pactl load-module module-loopback $"source=($audio_info.source_input)" $"sink=($mix_name)" latency_msec=20 | str trim)

        try {
          wf-recorder ...$output_args $"--audio=($mix_name).monitor" -C aac -P b=192k -x yuv420p -f $"($file).mp4"
        } catch { |e|
          # recording completed or interrupted by Ctrl+C
        }

        # Cleanup PipeWire modules
        try { pactl unload-module $lb_src_mod } catch {}
        try { pactl unload-module $lb_sink_mod } catch {}
        try { pactl unload-module $sink_mod } catch {}
      }
    } else {
      print (echo-g "recording screen without audio for Hyprland...")
      wf-recorder ...$output_args -x yuv420p -f $"($file).mp4"
    }
  } else {
    let resolution = try {
      xrandr | grep '*' | awk '{print $1}' | lines | first
    } catch {
      "1920x1080"
    }
    let display = ($env.DISPLAY? | default ":0")

    if ($audio and (not ($no_mic and $no_system))) {
      print (echo-g "recording screen with audio for Gnome/X11...")
      let audio_info = resolve-screen-record-audio
      print (echo-g $"[screen-record] Sink Monitor: ($audio_info.sink_monitor)")
      print (echo-g $"[screen-record] Mic Source:   ($audio_info.source_input)")

      let args_nvenc = build-screen-record-args $resolution $display $file $audio $no_mic $no_system $separate_tracks $audio_info.sink_monitor $audio_info.source_input true
      let args_cpu = build-screen-record-args $resolution $display $file $audio $no_mic $no_system $separate_tracks $audio_info.sink_monitor $audio_info.source_input false

      try {
        ffmpeg ...$args_nvenc
      } catch {
        print (echo-y "NVENC encode failed, falling back to CPU libx264...")
        ffmpeg ...$args_cpu
      }
    } else {
      print (echo-g "recording screen without audio for Gnome/X11...")
      let args_nvenc = build-screen-record-args $resolution $display $file false false false false "" "" true
      let args_cpu = build-screen-record-args $resolution $display $file false false false false "" "" false
      try {
        ffmpeg ...$args_nvenc
      } catch {
        ffmpeg ...$args_cpu
      }
    }
  }
  print (echo-g "recording finished...")
}

#remove audio from video file
export def "media remove-audio" [
  input_file: string #the input file
  output_file?       #the output file
  --notify(-n)       #notify to android via join/tasker
] {
  let output_file = get-input $"($input_file | path parse | get stem)-noaudio.($input_file | path parse | get extension)" $output_file

  try {
    echo-g "trying myffmpeg..."
    my-ffmpeg -n -loglevel 0 -i $input_file -c copy -an $output_file
  } catch {
    echo-r "trying ffmpeg..."
    ffmpeg -n -loglevel 0 -i $input_file -c copy -an $output_file
  }
  if $notify {"summary finished!" | tasker send-notification}
}

#cut segment of video file
export def "media cut-video" [
  file                     #video file name
  SEGSTART                 #timestamp of the start of the segment (hh:mm:ss)
  SEGEND                   #timestamp of the end of the segment (hh:mm:ss)
  --output_file(-o):string #output file
  --append(-a):string = "cutted"  #append to file name
  --notify(-n)             #notify to android via join/tasker
  --reencode(-r)           #reencode video
  --audio-track: int       #audio stream index to include (0-based)
  --subtitle-track: int    #subtitle stream index to include (0-based)
] {
  let ext = $file | path parse | get extension
  let name = $file | path parse | get stem

  let ofile = get-input $"($name)_($append).($ext)" $output_file

  mut audio_idx = $audio_track
  mut sub_idx = $subtitle_track
  if ($audio_idx | is-empty) or ($sub_idx | is-empty) {
    let info = media video-info $file
    if ($audio_idx | is-empty) { $audio_idx = resolve-audio-track $info null }
    if ($sub_idx | is-empty) { $sub_idx = resolve-subtitle-track $info null }
  }

  let args = build-cut-args $file $SEGSTART $SEGEND $ofile $reencode $audio_idx $sub_idx
  let fallback_args = build-cut-args $file $SEGSTART $SEGEND $ofile $reencode null null

  try {
    echo-g "trying myffmpeg..."
    try {
      my-ffmpeg ...$args
    } catch {
      print (echo-y "requested track(s) not available; falling back to video-only")
      my-ffmpeg ...$fallback_args
    }
  } catch {
    echo-r "trying ffmpeg..."
    try {
      ffmpeg ...$args
    } catch {
      print (echo-y "requested track(s) not available; falling back to video-only")
      ffmpeg ...$fallback_args
    }
  }
  if $notify {"summary finished!" | tasker send-notification}
}

#build ffmpeg argument list for a cut with selected streams
def build-cut-args [
  file: string
  start: string
  end: string
  ofile: string
  reencode: bool
  audio_idx: any
  sub_idx: any
] {
  mut args = ["-i", $file, "-ss", $start, "-to", $end]
  $args = ($args | append ["-map", "0:0"])
  if ($audio_idx | is-not-empty) {
    $args = ($args | append ["-map", $"0:($audio_idx)"])
  }
  if ($sub_idx | is-not-empty) {
    $args = ($args | append ["-map", $"0:($sub_idx)"])
  }
  if not $reencode {
    $args = ($args | append ["-c:v", "copy"])
    if ($audio_idx | is-not-empty) { $args = ($args | append ["-c:a", "copy"]) }
    if ($sub_idx | is-not-empty) { $args = ($args | append ["-c:s", "copy"]) }
  }
  $args | append ["-y", $ofile]
}

#split video file
export def "media split-video" [
  file                      #video file name
  --number_segments(-n):int #number of pieces to generate (takes precedence over -d)
  --duration(-d):duration   #duration of each segment except probably the last one
  --delta:duration = 10sec  #duration of overlaping beetween segments
  --notify(-n)              #notify to android via join/tasker
  --audio-track: int        #audio stream index to include (0-based)
  --subtitle-track: int     #subtitle stream index to include (0-based)
] {
  let info = media video-info $file
  let audio_idx = resolve-audio-track $info $audio_track
  let sub_idx = resolve-subtitle-track $info $subtitle_track

  let full_length = $info
    | get format
    | get duration
  

def format-hhmmss [dur?: duration] {
  let dur_val = if ($dur | is-empty) { $in } else { $dur }
  let total_secs = ($dur_val / 1sec | math floor | into int)
  let hours = ($total_secs / 3600 | math floor | into int)
  let mins = (($total_secs mod 3600) / 60 | math floor | into int)
  let secs = ($total_secs mod 60 | into int)
  $"($hours | fill -a right -c '0' -w 2):($mins | fill -a right -c '0' -w 2):($secs | fill -a right -c '0' -w 2)"
}

  let full_secs = ($full_length + "sec") | into duration
  let full_hhmmss = $full_secs | format-hhmmss

  let n_segments = if not ($number_segments | is-empty) {
      $number_segments
    } else {
      $full_secs / $duration + 1 | into int
    } 
  

  let seg_duration = $full_secs / $n_segments
  let seg_end = $seg_duration

  for $it in 1..($n_segments - 1) {
    let segment_start = (($it - 1) * $seg_duration) | format-hhmmss
    let segment_end = ($seg_end + ($it - 1) * $seg_duration + $delta) | format-hhmmss

    print (echo-g $"generating part ($it): ($segment_start) - ($segment_end)...")
    media cut-video $file $segment_start $segment_end -a ($it | into string) --audio-track $audio_idx --subtitle-track $sub_idx
  }

  let segment_start = (($n_segments - 1) * $seg_duration) | format-hhmmss

  print (echo-g $"generating part ($n_segments): ($segment_start) - ($full_hhmmss)...")
  media cut-video $file $segment_start $full_hhmmss -a ($n_segments | into string) --audio-track $audio_idx --subtitle-track $sub_idx
  if $notify {"video split finished!" | tasker send-notification}
}

#convert media files recursively to specified format
#
#Examples (make sure there are only compatible files in all subdirectories)
#media-to mp4 (avi/mkv to mp4)
#media-to mp4 -v libx265 (avi/mkv to mp4)
#media-to mp4 -c (avi to mp4)
#media-to aac (audio files to aac)
#media-to mp3 (audio files to mp3)
export def "media to" [
  to:string                 #destination format (aac, mp3 or mp4)
  --copy(-c)                #copy video codec and audio to mp3 (for mp4 only)
  --mkv(-m)                 #include mkv files (for mp4 only)
  --file(-f):string         #specify unique file to convert
  --vcodec(-v):string = "libx264"  #video codec (for single file only)
  --notify(-n)              #notify to android via join/tasker
] {
  if ($file | is-empty) {
    #to aac or mp3
    if $to like "aac" or $to like "mp3" {
      let n_files = bash -c $'find . -type f -not -name "*.part" -not -name "*.srt" -not -name "*.mkv" -not -name "*.mp4" -not -name "*.txt" -not -name "*.url" -not -name "*.jpg" -not -name "*.png" -not -name "*.3gp" -not -name  "*.($to)"'
          | lines 
          | length
      

      print (echo-g $"($n_files) audio files found...")

      if $n_files > 0 {
        bash -c $'find . -type f -not -name "*.part" -not -name "*.srt" -not -name "*.mkv" -not -name "*.mp4" -not -name "*.txt" -not -name "*.url" -not -name "*.jpg" -not -name "*.png" -not -name "*.3gp" -not -name "*.($to)" -print0 | parallel -0 --eta ffmpeg -n -loglevel 0 -i {} -c:a ($to) -b:a 64k {.}.($to)'

       let aacs = ls **/* 
         | insert "ext" {|| 
             $in.name | path parse | get extension
           }  
         | where ext like $to 
         | length
       

        if $n_files == $aacs {
          print (echo-g $"audio conversion to ($to) done")
        } else {
          return-error $"audio conversion to ($to) done, but something might be wrong"
        }
      }

    #to mp4
    } else if $to like "mp4" {
      let n_files = ls **/*
          | insert "ext" {|f| 
              $f.name | path parse | get extension
            }  
          | where ext like "avi|webm"
          | length
      

      print (echo-g $"($n_files) avi/webm files found...")

     if $n_files > 0 {
       if $copy {
         bash -c 'find . -type f \( -name "*.avi" -o -name "*.webm" \) -print0 | parallel -0 --eta ffmpeg -n -loglevel 0 -i {} -c:v copy -c:a mp3 {.}.mp4'
       } else {
          bash -c 'find . -type f \( -name "*.avi" -o -name "*.webm" \) -print0 | parallel -0 --eta ffmpeg -n -loglevel 0 -i {} -c:v libx264 -c:a aac {.}.mp4'
       }

        let aacs = ls **/* 
          | insert "ext" {|| 
              $in.name | path parse | get extension
            }  
          | where ext like "mp4"
          | length
        

       if $n_files == $aacs {
         print (echo-g $"avi video conversion to mp4 done")
       } else {
         return-error "video conversion to mp4 done, but something might be wrong"
       }
      }

      if $mkv {
        let n_files = ls **/*
          | insert "ext" {|f| 
              $f.name | path parse | get extension
            }  
          | where ext like "mkv"
          | length
        

        print (echo-g $"($n_files) mkv files found...")

        if $n_files > 0 {
          if $copy {
            bash -c 'find . -type f -name "*.mkv" -print0 | parallel -0 --eta ffmpeg -n -loglevel 0 -i {} -c:v copy -c:a mp3 -c:s mov_text {.}.mp4'
         } else {
           bash -c 'find . -type f -name "*.mkv" -print0 | parallel -0 --eta ffmpeg -n -loglevel 0 -i {} -c:v libx264 -c:a aac -c:s mov_text {.}.mp4'
         }

          let aacs = ls **/* 
            | insert "ext" {|| 
                $in.name | path parse | get extension
              }  
            | where ext like "mp4"
            | length
          

         if $n_files == $aacs {
           print (echo-g $"mkv video conversion to mp4 done")
         } else {
           return-error "video conversion to mp4 done, but something might be wrong"
         }
        }
      }
    }
    return
  }

  let filename = $file | path parse | get stem
  let ext = $file | path parse | get extension

  if $to like "aac" or $to like "mp3" {
    ffmpeg -n -loglevel 48 -i $file -c:a $to -b:a 64k $"($filename).($to)"
  } else if $to like "mp4" {
    if $copy {
      if $ext like "mkv" {
        ffmpeg -n -loglevel 48 -i $file -c:v copy -c:a mp3 -c:s mov_text $"($filename).($to)"
      } else {
        ffmpeg -n -loglevel 48 -i $file -c:v copy -c:a mp3 $"($filename).($to)"
      }
    } else {
      if $ext like "mkv" {
        ffmpeg -n -loglevel 48 -i $file -c:v $vcodec -c:a aac -c:s mov_text $"($filename).($to)"
      } else {
        ffmpeg -n -loglevel 48 -i $file -c:v $vcodec -c:a aac $"($filename).($to)"
      }
    }
  } 
  if $notify {"conversion finished!" | tasker send-notification}
}

#cut segment from audio file
#
#Example: cut 10s starting at second 60 
#cut_audio input.ext output.ext 60 10
export def "media cut-audio" [
  infile:string   #input audio file
  outfile:string  #output audio file
  start:int       #start of the piece to extract (s) 
  duration:int    #duration of the piece to extract (s)
  --notify(-n)    #notify to android via join/tasker
] {  
  try {
    my-ffmpeg -ss $start -i $"($infile)" -t $duration -c copy $"($outfile)"
  } catch {
    ffmpeg -ss $start -i $"($infile)" -t $duration -c copy $"($outfile)"
  }
  if $notify {"cut finished!" | tasker send-notification}
}

#merge subs to mkv video
export def "media merge-subs" [
  filename     #name (without extencion) of both subtitle and mkv file
  --notify(-n) #notify to android via join/tasker
] { 
  mkvmerge -o myoutput.mkv  $"($filename).mkv" --language "0:spa" --track-name $"0:($filename)" $"($filename).srt"
  mv myoutput.mkv $"($filename).mkv"
  rm $"($filename).srt" | ignore
  if $notify {"subs merge finished!" | tasker send-notification}
}

#merge videos
#
#To get a functional output, all audio sample rate must be the same
#check with video-info video_file
#
#The file with the list must have the following structure:
#
#~~~
#file '/path/to/file/file1'"
#.
#.
#.
#file '/path/to/file/fileN'"
#~~~
export def "media merge-videos" [
  list         #text file with list of videos to merge
  output       #output file
  --notify(-n) #notify to android via join/tasker
] {
  print (echo-g "merging videos...")
  my-ffmpeg -f concat -safe 0 -i $"($list)" -c copy $"($output)"
  
  print (echo-g "done!")
  notify-send "video merge done!"
  if $notify {"video merge finished!" | tasker send-notification}
}

#auto merge all videos in dir
#
#To get a functional output, all audio sample rate must be the same
#check with video-info video_file
export def "media merge-videos-auto" [
  ext    #unique extension of all videos to merge
  output #output file
  --notify(-n) #notify to android via join/tasker
] {
  let list = $env.PWD | path join "list.txt"

  if not ($list | path exists) {
    touch $"($list)"
  } else {
    "" | save -f $list
  }
  
  ls ($"*.($ext)" | into glob) 
  | where type == file 
  | get name
  | each {|file|
      ("file \'" + ($env.PWD | path join $file) + "\'\n") | save --append list.txt
    }

  print (echo-g "merging videos...")
  my-ffmpeg -f concat -safe 0 -i list.txt -c copy $"($output).($ext)"
      
  print (echo-g "done!")
  notify-send "video merge done!"
  if $notify {"video merge finished!" | tasker send-notification}
}

const vcodecs = ["libx264", "libx265"]
#reduce size of video files recursively, to mp4 x265
#
#Considers only mp4 and webm files
#
#media compress-video
#media compress-video -m
#media compress-video -l 1
#media compress-video -c 20
#media compress-video -v libx264
#
#After ensuring that the conversions are ok, run
#
#media delete-non-compressed
#
#to delete original files
export def "media compress-video" [
  --file(-f):string         #single file
  --level(-l):int           #level of recursion (-maxdepth in ^find, minimun = 1).
  --crf(-c):int = 18        #compression rate, range 0-51, sane range 18-28.
  --vcodec(-v):string@$vcodecs = "libx265"  #video codec: libx264 | libx265.
  --append(-a):string = "com" # what to append to compressed file names
  --jobs(-j):int = 2        #number of jobs to run in parallel
  --mkv(-m)                 #include mkv files
  --notify(-n)              #notify to android via join/tasker
] {
  if ($file | is-empty) {
    let n_files = if ($level | is-empty) {
        if not $mkv {
          bash -c $"find . -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' (char -i 92)(char rparen) -not -name '*($append)*'"
        } else {
          bash -c $"find . -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' -o -iname '*.mkv' (char -i 92)(char rparen) -not -name '*($append)*'"
        }
      } else {
        if not $mkv {
          bash -c $"find . -maxdepth ($level) -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' (char -i 92)(char rparen) -not -name '*($append)*'"
        } else {
          bash -c $"find . -maxdepth ($level) -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' -o -iname '*.mkv' (char -i 92)(char rparen) -not -name '*($append)*'"
        }
      }
      | lines 
      | length
    

    if $n_files == 0 {return-error "no files found..."}

    print (echo-g $"($n_files) video files found...")

    if ($level | is-empty) {
      if not $mkv {
        try {
          print (echo-g "trying myffmpeg...")
          bash -c $"find . -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' (char -i 92)(char rparen) -not -name '*($append)*' -print0 | parallel -0 --eta --jobs ($jobs) myffmpeg -n -loglevel 0 -i {} -map 0:v -map 0:a -map 0:s? -vcodec ($vcodec) -crf ($crf) -c:a aac {.}_($append).mp4"
        } catch {
          print (echo-r "failed myffmpeg...")
          print (echo-g "trying ffmpeg...")
          bash -c $"find . -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' (char -i 92)(char rparen) -not -name '*($append)*' -print0 | parallel -0 --eta --jobs ($jobs) ffmpeg -n -loglevel 0 -i {} -map 0:v -map 0:a -map 0:s? -vcodec ($vcodec) -crf ($crf) -c:a aac {.}_($append).mp4"
        }
      } else {
        try {
          print (echo-g "trying myffmpeg...")
          bash -c $"find . -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' -o -iname '*.mkv' (char -i 92)(char rparen) -not -name '*($append)*' -print0 | parallel -0 --eta --jobs ($jobs) myffmpeg -n -loglevel 0 -i {} -map 0:v -map 0:a -map 0:s? -vcodec ($vcodec) -crf ($crf) -c:a aac -c:s mov_text {.}_($append).mp4"
        } catch {
          print (echo-r "failed myffmpeg...")
          print (echo-g "trying ffmpeg...")
          bash -c $"find . -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' -o -iname '*.mkv' (char -i 92)(char rparen) -not -name '*($append)*' -print0 | parallel -0 --eta --jobs ($jobs) ffmpeg -n -loglevel 0 -i {} -map 0:v -map 0:a -map 0:s? -vcodec ($vcodec) -crf ($crf) -c:a aac -c:s mov_text {.}_($append).mp4"
        }
      }
    } else {
      if not $mkv {
        try {
          print (echo-g "trying myffmpeg...")
          bash -c $"find . -maxdepth ($level) -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' (char -i 92)(char rparen) -not -name '*($append)*' -print0 | parallel -0 --eta --jobs ($jobs) myffmpeg -n -loglevel 0 -i {} -map 0:v -map 0:a -map 0:s? -vcodec ($vcodec) -crf ($crf) -c:a aac {.}_($append).mp4"
        } catch {
          print (echo-r "failed myffmpeg...")
          print (echo-g "trying ffmpeg...")
          bash -c $"find . -maxdepth ($level) -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' (char -i 92)(char rparen) -not -name '*($append)*' -print0 | parallel -0 --eta --jobs ($jobs) ffmpeg -n -loglevel 0 -i {} -map 0:v -map 0:a -map 0:s? -vcodec ($vcodec) -crf ($crf) -c:a aac {.}_($append).mp4"
        }
      } else {
        try {
          print (echo-g "trying myffmpeg...")
          bash -c $"find . -maxdepth ($level) -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' -o -iname '*.mkv' (char -i 92)(char rparen) -not -name '*($append)*' -print0 | parallel -0 --eta --jobs ($jobs) myffmpeg -n -loglevel 0 -i {} -map 0:v -map 0:a -map 0:s? -vcodec ($vcodec) -crf ($crf) -c:a aac -c:s mov_text {.}_($append).mp4"
        } catch {
          print (echo-r "failed myffmpeg...")
          print (echo-g "trying ffmpeg...")
          bash -c $"find . -maxdepth ($level) -type f (char -i 92)(char lparen) -iname '*.mp4' -o -iname '*.webm' -o -iname '*.mkv' (char -i 92)(char rparen) -not -name '*($append)*' -print0 | parallel -0 --eta --jobs ($jobs) ffmpeg -n -loglevel 0 -i {} -map 0:v -map 0:a -map 0:s? -vcodec ($vcodec) -crf ($crf) -c:a aac -c:s mov_text {.}_($append).mp4"
        }
      }
    }
    return
  } 

  let ext = $file | path parse | get extension
  let name = $file | path parse | get stem

  match $ext {
    "avi" => {
      try {
        print (echo-g "trying myffmpeg...")
        my-ffmpeg -i $file -vcodec $vcodec -crf $crf -c:a aac $"($name)_($append).mp4"
      } catch {
        print (echo-r "failed myffmpeg...")
        print (echo-g "trying ffmpeg...")
        ffmpeg -i $file -map 0:v -map 0:a -map 0:s? -vcodec $vcodec -crf $crf -c:a aac $"($name)_($append).mp4"
      }
    },
    "mp4" => {
      try {
        print (echo-g "trying myffmpeg...")
        my-ffmpeg -i $file -vcodec $vcodec -crf $crf -c:a aac $"($name)_($append).mp4"
      } catch {
        print (echo-r "failed myffmpeg...")
        print (echo-g "trying ffmpeg...")
        ffmpeg -i $file -map 0:v -map 0:a -map 0:s? -vcodec $vcodec -crf $crf -c:a aac $"($name)_($append).mp4"
      }
    },
    "h264" => {
      try {
        print (echo-g "trying myffmpeg...")
        my-ffmpeg -i $file -map 0:v -map 0:a -map 0:s? -vcodec $vcodec -crf $crf -c:a aac $"($name)_($append).mp4"
      } catch {
        print (echo-r "failed myffmpeg...")
        print (echo-g "trying ffmpeg...")
        ffmpeg -i $file -map 0:v -map 0:a -map 0:s? -vcodec $vcodec -crf $crf -c:a aac $"($name)_($append).mp4"
      }
    },
    "webm" => {
      try {
        print (echo-g "trying myffmpeg...")
        my-ffmpeg -i $file -map 0:v -map 0:a -map 0:s? -vcodec $vcodec -crf $crf -c:a aac $"($name)_($append).mp4"
      } catch {
        print (echo-r "failed myffmpeg...")
        print (echo-g "trying ffmpeg...")
        ffmpeg -i $file -map 0:v -map 0:a -map 0:s? -vcodec $vcodec -crf $crf -c:a aac $"($name)_($append).mp4"
      }
    },
    "mkv" => {
      try {
        print (echo-g "trying myffmpeg...")
        my-ffmpeg -i $file -vcodec $vcodec -crf $crf -c:a aac -c:s mov_text $"($name)_($append).mp4"
      } catch {
        print (echo-r "failed myffmpeg...")
        print (echo-g "trying ffmpeg...")
        ffmpeg -i $file -map 0:v -map 0:a -map 0:s? -vcodec $vcodec -crf $crf -c:a aac -c:s mov_text $"($name)_($append).mp4"
      }
    },
    _ => {return-error "file extension not allowed"}
  }
  
  if $notify {"compression finished!" | tasker send-notification}
}

export alias mcv = media compress-video -nm

#delete original videos after compression recursively
export def "media delete-non-compressed" [
  file?
  --append(-a):string = '_com'
] {
  ls **/* 
  | where type == file 
  | where name like $append 
  | each {|file| 
      $file 
      | get name 
      | split row $"_($append)" 
      | str join "" 
      | path expand
    }
  | wrap name
  | rm-pipe

  ls **/*
  | where name like .webm
  | par-each {|file|
      let compressed = $file
        | get name
        | path expand
        | path parse
        | upsert stem ($file | get name | path parse | get stem | { $in + $"_($append)" })
        | upsert extension mp4
        | path join
      
      
      if ($compressed | path exists) {
        $file | rm-pipe
      }
    }
}

#search for a name in the media database
export def "media find" [
  search            #search term
  --season(-s):int  #season number
  --manga(-m)       #for searching manga
  --no_manga(-n)    #exclude manga results
] {
  let database = ls $env.MY_ENV_VARS.media_database 
    | where name like ".json" 
    | openm
  
  
  let S = if ($season | is-empty) {
      ""
    } else {
      $season | into string | fill -a r -c "0" -w 2
  }

  let results = if ($season | is-empty) {
      $database | find -i $search
    } else {
      $database | find -i $search | find -i $"s($S)"
    }

  if $manga {
    $results | find -i manga
  } else if $no_manga {
    $results | where path not-like Manga
  } else {
    $results
  }
  | ansi-strip-table
}

#play first/last downloaded youtube video
export def "media myt" [file?, --reverse(-r)] {
  let inp = $in
  let video = if not ($inp | is-empty) {
      $inp | get name
    } else if not ($file | is-empty) {
      $file
    } else if $reverse {
      ls | sort-by modified -r | where type == "file" | last | get name
    } else {
      ls | sort-by modified | where type == "file" | last | get name
    }
  
  
  ^mpv --ontop --window-scale=0.4 --save-position-on-quit --no-border $video

  let delete = input "delete file? (y/n): "
  if $delete == "y" {
    rm $video
    return
  } 

  let move = input "move file to pending? (y/n): "
  if $move == "y" {
    mv $video pending
  } 
}

#delete non wanted media in mps (youtube download folder)
export def "media delete-mps" [] {
  if $env.MY_ENV_VARS.mps not-like $env.PWD {
    return-error "wrong directory to run this!"
  } 

  le
  | where type == "file" and ext not-like "mp4|mkv|webm|part" 
  | each {|item| 
      rm $"($item.name)" | ignore
    }     
}

#mpv wrapper
export def mpv [
  video?, 
  --on-top(-o)
  --in-terminal(-i)
] {
  let video = get-input $in $video
  let type = $video | typeof

  match $type {
    "table" | "list" => {
      $video | each {|f| $f | mpv}
    },
    _ => {
      let file = match $type {
          "record" => {$video | get name | ansi strip},
          "string" => {$video | ansi strip}
        }
      
      
      if $env.XDG_CURRENT_DESKTOP == "Hyprland" {
        let active_window = ^hyprctl -j activewindow | from json | get workspace.name
        if $active_window == "special:dropdown" {
          ^hyprctl dispatch togglespecialworkspace dropdown
        }
        sleep 0.1sec
        
        let active_window = ^hyprctl -j activewindow | from json | get workspace.name
        let target_window = if (sys host | get hostname) == $env.MY_ENV_VARS.hosts.2 {3} else {1}
        
        if $active_window != ($target_window | into string) {
            ^hyprctl dispatch workspace $target_window
        }
      }
      
      if $on_top {
        ^mpv --save-position-on-quit --no-border --ontop $file
      } else if $in_terminal {
        ^mpv --save-position-on-quit --vo=kitty --really-quiet $file
      } else {
        ^mpv --save-position-on-quit --no-border $file
      } 
    }
  }
}

#extract audio from video file
export def "media extract-audio" [
  filename
  --audio_format(-a):string@$formats = "mp3" #audio output format, wav or mp3
  --notify(-n)               #notify to android via mpv
] {
  let file = $filename | path parse | get stem

  print (echo-g "extracting audio...")
  match $audio_format {
    "mp3" => {
      ffmpeg -loglevel 1 -i $"($filename)" -ar 44100 -ac 2 -ab 192k -f mp3 -vn $"($file).mp3"
    },
    "wav" => {
      ffmpeg -loglevel 1 -i $"($filename)" -acodec pcm_s16le -ar 128k -vn $"($file).wav"
    },
    _ => {return-error "format not allowed!"}
  }
  if $notify {"extraction finished!" | tasker send-notification}
}

#crop image by shortest dimension
#
#Generates a new square image cropped by the shortest dimention.
#The output name is (image_file_name_cropped.ext)
export def "media crop-image" [
  image?:string
  --name(-n)    #return name of cropped image
] {
  let image = get-input $in $image -n
  let image_size = identify $image | split row " " | get 2 | split row "x" | uniq
  
  if ($image_size | length) == 1 {
    print (echo-g "image already square!")
    if $name {return $image} else {return}
  }

  print (echo-r "Image isn't square, croping to the minor dimension...")

  let width = $image_size | get 0 | into int
  let height = $image_size | get 1 | into int

  let new_image = $"($image | path parse | get stem)_cropped.png"

  if $width > $height {
    let new_image_size = $height

    let choice = ["center", "left", "right"] | input list (echo-g "choose from where you want to crop the image:")

    match $choice {
      "center" => {
          convert ($image | path expand) -gravity Center -crop $"($new_image_size)x($new_image_size)+0+0" +repage $new_image
        },

      "left" => {
          convert ($image | path expand) -gravity West -crop $"($new_image_size)x($new_image_size)+0+0" +repage $new_image
        },

      "right" => {
          convert ($image | path expand) -gravity East -crop $"($new_image_size)x($new_image_size)+0+0" +repage $new_image
        },

      _ => {return-error "Wrong choice of location for cropped image!!!"}
    }

  } else {
    let new_image_size = $width

    let choice = ["center", "top", "bottom"] | input list (echo-g "choose from where you want to crop the image:")

    match $choice {
      "center" => {
          convert ($image | path expand) -gravity Center -crop $"($new_image_size)x($new_image_size)+0+0" +repage $new_image
        },

      "top" => {
          convert ($image | path expand) -gravity North -crop $"($new_image_size)x($new_image_size)+0+0" +repage $new_image
        },

      "bottom" => {
          convert ($image | path expand) -gravity South -crop $"($new_image_size)x($new_image_size)+0+0" +repage $new_image
        },

      _ => {return-error "Wrong choice of location for cropped image!!!"}
    }
  }

  if $name {return $new_image} else {return}
}

#crop video 
export def "media crop-video" [
  video?:string
  --left(-l):string = "0" #horizontal offset of the crop area from the left edge of the video
  --top(-t):string = "0"  #vertical offset of the crop area from the left edge of the video
  --size(-s):string       #resolution of output video (ex: "720:1280")
  --append_to_filename(-a):string = "cropped" #append to original filename to differentiate
  --android(-A)           #use android resolution "720:x"
] {
  let video = get-input $in $video -n
  let resolution = media video-info $video | get streams.0 | select width height
  let output_resolution = if not ($size | is-empty) {
      $size
    } else if $android {
      "720:" + ($resolution.height | into string)
    } else {
      return-error "output resolution not specified!"
    }
  

  let filename = $video | path parse | get stem 
  let extension = $video | path parse | get extension

  if $extension != "mp4" {
    media to mp4 -f $video
  }

  let file = $filename + ".mp4"
  let output = $filename + "_" + $append_to_filename + ".mp4"

  let crop_command = "crop=" + $output_resolution + ":" + $left + ":" + $top

  ffmpeg -i $file -vf $crop_command $output
}

#get first frame of video
export def "media get-frame" [
  time:string = "00:00:00" #time of the frame to extract format hh:mm:ss
  file? #file or list of files
  --single-file(-f):string
] {
  let files = get-input $in $file
  
  if ($single_file | is-not-empty) {
    ffmpeg -ss $time -i $single_file -vframes 1 $"($single_file | path parse | get stem).png"
    return
  }
  
  $files 
  | get name 
  | par-each -t ([(sys cpu  | length) / 2 ($files | length)] | math min) {|f| 
      ffmpeg -ss $time -i ($f) -vframes 1 $"($f | path parse | get stem).png"
    }
}

#images to video
#
#Example, for a list of files like:
#
# something_001_otherthing.png
# something_002_otherthing.png
# something_003_otherthing.png
# etc
#
#Run:
# media images-2-video something_%03d_otherthing.png
export def "media images-2-video" [
  files_pattern:string    # pattern for files
  --framerate(-f):int = 2 # how many images per second
  --output(-o):string = "output"  # file name of the output video
] {
  try {
    my-ffmpeg -framerate $framerate -i $files_pattern $"($output).mp4"
  } catch {
    ffmpeg -framerate $framerate -i $files_pattern $"($output).mp4"
  }
}

#auto remove black bars/banner from video
export def "media auto-crop-banner" [
  input: path
  output: path
] {
    let crop_params = ffmpeg -hide_banner -i $input -t 1 -vf cropdetect -f null - o+e>|
      | lines
      | where {|line| 'crop=' in $line}
      | first
      | split row " "
      | last

    ffmpeg -hide_banner -i $input -vf $crop_params $output
}

#remove logo from video
# Use `media get-frame` to extract the frame that contains the logo you want to remove
# Use gimp to obtain coordinates
export def "media remove-logo" [
    file: string,                   # The input video file
    --top-left(-l): string,         # Top-left coordinates, e.g., "540,96"
    --top-right(-r): string,        # Top-right coordinates, e.g., "726,96"
    --bottom-left(-b): string,      # Bottom-left coordinates, e.g., "540,120"
    --start-time(-s): string,       # Start time for removal, e.g., "00:00:00"
    --end-time(-e): string,         # End time for removal, e.g., "00:07:01" or "end"
    --output-file(-o): string,      # Optional output file name
    --append(-a): string = "delogo" # String to append to the output file name
] {
    # --- Calculate delogo parameters ---
    let tl = $top_left | split row "," | into int
    if ($tl | length) != 2 {return-error "Top-left coordinates must be in x,y format"}

    let tr = $top_right | split row "," | into int
    if ($tr | length) != 2 {return-error "Top-right coordinates must be in x,y format"}

    let bl = $bottom_left | split row "," | into int
    if ($bl | length) != 2 {return-error "Bottom-left coordinates must be in x,y format"}

    let x = $tl.0
    let y = $tl.1
    let w = $tr.0 - $tl.0
    let h = $bl.1 - $tl.1

    if $w <= 0 {return-error "Invalid width calculated. Top-right x must be greater than top-left x." }
    if $h <= 0 {return-error "Invalid height calculated. Bottom-left y must be greater than top-left y." }

    # --- Calculate time in seconds ---
    let start_parts = $start_time | split row ":" | into int
    if ($start_parts | length) != 3 {return-error "Start time must be in hh:mm:ss format"}
    let start_s = ($start_parts.0 * 3600) + ($start_parts.1 * 60) + $start_parts.2

    let end_s = if $end_time == "end" {
        # Get video duration if end time is "end"
        ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 $file | into float | math round
    } else {
        let end_parts = $end_time | split row ":" | into int
        if ($end_parts | length) != 3 {return-error "End time must be in hh:mm:ss format or 'end'"}
        ($end_parts.0 * 3600) + ($end_parts.1 * 60) + $end_parts.2
    }

    # --- Construct ffmpeg filter ---
    let filter = $"delogo=x=($x):y=($y):w=($w):h=($h):enable='between\(t,($start_s),($end_s)\)'"

    # --- Determine output file name ---
    let ext = $file | path parse | get extension
    let name = $file | path parse | get stem
    let ofile = if not ($output_file | is-empty) {
        $output_file
    } else {
        $"($name)_($append).($ext)"
    }

    # --- Run ffmpeg with fallback ---
    try {
        print (echo-g "Trying with my-ffmpeg (CUDA accelerated decode/encode)...")
        my-ffmpeg -i $file -vf $filter $ofile
    } catch {
        print (echo-r "my-ffmpeg with CUDA failed, falling back to standard ffmpeg (CPU)...")
        ffmpeg -i $file -vf $filter $ofile
    }
}

# Clip delogo parameters to ensure they are within frame boundaries
export def "media clip-delogo-params" [params: string, file: string, --w_band: int = 35, --h_band: int = 18] {
    # Expected format: delogo=x=832:y=591:w=442:h=129
    let parsed = $params | parse -r r#'delogo=x=(?<x>\d+):y=(?<y>\d+):w=(?<w>\d+):h=(?<h>\d+)'# | get 0
    let p_x = $parsed.x | into int
    let p_y = $parsed.y | into int
    let p_w = $parsed.w | into int
    let p_h = $parsed.h | into int
    
    # Get media dimensions (works for video and image)
    let info = ffprobe -v error -select_streams v:0 -show_entries stream=width,height -of csv=s=x:p=0 $file | str trim | split row "x" | into int
    let v_width = $info.0
    let v_height = $info.1

    # Tightening check: warn if area matches search bands
    let max_w_band = $v_width * $w_band / 100 | into int
    let max_h_band = $v_height * $h_band / 100 | into int

    if $p_w >= ($max_w_band - 10) or $p_h >= ($max_h_band - 10) {
        print (echo-y $"WARNING: Detected logo area w:($p_w), h:($p_h) is near search band limits max_w:($max_w_band), max_h:($max_h_band).")
        print (echo-y "The rectangle might be too big. Consider reducing --width_band (-W) or --height_band (-H).")
    }

    # Ensure x, y >= 0 and within frame
    let x = if $p_x < 0 { 0 } else if $p_x >= $v_width { $v_width - 1 } else { $p_x }
    let y = if $p_y < 0 { 0 } else if $p_y >= $v_height { $v_height - 1 } else { $p_y }

    # Ensure w, h > 0
    let w = if $p_w < 1 { 1 } else { $p_w }
    let h = if $p_h < 1 { 1 } else { $p_h }
    
    # Final boundary check: x + w < v_width, y + h < v_height
    # We use strictly < to be absolutely safe
    let w = if ($x + $w) >= $v_width { $v_width - $x - 1 } else { $w }
    let h = if ($y + $h) >= $v_height { $v_height - $y - 1 } else { $h }

    # Final safety: if width or height became <= 0 after clipping, reset to 1
    let w = if $w < 1 { 1 } else { $w }
    let h = if $h < 1 { 1 } else { $h }

    $"delogo=x=($x):y=($y):w=($w):h=($h)"
}

# Trim specified seconds from the end of a video
export def "media trim-end" [
    file: string,                  # The input video file
    --seconds(-s): float = 2.6     # Number of seconds to remove from the end (default: 2.5)
    --output(-o): string           # Optional output file name
    --notify(-n)                   # Notify to android via join/tasker
] {
    let ext = $file | path parse | get extension | str lowercase
    let name = $file | path parse | get stem
    let is_video = $ext in ["mp4", "mkv", "avi", "webm", "h264"]
    
    if not $is_video {
        return-error "This command only supports video files."
    }

    let ofile = if not ($output | is-empty) { $output } else { $"($name)_trimmed.($ext)" }

    # Get total duration
    let full_length = ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 $file 
        | str trim 
        | into float
    

    if $full_length <= $seconds {
        return-error $"Video duration (($full_length)s) is shorter than or equal to trim time (($seconds)s)."
    }

    let new_duration = $full_length - $seconds
    print (echo-g $"Trimming ($seconds)s from end. New duration: ($new_duration)s. Output: ($ofile)...")

    try {
        my-ffmpeg -i $file -t $new_duration -c copy $ofile -y
    } catch {
        print (echo-y "my-ffmpeg failed, falling back to standard ffmpeg...")
        ffmpeg -i $file -t $new_duration -c copy $ofile -y
    }

    if ($ofile | path exists) {
        print (echo-g $"SUCCESS: Video trimmed. Output saved to ($ofile)")
        if $notify { "Video trimming finished!" | tasker send-notification }
    } else {
        return-error "FFmpeg failed to produce output file."
    }
}

# Automatically remove logo from media file
#
# Examples:
# media auto-remove-logo input.mp4
# media auto-remove-logo input.mp4 --method find_rect --template logo.png
# media auto-remove-logo input.jpg --template logo.png
export def "media auto-remove-logo" [
    file: string,                  # The input file (video or image)
    --method(-m): string = "auto", # Detection method: 'auto' (zelea2/delogo), 'find_rect' (ffmpeg)
    --template(-t): string,        # Template image for 'find_rect' method (required for images)
    --threshold(-T): float = 0.5,  # Detection threshold for find_rect (0.0 to 1.0)
    --output(-o): string,          # Optional output file name
    --canny(-y),                   # Force canny edge detection (for zelea2 method)
    --width_band(-W): int = 35,    # Width search band percentage (default 35)
    --height_band(-H): int = 18,   # Height search band percentage (default 18)
    --corner(-c): int,             # Fix logo corner [0-3] (NW, NE, SW, SE)
    --return-info(-i),             # Return detection info (start, end, coordinates)
    --detect_only(-d),             # Only detect coordinates without transcoding/removing
    --notify(-n)                   # Notify to android via join/tasker
] {
    let ext = $file | path parse | get extension | str lowercase
    let name = $file | path parse | get stem
    let is_video = $ext in ["mp4", "mkv", "avi", "webm", "h264"]
    let is_image = $ext in ["jpg", "jpeg", "png", "webp"]
    mut info = {}

    if not $is_video and not $is_image {
        return-error $"Unsupported file extension: .($ext)"
    }

    if $is_image and $template == null and $method != "auto" {
        return-error "Template is required for image logo removal with find_rect method"
    }

    let delogo_bin = if ("~/software/delogo/delogo" | path expand | path exists) {
            "~/software/delogo/delogo" | path expand
        } else if (($env.HOME? | default "" | path join "software/delogo/delogo") | path exists) {
            $env.HOME | path join "software/delogo/delogo"
        } else {
            "delogo" # Assume it's in PATH as last resort
        }
    
    let dir = $file | path parse | get parent
    let ofile = if ($output | is-empty) {
        $dir | path join $"($name)_nologo.($ext)"
    } else {
        $output
    }

    let params = if $method == "auto" and $is_video {
        print (echo-g $"Attempting automatic logo detection on ($file) using ($delogo_bin) [W:($width_band)%, H:($height_band)%]...")
        let canny_flag = if $canny { "-y" } else { "" }
        let corner_flag = if not ($corner | is-empty) { $"-c ($corner)" } else { "" }
        let detection = bash -c $"($delogo_bin) ($canny_flag) ($corner_flag) -W ($width_band) -H ($height_band) '($file)'" | complete
        
        let p = if ($detection.stdout | str contains "delogo=") {
            ($detection.stdout | lines | where $it =~ "delogo=" | first | split row " corner" | first | str trim)
        } else {
            print (echo-r "Default detection failed. Attempting with Canny edge detection...")
            let detection_canny = bash -c $"($delogo_bin) -y ($corner_flag) -W ($width_band) -H ($height_band) '($file)'" | complete
            if ($detection_canny.stdout | str contains "delogo=") {
                ($detection_canny.stdout | lines | where $it =~ "delogo=" | first | split row " corner" | first | str trim)
            } else {
                return-error "Automatic logo detection failed. Please provide a template and use --method find_rect."
            }
        }
        
        print (echo-g $"Detected logo params: ($p)")

        if $return_info or $detect_only {
            let duration = ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 $file | str trim | into float
            let coords = $p | parse -r r#'delogo=x=(?<x>\d+):y=(?<y>\d+):w=(?<w>\d+):h=(?<h>\d+)'# | get 0
            $info = {
                start_time: 0,
                end_time: $duration,
                x: ($coords.x | into int),
                y: ($coords.y | into int),
                w: ($coords.w | into int),
                h: ($coords.h | into int)
            }
        }
        $p
    } else if $method == "find_rect" or ($is_image and ($template | is-not-empty)) {
        if ($template | is-empty) { return-error "Template file is required for find_rect method." }
        if not ($template | path exists) { return-error $"Template file not found: ($template)" }
        
        print (echo-g $"Attempting logo detection on ($file) using FFmpeg find_rect with template ($template) and threshold ($threshold)...")
        
        # Convert template to gray if needed
        let template_gray = $"($template | path parse | get stem)_gray.png"
        ffmpeg -i $template -vf format=gray $template_gray -y -loglevel quiet

        let time_limit = if $return_info or $detect_only { "" } else { "-t 5" }
        let detection = bash -c $"ffmpeg -i '($file)' -vf 'find_rect=object=($template_gray):threshold=($threshold)' ($time_limit) -f null -" | complete
        rm $template_gray | ignore

        if ($detection.stderr | str contains "Found at") {
            # Parse coordinates: [Parsed_find_rect_0 @ 0x...] Found at n=0 pts_time=0.000000 x=1102 y=688 with score=0.000914
            let matches = $detection.stderr | lines | where $it =~ "Found at" | parse -r r#'pts_time=(?<t>[\d.]+).*x=(?<x>\d+).*y=(?<y>\d+)'#
            let first_match = $matches | first
            let x = $first_match.x | into int
            let y = $first_match.y | into int
            
            # We also need width and height from template
            let info_template = ffprobe -v error -select_streams v:0 -show_entries stream=width,height -of csv=s=x:p=0 $template | str trim | split row "x" | into int
            let w = $info_template.0
            let h = $info_template.1

            if $return_info or $detect_only {
                let start_t = $matches.t | into float | math min
                let end_t = $matches.t | into float | math max
                $info = {
                    start_time: $start_t,
                    end_time: $end_t,
                    x: $x,
                    y: $y,
                    w: $w,
                    h: $h
                }
            }

            let p = $"delogo=x=($x):y=($y):w=($w):h=($h)"
            print (echo-g $"Detected logo params via find_rect: ($p)")
            $p
        } else {
            return-error "Logo detection via find_rect failed."
        }
    } else {
        return-error $"Method ($method) not supported for this file type."
    }

    # Validate and clip coordinates to prevent FFmpeg "outside of frame" errors
    let params = media clip-delogo-params $params $file --w_band $width_band --h_band $height_band

    if $return_info or $detect_only {
        $info = ($info | upsert delogo_params $params)
        let coords_clipped = $params | parse -r r#'delogo=x=(?<x>\d+):y=(?<y>\d+):w=(?<w>\d+):h=(?<h>\d+)'#
        if ($coords_clipped | is-not-empty) {
            let c0 = $coords_clipped | first
            $info = ($info | upsert x ($c0.x | into int) | upsert y ($c0.y | into int) | upsert w ($c0.w | into int) | upsert h ($c0.h | into int))
        }
    }

    if $detect_only {
        return (if $return_info { $info } else { $params })
    }

    # Removal Phase
    print (echo-g $"Applying removal filter to ($ofile)...")
    if $is_video {
        try {
            my-ffmpeg -i $file -vf $params -c:a copy $ofile -y
        } catch {
            do -i { ffmpeg -i $file -vf $params -c:a copy $ofile -y } | complete
            if not ($ofile | path exists) {
                return-error $"FFmpeg failed to produce output file using params: ($params). The area might still be invalid for this video's codec or dimensions."
            }
        }
    } else {
        ffmpeg -i $file -vf $params $ofile -y
    }

    if ($ofile | path exists) {
        print (echo-g $"SUCCESS: Logo removed. Output saved to ($ofile)")
        if $notify { "Logo removal finished!" | tasker send-notification }
        if $return_info { return $info }
    } else {
        return-error "FFmpeg failed to produce output file."
    }
}

# Add one or more logos to a video file
#
# Examples:
# media add-logo input.mp4 [{image: 'logo.png', x: 10, y: 10, start_time: 5, end_time: 15}]
# media add-logo input.mp4 logo_config.json
export def "media add-logo" [
    file: string,          # The input video file
    logo_data: any,        # List of records or path to JSON/YAML file
    --iterative(-I),       # Process logos iteratively (one pass per logo)
    --fit(-f),             # Reposition logos for best fit within frame
    --crf(-q): int = 18,   # Video encoding quality CRF/CQ (default 18 for visually lossless)
    --output(-o): string   # Optional output file name
] {
    let ext = $file | path parse | get extension | str lowercase
    let name = $file | path parse | get stem
    let is_video = $ext in ["mp4", "mkv", "avi", "webm", "h264"]

    if not $is_video {
        return-error "This command only supports video files."
    }

    let data = if ($logo_data | describe) == "string" {
        if ($logo_data | path exists) {
            let config_ext = $logo_data | path parse | get extension | str lowercase
            match $config_ext {
                "json" => (open $logo_data),
                "yaml" | "yml" => (open $logo_data),
                _ => (return-error $"Unsupported config file extension: .($config_ext)")
            }
        } else {
            return-error $"Config file not found: ($logo_data)"
        }
    } else {
        $logo_data
    }

    let data_desc = $data | describe
    if not ($data_desc =~ "list") and not ($data_desc =~ "table") {
        return-error $"Logo data must be a list or table of records. Found: ($data_desc)"
    }

    # Validation and default values
    let v_info = media video-info $file
    let duration = $v_info.format.duration | into float
    let frame_w = $v_info.streams | where codec_type == "video" | get 0.width | into int
    let frame_h = $v_info.streams | where codec_type == "video" | get 0.height | into int
    
    let validated_data = $data | each {|row|
        if ($row.image? | is-empty) or ($row.x? | is-empty) or ($row.y? | is-empty) {
            return-error "Each logo record must contain 'image', 'x', and 'y'."
        }
        if not ($row.image | path exists) {
            return-error $"Logo image not found: ($row.image)"
        }
        {
            image: ($row.image | path expand),
            x: ($row.x | into int),
            y: ($row.y | into int),
            w: (if ($row.w? | is-not-empty) { $row.w | into int } else { null }),
            h: (if ($row.h? | is-not-empty) { $row.h | into int } else { null }),
            scale: (if ($row.scale? | is-not-empty) { $row.scale | into float } else { null }),
            start_time: ($row.start_time? | default 0 | into float),
            end_time: ($row.end_time? | default $duration | into float)
        }
    }

    # Phase: Fit and Resize
    let validated_data = $validated_data | each {|row|
        mut r = $row
        
        # Get dimensions of the logo image
        let logo_info = ^identify $r.image | str trim | split row " "
        let logo_dim = $logo_info | get 2 | split row "x"
        let curr_w = $logo_dim | get 0 | into int
        let curr_h = $logo_dim | get 1 | into int
        let aspect = ($curr_w | into float) / ($curr_h | into float)

        # Compute target dimensions preserving aspect ratio
        let final_dims = if $r.scale != null and $r.w != null and $r.h != null {
            # Scaling relative to existing bounding box
            let target_box_w = ($r.w | into float) * $r.scale
            let target_box_h = ($r.h | into float) * $r.scale
            let w_based_h = $target_box_w / $aspect
            if $w_based_h <= $target_box_h {
                [($target_box_w | math round | into int), ($w_based_h | math round | into int)]
            } else {
                [(($target_box_h * $aspect) | math round | into int), ($target_box_h | math round | into int)]
            }
        } else if $r.w != null and $r.h != null {
            # Proportional fit inside w x h bounding box
            let target_box_w = $r.w | into float
            let target_box_h = $r.h | into float
            let w_based_h = $target_box_w / $aspect
            if $w_based_h <= $target_box_h {
                [($target_box_w | math round | into int), ($w_based_h | math round | into int)]
            } else {
                [(($target_box_h * $aspect) | math round | into int), ($target_box_h | math round | into int)]
            }
        } else if $r.w != null {
            let target_w = $r.w | into int
            let target_h = ($target_w | into float) / $aspect | math round | into int
            [$target_w, $target_h]
        } else if $r.h != null {
            let target_h = $r.h | into int
            let target_w = ($target_h | into float) * $aspect | math round | into int
            [$target_w, $target_h]
        } else if $r.scale != null {
            let target_w = ($curr_w | into float) * $r.scale | math round | into int
            let target_h = ($curr_h | into float) * $r.scale | math round | into int
            [$target_w, $target_h]
        } else {
            [$curr_w, $curr_h]
        }

        let final_w = $final_dims.0
        let final_h = $final_dims.1

        # Center position relative to original bounding box (if specified) and clamp to frame boundaries
        let raw_x = if $r.w != null {
            ($r.x | into float) + ((($r.w - $final_w) | into float) / 2.0) | math round | into int
        } else {
            $r.x
        }
        let raw_y = if $r.h != null {
            ($r.y | into float) + ((($r.h - $final_h) | into float) / 2.0) | math round | into int
        } else {
            $r.y
        }

        # Apply fit / boundary clamping
        let clamped_x = if $raw_x < 0 { 0 } else if ($raw_x + $final_w) > $frame_w { $frame_w - $final_w } else { $raw_x }
        let clamped_y = if $raw_y < 0 { 0 } else if ($raw_y + $final_h) > $frame_h { $frame_h - $final_h } else { $raw_y }

        $r = ($r | upsert x $clamped_x | upsert y $clamped_y | upsert w $final_w | upsert h $final_h)

        let img_source = $r.image
        let img_ext = $img_source | path parse | get extension | str lowercase
        if $final_w != $curr_w or $final_h != $curr_h or $img_ext == "svg" {
            let temp_logo = $"(( $img_source | path parse | get stem ))_resized_(( random chars --length 5 )).png"
            print (echo-g $"Pre-resizing logo: ($img_source) to ($final_w)x($final_h)...")
            if $img_ext == "svg" {
                try {
                    ^convert -density 300 -background none $img_source -resize $"($final_w)x($final_h)!" $temp_logo
                } catch {
                    try {
                        ^convert -background none $img_source -resize $"($final_w)x($final_h)!" $temp_logo
                    } catch {
                        print (echo-y "Warning: SVG conversion failed.")
                    }
                }
            } else {
                try {
                    ^convert $img_source -colorspace RGB -filter Lanczos -resize $"($final_w)x($final_h)" -colorspace sRGB -channel RGB -unsharp 0x0.6+0.6+0.005 +channel $temp_logo
                } catch {
                    print (echo-y "Warning: High-quality gamma-corrected resizing failed. Falling back to basic Lanczos resize.")
                    try {
                        ^convert $img_source -background none -filter Lanczos -resize $"($final_w)x($final_h)" -channel RGB -unsharp 0x0.6+0.6+0.005 +channel $temp_logo
                    } catch {
                        try {
                            ^convert $img_source -resize $"($final_w)x($final_h)" $temp_logo
                        } catch {
                            print (echo-y "Warning: ImageMagick resizing failed. Using original image.")
                        }
                    }
                }
            }
            
            if ($temp_logo | path exists) {
                $r = ($r | update image ($temp_logo | path expand))
            }
        }
        $r
    }

    mut ofile = if ($output | is-empty) {
        $"($name)_with_logo.($ext)"
    } else {
        $output
    }

    # Overwriting prevention
    let abs_file = $file | path expand
    let abs_ofile = $ofile | path expand
    if $abs_file == $abs_ofile {
        let new_ofile = $"($ofile | path parse | get stem)_v2.($ext)"
        print (echo-y $"WARNING: Output path same as input. Changing output to: ($new_ofile)")
        $ofile = $new_ofile
    }

    if $iterative {
        print (echo-g "Processing logos iteratively...")
        mut current_input = $file
        let total_logos = $validated_data | length
        
        for i in 0..($total_logos - 1) {
            let row = $validated_data | get $i
            let temp_output = if $i == ($total_logos - 1) { $ofile } else { $"(($ofile | path parse | get stem))_temp_($i).(($ofile | path parse | get extension))" }
            let in_file = $current_input # Create immutable copy for the catch block
            
            print (echo-g $"Applying logo ($i + 1)/($total_logos): ($row.image) at [($row.x), ($row.y)] from ($row.start_time)s to ($row.end_time)s...")
            
            let filter = $"overlay=x=($row.x):y=($row.y):format=auto:enable='between\(t,($row.start_time),($row.end_time)\)'"
            
            try {
                my-ffmpeg -i $in_file -i $row.image -filter_complex $filter -map 0:v -c:v h264_nvenc -preset p7 -cq $crf -b:v 0 -map 0:a? -c:a copy $temp_output -y
            } catch {
                ffmpeg -i $in_file -i $row.image -filter_complex $filter -map 0:v -c:v libx264 -crf $crf -preset slow -pix_fmt yuv420p -map 0:a? -c:a copy $temp_output -y
            }

            if $i > 0 {
                rm $current_input | ignore
            }
            $current_input = $temp_output
        }
        
        # Cleanup temporary resized logos
        for row in $validated_data {
            if ($row.image | str contains "_resized_") {
                rm $row.image | ignore
            }
        }
        
        print (echo-g $"SUCCESS: Logos added iteratively. Output saved to ($ofile)")
        return
    } else {
        print (echo-g "Processing logos in a single pass...")
        
        mut inputs = ["-i" $file]
        mut filter_parts = []
        mut last_label = "[0:v]"
        
        for i in 0..(($validated_data | length) - 1) {
            let row = $validated_data | get $i
            let img_idx = $i + 1
            $inputs = ($inputs | append ["-i" $row.image])
            
            let next_label = $"[v($img_idx)]"
            let filter = $"($last_label)[($img_idx):v]overlay=x=($row.x):y=($row.y):format=auto:enable='between\(t,($row.start_time),($row.end_time)\)'($next_label)"
            $filter_parts = ($filter_parts | append $filter)
            $last_label = $next_label
        }
        
        let filter_complex = $filter_parts | str join ";"
        let final_inputs = $inputs # Immutable copy for try/catch
        let map_label = $last_label # Immutable copy for try/catch
        let final_ofile = $ofile # Immutable copy for try/catch
        
        print (echo-g $"Executing single-pass FFmpeg with ($validated_data | length) logos...")
        
        try {
            my-ffmpeg ...$final_inputs -filter_complex $filter_complex -map $map_label -c:v h264_nvenc -preset p7 -cq $crf -b:v 0 -map 0:a? -c:a copy $final_ofile -y
        } catch {
            ffmpeg ...$final_inputs -filter_complex $filter_complex -map $map_label -c:v libx264 -crf $crf -preset slow -pix_fmt yuv420p -map 0:a? -c:a copy $final_ofile -y
        }

        # Cleanup temporary resized logos
        for row in $validated_data {
            if ($row.image | str contains "_resized_") {
                rm $row.image | ignore
            }
        }

        if ($final_ofile | path exists) {
            print (echo-g $"SUCCESS: Logos added in a single pass. Output saved to ($final_ofile)")
        } else {
            return-error "FFmpeg failed to produce output file."
        }
    }
}

# Replace a logo in a video file with a new image
#
# This command automatically detects the existing logo, removes it,
# and places the new image in the same location and timestamps.
#
# Examples:
# media replace-logo input.mp4 new_logo.png
# media replace-logo input.mp4 new_logo.png --scale 1.0
# media replace-logo input.mp4 new_logo.png --resize 200x100 --clean
export def "media replace-logo" [
    file: string,                  # The input video file
    image: string,                 # The new logo image
    --scale(-s): float,            # Scale factor for the new logo (1.0 = original size)
    --resize(-r): string,          # Force custom size (WxH, e.g., 200x100)
    --fit(-f),                     # Reposition logo for best fit without scaling
    --original-logo-size(-O),      # Keep logo at its 1:1 original dimensions without resizing
    --crf(-q): int = 18,           # Video encoding quality CRF/CQ (default 18 for visually lossless)
    --clean(-c)                    # Delete intermediate logo-free video (if two-pass fallback is used)
] {
    let ext = $file | path parse | get extension | str lowercase
    let name = $file | path parse | get stem
    let is_video = $ext in ["mp4", "mkv", "avi", "webm", "h264"]

    if not $is_video {
        return-error "This command only supports video files."
    }
    if not ($image | path exists) {
        return-error $"Logo image not found: ($image)"
    }
    if $fit and ($scale != null or ($resize | is-not-empty) or $original_logo_size) {
        return-error "Flag --fit cannot be used with --scale, --resize, or --original-logo-size."
    }
    if $original_logo_size and ($scale != null or ($resize | is-not-empty)) {
        return-error "Flag --original-logo-size cannot be used with --scale or --resize."
    }

    let dir = $file | path parse | get parent
    let ofile = $dir | path join $"($name)_replaced.($ext)"

    # Phase 2: Logo Detection (Attempt fast detect-only without lossy intermediate transcoding)
    print (echo-g $"Detecting original logo on ($file)...")
    let info = try {
        media auto-remove-logo $file --return-info --detect_only
    } catch {
        null
    }

    if ($info | is-empty) or ($info.x? | is-empty) or ($info.delogo_params? | is-empty) {
        # Fallback to two-pass if direct detection failed
        print (echo-y "Direct detection failed. Falling back to two-pass logo replacement...")
        let remove_info = media auto-remove-logo $file --return-info
        if ($remove_info | is-empty) {
            return-error "Logo detection failed. Aborting replacement."
        }
        let intermediate_file = $dir | path join $"($name)_nologo.($ext)"
        if not ($intermediate_file | path exists) {
            return-error $"Intermediate logo-free file missing: ($intermediate_file)"
        }
        mut logo_rec = $remove_info | insert image $image
        if $original_logo_size {
            let logo_dim = ^identify ($image | path expand) | str trim | split row " " | get 2 | split row "x" | into int
            $logo_rec = ($logo_rec | upsert w $logo_dim.0 | upsert h $logo_dim.1 | upsert scale null)
        } else if ($resize | is-not-empty) {
            let parts = $resize | split row "x"
            $logo_rec = ($logo_rec | upsert w ($parts.0 | into int) | upsert h ($parts.1 | into int) | upsert scale null)
        } else if $scale != null {
            $logo_rec = ($logo_rec | upsert scale $scale)
        } else if $fit {
            $logo_rec = ($logo_rec | upsert scale null | upsert w null | upsert h null)
        } else {
            $logo_rec = ($logo_rec | upsert scale null)
        }
        media add-logo $intermediate_file [$logo_rec] --output $ofile --fit=$fit --crf $crf
        if ($ofile | path exists) and $clean {
            rm $intermediate_file | ignore
        }
        return
    }

    # Phase 3: Single-Pass Combined Delogo + Overlay
    print (echo-g "Preparing high-quality replacement logo and single-pass filtergraph...")
    let v_info = media video-info $file
    let duration = $v_info.format.duration | into float
    let frame_w = $v_info.streams | where codec_type == "video" | get 0.width | into int
    let frame_h = $v_info.streams | where codec_type == "video" | get 0.height | into int

    let logo_info = ^identify ($image | path expand) | str trim | split row " "
    let logo_dim = $logo_info | get 2 | split row "x"
    let curr_w = $logo_dim | get 0 | into int
    let curr_h = $logo_dim | get 1 | into int
    let aspect = ($curr_w | into float) / ($curr_h | into float)

    let final_dims = if $original_logo_size {
        [$curr_w, $curr_h]
    } else if ($resize | is-not-empty) {
        let parts = $resize | split row "x"
        [($parts.0 | into int), ($parts.1 | into int)]
    } else if $scale != null and ($info.w? | is-not-empty) and ($info.h? | is-not-empty) {
        let target_box_w = ($info.w | into float) * $scale
        let target_box_h = ($info.h | into float) * $scale
        let w_based_h = $target_box_w / $aspect
        if $w_based_h <= $target_box_h {
            [($target_box_w | math round | into int), ($w_based_h | math round | into int)]
        } else {
            [(($target_box_h * $aspect) | math round | into int), ($target_box_h | math round | into int)]
        }
    } else if ($info.w? | is-not-empty) and ($info.h? | is-not-empty) {
        let target_box_w = $info.w | into float
        let target_box_h = $info.h | into float
        let w_based_h = $target_box_w / $aspect
        if $w_based_h <= $target_box_h {
            [($target_box_w | math round | into int), ($w_based_h | math round | into int)]
        } else {
            [(($target_box_h * $aspect) | math round | into int), ($target_box_h | math round | into int)]
        }
    } else {
        [$curr_w, $curr_h]
    }

    let final_w = $final_dims.0
    let final_h = $final_dims.1

    let raw_x = if ($info.w? | is-not-empty) {
        ($info.x | into float) + ((($info.w - $final_w) | into float) / 2.0) | math round | into int
    } else {
        $info.x
    }
    let raw_y = if ($info.h? | is-not-empty) {
        ($info.y | into float) + ((($info.h - $final_h) | into float) / 2.0) | math round | into int
    } else {
        $info.y
    }

    let clamped_x = if $final_w >= $frame_w {
        0
    } else if $raw_x < 0 {
        0
    } else if ($raw_x + $final_w) > $frame_w {
        $frame_w - $final_w
    } else {
        $raw_x
    }

    let clamped_y = if $final_h >= $frame_h {
        0
    } else if $raw_y < 0 {
        0
    } else if ($raw_y + $final_h) > $frame_h {
        $frame_h - $final_h
    } else {
        $raw_y
    }

    let img_source = ($image | path expand)
    let img_ext = $img_source | path parse | get extension | str lowercase
    let temp_logo = $"(( $img_source | path parse | get stem ))_resized_(( random chars --length 5 )).png"
    
    let actual_logo = if $original_logo_size {
        if $img_ext == "svg" {
            try {
                ^convert -density 300 -background none $img_source $temp_logo
                $temp_logo
            } catch {
                $img_source
            }
        } else {
            $img_source
        }
    } else {
        print (echo-g $"Pre-resizing logo: ($img_source) to ($final_w)x($final_h)...")
        if $img_ext == "svg" {
            try {
                ^convert -density 300 -background none $img_source -resize $"($final_w)x($final_h)!" $temp_logo
            } catch {
                try {
                    ^convert -background none $img_source -resize $"($final_w)x($final_h)!" $temp_logo
                } catch {
                    print (echo-y "Warning: SVG conversion failed.")
                }
            }
        } else {
            try {
                ^convert $img_source -colorspace RGB -filter Lanczos -resize $"($final_w)x($final_h)" -colorspace sRGB -channel RGB -unsharp 0x0.6+0.6+0.005 +channel $temp_logo
            } catch {
                print (echo-y "Warning: High-quality gamma-corrected resizing failed. Falling back to basic Lanczos resize.")
                try {
                    ^convert $img_source -background none -filter Lanczos -resize $"($final_w)x($final_h)" -channel RGB -unsharp 0x0.6+0.6+0.005 +channel $temp_logo
                } catch {
                    try {
                        ^convert $img_source -resize $"($final_w)x($final_h)" $temp_logo
                    } catch {
                        print (echo-y "Warning: ImageMagick resizing failed. Using original image.")
                    }
                }
            }
        }
        if ($temp_logo | path exists) { $temp_logo } else { $img_source }
    }

    let delogo_filter = $info.delogo_params
    let start_t = ($info.start_time? | default 0)
    let end_t = ($info.end_time? | default $duration)
    let filter_complex = $"[0:v]($delogo_filter)[clean];[clean][1:v]overlay=x=($clamped_x):y=($clamped_y):format=auto:enable='between\(t,($start_t),($end_t)\)'[outv]"

    print (echo-g $"Executing single-pass delogo + overlay on ($file) -> ($ofile)...")
    try {
        my-ffmpeg -i $file -i $actual_logo -filter_complex $filter_complex -map "[outv]" -c:v h264_nvenc -preset p7 -cq $crf -b:v 0 -map 0:a? -c:a copy $ofile -y
    } catch {
        ffmpeg -i $file -i $actual_logo -filter_complex $filter_complex -map "[outv]" -c:v libx264 -crf $crf -preset slow -pix_fmt yuv420p -map 0:a? -c:a copy $ofile -y
    }

    if ($temp_logo | path exists) {
        rm $temp_logo | ignore
    }

    if ($ofile | path exists) {
        print (echo-g $"SUCCESS: Logo replaced in a single pass. Output saved to ($ofile)")
    } else {
        return-error "FFmpeg failed to produce output file."
    }
}

# --- Track selection helpers (used by split-video / cut-video) ---

#extract audio streams from video-info record
export def get-audio-streams [info: record] {
  $info.streams
    | where codec_type == "audio"
    | each {|s| {
        index: ($s.index | into int)
        codec_name: $s.codec_name
        language: ($s.tags?.language? | default "?")
        title: ($s.tags?.title? | default "")
      }}
}

#extract subtitle streams from video-info record
export def get-subtitle-streams [info: record] {
  $info.streams
    | where codec_type == "subtitle"
    | each {|s| {
        index: ($s.index | into int)
        codec_name: $s.codec_name
        language: ($s.tags?.language? | default "?")
        title: ($s.tags?.title? | default "")
      }}
}

#build input-list choices from a stream list
export def build-stream-choice [streams: list] {
  $streams | each {|s|
    let title_part = if ($s.title | is-empty) {""} else {($" - ($s.title)")}
    { value: $s.index, label: $"Stream #0:($s.index): ($s.codec_name), ($s.language)($title_part)" }
  }
}

#select a stream track from video-info: auto-picks when unique, prompts when multiple
export def select-track [streams: list, prompt: string] {
  let n = $streams | length
  if $n == 0 { return null }
  if $n == 1 { return ($streams | get 0.index) }

  let choice = $streams
    | build-stream-choice $in
    | input list -fd label (echo-g $prompt)

  if ($choice | is-empty) { return null }
  $choice.value
}

#resolve audio track: flag wins, else auto-select or prompt
export def resolve-audio-track [info: record, audio_track: any = null] {
  if ($audio_track | is-not-empty) { return $audio_track }
  select-track (get-audio-streams $info) "Select audio track:"
}

#resolve subtitle track: flag wins, else prompt only when multiple (no auto-select)
export def resolve-subtitle-track [info: record, subtitle_track: any = null] {
  if ($subtitle_track | is-not-empty) { return $subtitle_track }
  let streams = get-subtitle-streams $info
  if ($streams | length) < 2 { return null }
  select-track $streams "Select subtitle track:"
}