#!ruby
#vim: set fileencoding:utf-8

# AUTHOR: dearblue <dearblue@users.osdn.me>
# Only this program is usable as public domain software.

require "extlz4"
require "optparse"
require "find"

PROGNAME = File.basename(__FILE__)
opt = OptionParser.new(<<-EOS, 8, "  ")
Usage: #{PROGNAME} [option]... [file]...

  This program is likely lz4-cli. Reinventing the wheel.
EOS

class << opt
  #
  # Define hidden switch.
  #
  def hide_on(opt, &block)
    top.short[opt.to_s[1]] ||= OptionParser::Switch::NoArgument.new(&block)
  end
end

mode = nil
verbose = 1
opt.separator("")
level = 1
opt.on("-1", "fastest (worst) compression (default)") { mode = :encode; level = 1 }
opt.separator("  -2 .. -8 set compression level")
opt.hide_on("-2") { mode = :encode; level = 2 }
opt.hide_on("-3") { mode = :encode; level = 3 }
opt.hide_on("-4") { mode = :encode; level = 4 }
opt.hide_on("-5") { mode = :encode; level = 5 }
opt.hide_on("-6") { mode = :encode; level = 6 }
opt.hide_on("-7") { mode = :encode; level = 7 }
opt.hide_on("-8") { mode = :encode; level = 8 }
opt.on("-9", "best (slowest) compression") { mode = :encode; level = 9 }
outstdout = false
opt.on("-c", "write to stdout, keep original files") { outstdout = true }
opt.on("-d", "uncompress files") { mode = :decode }
forceoverwrite = false
opt.on("-f", "force overwriting of output file") { forceoverwrite = true }
keepfile = false
opt.on("-k", "don't delete input files during operation") { keepfile = true }
opt.on("-q", "output no warnings") { verbose = 0 }
recursive = false
opt.on("-r", "recursively compress files in directories") { recursive = true }
opt.on("-t", "test compressed file") { mode = :test }
opt.on("-v", "increment verbosery level") { verbose += 1 }
outdir = nil
opt.on("-Cdir", "set output directory") { |dir| outdir = dir }
blocksize = 0
blockdep = false
blockchecksum = false
opt.separator("  -B#      set block size [4-7] (default: 7)") # merged to "-BD"
opt.on("-BD", "set mode to block dependency (improve compression ratio)", %w[4 5 6 7 D]) do |o|
  case o
  when ?4, ?5, ?6, ?7
    blocksize = 1 << ((o.ord - ?0.ord) * 2 + 8)
  when ?D
    blockdep = true
  else
    0/0
  end
end
checksum = true
opt.on("-Sx", "disable content checksum (default: enabled)", %w(x)) { checksum = false }
opt.on("-V", "display program version") {
  puts <<-EOS
#{PROGNAME}: extlz4-cli program version #{LZ4::VERSION} (powered by #{RUBY_ENGINE}-#{RUBY_VERSION})
  EOS

  exit 0
}

opt.separator <<EOS

temporary special operation:
EOS
opt.on("--fix-extlz4-0.1-bug",
       "fix corrupted lz4 stream file for encoded by extlz4-0.1",
       "this operation required xxhash (`gem install xxhash`)") { mode = :fix_extlz4_0_1_bug }

begin
  opt.parse!
rescue OptionParser::InvalidOption, OptionParser::InvalidArgument
  $stderr.puts <<-EOS
#{PROGNAME}: #{$!}
  EOS
#  $stderr.puts <<-EOS
##{PROGNAME}: #{$!}
#        enter ``#{PROGNAME} --help'' to print help.
#  EOS
  exit 1
end

def file_operation(outdir, infile, defaultoutfile, outstdout, forceoverwrite, keepfile)
  case
  when outstdout
    outfile = $stdout.binmode
  when infile == defaultoutfile # TODO: 大文字小文字を区別しないシステムも考慮すべし
    $stderr.puts "#{PROGNAME}: out file name is same as in file - #{infile}"
  else
    outfile = defaultoutfile
    outfile = File.join(outdir, File.basename(outfile)) if outdir
    if !forceoverwrite && File.exist?(outfile)
      $stderr.puts "#{PROGNAME}: file exists - #{outfile}. (with ``-f'' switch to overwrite)"
      return false
    end
  end

  yield(infile, outfile)

  if !outstdout
    t = File.mtime(infile)
    File.utime(t, t, outfile)
    File.unlink(infile) if !keepfile
  end

  true
end

def find_files(path, recursive = false)
  unless File.directory?(path)
    yield path
    return nil
  end

  unless recursive
    $stderr.puts "#{PROGNAME}: ignored directory - #{path}"
    return nil
  end

  Find.find(path) do |path1|
    yield path1 unless File.directory? path1
  end

  nil
end

begin
  if ARGV.empty?
    if $stdout.tty? && !forceoverwrite && mode != :decode && mode != :test
      $stderr.puts <<-EOS
#{PROGNAME}: not written to terminal. use ``-f'' to force encode.
\tor enter ``#{PROGNAME} --help'' to print help.
      EOS
      exit 1
    end

    $stdin.binmode
    $stdout.binmode

    case mode
    when :encode, nil
      LZ4.encode_file($stdin, $stdout, level,
                      blocksize: blocksize,
                      blocklink: blockdep,
                      checksum: checksum)
    when :decode
      LZ4.decode_file($stdin, $stdout)
    when :test
      LZ4.test_file($stdin)
    else
      raise NotImplementedError
    end

    exit 0
  else
    ARGV.each do |file1|
      file1 = file1.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
      find_files(file1, recursive) do |file|
        begin
          case
          when mode == :decode || (mode.nil? && file =~ /\.lz4$/i)
            file_operation(outdir, file, file.sub(/\.lz4$/i, ""), outstdout, forceoverwrite, keepfile) do |infile, outfile|
              LZ4.decode_file(infile, outfile)
            end
          when mode == :encode || mode.nil?
            file_operation(outdir, file, file + ".lz4", outstdout, forceoverwrite, keepfile) do |infile, outfile|
              LZ4.encode_file(infile, outfile, level,
                              blocksize: blocksize,
                              blocklink: blockdep,
                              checksum: checksum)
            end
          when mode == :test
            LZ4.test_file(file)
          when mode == :fix_extlz4_0_1_bug
            require "extlz4/oldstream"
            require "extlz4/fix-0.1bug"

            outname = file.sub(/(?<=#{File::SEPARATOR})(?=[^#{File::SEPARATOR}]+$)|^(?=[^#{File::SEPARATOR}]+$)/, "fixed-")
              file_operation(outdir, file, outname, outstdout, forceoverwrite, true) do |infile, outfile|
              if verbose > 0
                $stderr.puts "#{PROGNAME}: correcting lz4 file - #{infile} to #{outfile}"
              end
              if verbose > 1
                outinfo = ->(mesg, offset, total, *etc) do
                  $stderr.puts "#{mesg} (at #{offset} of #{total})"
                end
              end
              LZ4.fix_extlz4_0_1_bug(infile, outfile, &outinfo)
              end
          else
            $stderr.puts "#{PROGNAME}: mode error - #{mode}"
          end
        rescue LZ4::Error #, Object
          $stderr.puts "#{PROGNAME}: #{file} - #$! (#{$!.class})"
        end
      end
    end
  end
rescue LZ4::Error
  $stderr.puts "#{PROGNAME}: #$! (#{$!.class})"
rescue SystemCallError, SignalException
  # do nothing
end