#!/usr/bin/env ruby
# encoding: utf-8
#
#     ____      ____
#    / __/___  / __/
#   / /_/_  / / /_
#  / __/ / /_/ __/
# /_/   /___/_/    Fuzzy finder for your shell
#
# URL:         https://github.com/junegunn/fzf
# Author:      Junegunn Choi
# License:     MIT
# Last update: November 10, 2013
#
# Copyright (c) 2013 Junegunn Choi
#
# MIT License
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

def usage x
  puts %[usage: fzf [options]

  -m, --multi      Enable multi-select
  -s, --sort=MAX   Maximum number of matched items to sort. Default: 500.
  +s, --no-sort    Do not sort the result. Keep the sequence unchanged.
  +i               Case-sensitive match
  +c, --no-color   Disable colors]
  exit x
end

stdout = $stdout.clone
$stdout.reopen($stderr)

usage 0 unless (%w[--help -h] & ARGV).empty?
@rxflag = ARGV.delete('+i') ? 0 : Regexp::IGNORECASE
@sort   = %w[+s --no-sort].map  { |e| ARGV.delete e }.compact.empty? ?
  ENV.fetch('FZF_DEFAULT_SORT', 500).to_i : nil
@color  = %w[+c --no-color].map { |e| ARGV.delete e }.compact.empty?
@multi  = !%w[-m --multi].map   { |e| ARGV.delete e }.compact.empty?
rest    = ARGV.join ' '
if sort = rest.match(/(-s|--sort=?) ?([0-9]+)/)
  usage 1 unless @sort
  @sort = sort[2].to_i
  rest  = rest.delete sort[0]
end
usage 1 unless rest.empty?

require 'thread'
require 'curses'

@mtx      = Mutex.new
@smtx     = Mutex.new
@cv       = ConditionVariable.new
@lists    = []
@new      = []
@query    = ''
@matches  = []
@count    = 0
@cursor_x = 0
@vcursor  = 0
@events   = {}
@selects  = {} # ordered >= 1.9

case RUBY_PLATFORM
when /darwin/
  module UConv
    CHOSUNG   = 0x1100
    JUNGSUNG  = 0x1161
    JONGSUNG  = 0x11A7
    CHOSUNGS  = 19
    JUNGSUNGS = 21
    JONGSUNGS = 28
    JJCOUNT   = JUNGSUNGS * JONGSUNGS
    NFC_BEGIN = 0xAC00
    NFC_END   = NFC_BEGIN + CHOSUNGS * JUNGSUNGS * JONGSUNGS

    def self.nfd str
      ret = ''
      str.split(//).each do |c|
        cp = c.ord
        if cp >= NFC_BEGIN && cp < NFC_END
          idx  = cp - NFC_BEGIN
          cho  = CHOSUNG  + idx / JJCOUNT
          jung = JUNGSUNG + (idx % JJCOUNT) / JONGSUNGS
          jong = JONGSUNG + idx % JONGSUNGS
          ret << cho << jung
          ret << jong if jong != JONGSUNG
        else
          ret << c
        end
      end
      ret
    end

    def self.nfc str, b = 0, e = 0
      ret  = ''
      omap = []
      pend = []
      str.split(//).each_with_index do |c, idx|
        cp = c.ord
        omap << ret.length
        unless pend.empty?
          if cp >= JUNGSUNG && cp < JUNGSUNG + JUNGSUNGS
            pend << cp - JUNGSUNG
            next
          elsif cp >= JONGSUNG && cp < JONGSUNG + JONGSUNGS
            pend << cp - JONGSUNG
            next
          else
            omap[-1] = omap[-1] + 1
            ret << [NFC_BEGIN + pend[0] * JJCOUNT +
                                (pend[1] || 0) * JONGSUNGS +
                                (pend[2] || 0)].pack('U*')
            pend.clear
          end
        end
        if cp >= CHOSUNG && cp < CHOSUNG + CHOSUNGS
          pend << cp - CHOSUNG
        else
          ret << c
        end
      end
      return [ret, omap[b] || 0, omap[e] || ((omap.last || 0) + 1)]
    end
  end

  def convert_query q
    UConv.nfd(q).split(//)
  end

  def convert_item item
    UConv.nfc(*item)
  end
else
  def convert_query q
    q.split(//)
  end

  def convert_item item
    item
  end
end

def emit event
  @mtx.synchronize do
    @events[event] = yield
    @cv.broadcast
  end
end

C = Curses
def max_items; C.lines - 2; end
def cursor_y;  C.lines - 1; end
def cprint str, col
  C.attron(col) do
    C.addstr str.gsub("\0", '')
  end if str
end

def print_input
  C.setpos cursor_y, 0
  C.clrtoeol
  cprint '> ', color(:blue, true)
  C.attron(C::A_BOLD) do
    C.addstr @query
  end
end

def print_info selected, msg = nil
  @fan ||= '-\|/-\|/'.split(//)
  C.setpos cursor_y - 1, 0
  C.clrtoeol
  prefix =
    if fan = @fan.shift
      @fan.push fan
      cprint fan, color(:fan, true)
      ' '
    else
      '  '
    end
  C.attron color(:info, false) do
    C.addstr "#{prefix}#{@matches.length}/#{@count}"
    C.addstr " (#{selected})" if selected > 0
    C.addstr msg if msg
  end
end

def refresh
  C.setpos cursor_y, 2 + width(@query[0, @cursor_x])
  C.refresh
end

def ctrl char
  char.to_s.ord - 'a'.ord + 1
end

if RUBY_VERSION.split('.').map { |e| e.rjust(3, '0') }.join > '001009'
  @wrx = Regexp.new '\p{Han}|\p{Katakana}|\p{Hiragana}|\p{Hangul}'
  def width str
    str.gsub(@wrx, '  ').length
  end

  def trim str, len, left
    width = width str
    diff = 0
    while width > len
      width -= (left ? str[0, 1] : str[-1, 1]) =~ @wrx ? 2 : 1
      str = left ? str[1..-1] : str[0...-1]
      diff += 1
    end
    [str, diff]
  end
else
  def width str
    str.length
  end

  def trim str, len, left
    diff = str.length - len
    if diff > 0
      [left ? str[diff..-1] : str[0...-diff], diff]
    else
      [str, 0]
    end
  end

  class String
    def ord
      self.unpack('c').first
    end
  end

  class Fixnum
    def ord
      self
    end
  end
end

C.init_screen
C.start_color
dbg =
  if C.respond_to?(:use_default_colors)
    C.use_default_colors
    -1
  else
    C::COLOR_BLACK
  end
C.raw
C.noecho

if @color
  if C.can_change_color?
    fg = ENV.fetch('FZF_FG', 252).to_i
    bg = ENV.fetch('FZF_BG', 236).to_i
    C.init_pair 1, 110,    dbg
    C.init_pair 2, 108,    dbg
    C.init_pair 3, fg + 2, bg
    C.init_pair 4, 151,    bg
    C.init_pair 5, 148,    dbg
    C.init_pair 6, 144,    dbg
    C.init_pair 7, 161,    bg
  else
    C.init_pair 1, C::COLOR_BLUE,   dbg
    C.init_pair 2, C::COLOR_GREEN,  dbg
    C.init_pair 3, C::COLOR_YELLOW, C::COLOR_BLACK
    C.init_pair 4, C::COLOR_GREEN,  C::COLOR_BLACK
    C.init_pair 5, C::COLOR_GREEN,  dbg
    C.init_pair 6, C::COLOR_WHITE,  dbg
    C.init_pair 7, C::COLOR_RED,    C::COLOR_BLACK
  end

  def color sym, bold = false
    C.color_pair([:blue, :match, :chosen,
                  :match!, :fan, :info, :red].index(sym) + 1) |
      (bold ? C::A_BOLD : 0)
  end
else
  def color sym, bold = false
    case sym
    when :chosen
     bold ? C::A_REVERSE : 0
    when :match
      C::A_UNDERLINE
    when :match!
      C::A_REVERSE | C::A_UNDERLINE
    else
      0
    end | (bold ? C::A_BOLD : 0)
  end
end

@read =
  if $stdin.tty?
    if default_command = ENV['FZF_DEFAULT_COMMAND']
      IO.popen(default_command)
    elsif !`which find`.empty?
      IO.popen("find * -path '*/\\.*' -prune -o -type f -print -o -type l -print 2> /dev/null")
    else
      exit 1
    end
  else
    $stdin
  end

reader = Thread.new {
  while line = @read.gets
    emit(:new) { @new << line.chomp }
  end
  emit(:loaded) { true }
  @smtx.synchronize { @fan = [] }
}

main     = Thread.current
searcher = Thread.new {
  events  = {}
  fcache  = {}
  matches = []
  selects = {}
  mcount  = 0      # match count
  plcount = 0      # prev list count
  q       = ''
  vcursor = 0
  delay   = -5

  begin
    while true
      @mtx.synchronize do
        while true
          events.merge! @events

          if @events.empty? # No new events
            @cv.wait @mtx
            next
          end
          @events.clear
          break
        end

        if events[:new]
          @lists << [@new, {}]
          @count += @new.length
          @new    = []
          fcache  = {}
        end

        if events[:select]
          selects = @selects.dup
        end
      end#mtx

      new_search = events[:key] || events.delete(:new)
      user_input = events[:key] || events[:vcursor] || events.delete(:select)
      progress   = 0
      started_at = Time.now

      if new_search && !@lists.empty?
        q = events.delete(:key) || q

        unless q.empty?
          q = q.downcase if @rxflag != 0
          regexp = Regexp.new(convert_query(q).inject('') { |sum, e|
            e = Regexp.escape e
            sum << "#{e}[^#{e}]*?"
          }, @rxflag)
        end

        matches = fcache[q] ||=
          begin
            found = []
            skip  = false
            cnt   = 0
            @lists.each do |pair|
              list, cache = pair
              cnt += list.length

              @mtx.synchronize {
                skip = @events[:key]
                progress = (100 * cnt / @count)
              }
              break if skip

              found.concat(cache[q] ||= q.empty? ? list : begin
                if progress < 100 && Time.now - started_at > 0.5
                  @smtx.synchronize do
                    print_info selects.length, " (#{progress}%)"
                    refresh
                  end
                end

                prefix, suffix = @query[0, @cursor_x], @query[@cursor_x..-1] || ''
                prefix_cache = suffix_cache = nil

                (prefix.length - 1).downto(1) do |len|
                  break if prefix_cache = cache[prefix[0, len]]
                end

                0.upto(suffix.length - 1) do |idx|
                  break if suffix_cache = cache[suffix[idx..-1]]
                end unless suffix.empty?

                partial_cache = [prefix_cache, suffix_cache].compact.sort_by { |e| e.length }.first
                (partial_cache ? partial_cache.map { |e| e.first } : list).map { |line|
                  # Ignore errors: e.g. invalid byte sequence in UTF-8
                  md = line.match(regexp) rescue nil
                  md && [line, *md.offset(0)]
                }.compact
              end)
            end
            next if skip
            @sort ? found : found.reverse
          end

        mcount = matches.length
        if @sort && mcount <= @sort && !q.empty?
          matches.replace matches.sort_by { |triple|
            line, b, e = triple
            [b ? (e - b) : 0, line.length, line]
          }
        end
      end#new_search

      # This small delay reduces the number of partial lists
      sleep((delay = [20, delay + 5].min) * 0.01) unless user_input

      if events.delete(:vcursor) || new_search
        @mtx.synchronize do
          plcount  = [@matches.length, max_items].min
          @matches = matches
          vcursor  = @vcursor = [0, [@vcursor, mcount - 1, max_items - 1].min].max
        end
      end

      # Output
      @smtx.synchronize do
        item_length = [mcount, max_items].min
        if item_length < plcount
          plcount.downto(item_length) do |idx|
            C.setpos cursor_y - idx - 2, 0
            C.clrtoeol
          end
        end

        maxc = C.cols - 3
        matches[0, max_items].each_with_index do |item, idx|
          next if !new_search && !((vcursor-1)..(vcursor+1)).include?(idx)

          line, b, e = convert_item item
          b ||= 0
          e ||= 0
          row = cursor_y - idx - 2
          chosen = idx == vcursor

          # Overflow
          if width(line) > maxc
            ewidth = width(line[0...e])
            # Stri..
            if ewidth <= maxc - 2
              line, _ = trim line, maxc - 2, false
              line << '..'
            # ..ring
            else
              # ..ri..
              line = line[0...e] + '..' if ewidth < width(line) - 2
              line, diff = trim line, maxc - 2, true
              b += 2 - diff
              e += 2 - diff
              b = [2, b].max
              line = '..' + line
            end
          end

          C.setpos row, 0
          C.clrtoeol
          cprint chosen ? '>' : ' ', color(:red, true)
          selected = selects.include?([*item][0])
          cprint selected ? '>' : ' ',
            chosen ? color(:chosen) : (selected ? color(:red, true) : 0)

          C.attron color(:chosen, true) if chosen

          if b < e
            C.addstr line[0, b]
            cprint   line[b...e], color(chosen ? :match! : :match, chosen)
            C.attron color(:chosen, true) if chosen
            C.addstr line[e..-1] || ''
          else
            C.addstr line
          end
          C.attroff color(:chosen, true) if chosen
        end

        print_info selects.length if !@lists.empty? || events[:loaded]
        refresh
      end
    end#while
  rescue Exception => e
    main.raise e
  end
}

got = nil
begin
  tty     = IO.open(IO.sysopen('/dev/tty'), 'r')
  input   = ''
  cursor  = 0
  actions = {
    :nop     => proc {},
    ctrl(:c) => proc { exit 1 },
    ctrl(:d) => proc { exit 1 if input.empty? },
    ctrl(:m) => proc {
      @mtx.synchronize do
        got = [*@matches.fetch(@vcursor, [])][0]
      end
      exit 0
    },
    ctrl(:u) => proc { input = input[cursor..-1]; cursor = 0 },
    ctrl(:a) => proc { cursor = 0 },
    ctrl(:e) => proc { cursor = input.length },
    ctrl(:j) => proc { emit(:vcursor) { @vcursor -= 1 } },
    ctrl(:k) => proc { emit(:vcursor) { @vcursor += 1 } },
    ctrl(:w) => proc {
      ridx   = (input[0...cursor - 1].rindex(/\S\s/) || -2) + 2
      input  = input[0...ridx] + input[cursor..-1]
      cursor = ridx
    },
    127 => proc { input[cursor -= 1] = '' if cursor > 0 },
    9 => proc { |o|
      emit(:select) {
        if sel = [*@matches.fetch(@vcursor, [])][0]
          if @selects.has_key? sel
            @selects.delete sel
          else
            @selects[sel] = 1
          end
          @vcursor = [0, @vcursor + (o == :stab ? 1 : -1)].max
        end
      } if @multi
    },
    :left => proc { cursor = [0, cursor - 1].max },
    :right => proc { cursor = [input.length, cursor + 1].min },
  }
  actions[ctrl(:b)] = actions[:left]
  actions[ctrl(:f)] = actions[:right]
  actions[ctrl(:h)] = actions[127]
  actions[ctrl(:n)] = actions[ctrl(:j)]
  actions[ctrl(:p)] = actions[ctrl(:k)]
  actions[:stab]    = actions[9]

  while true
    # Update user input
    @smtx.synchronize do
      @cursor_x = cursor
      print_input
      refresh
    end

    ord = tty.getc.ord
    if ord == 27
      ord = tty.getc.ord
      if ord == 91
        ord = case tty.getc.ord
              when 68 then :left
              when 67 then :right
              when 66 then ctrl(:j)
              when 65 then ctrl(:k)
              when 90 then :stab
              else :nop
              end
      end
    end

    actions.fetch(ord, proc { |ord|
      char = [ord].pack('U*')
      if char =~ /[[:print:]]/
        input.insert cursor, char
        cursor += 1
      end
    }).call(ord)

    # Dispatch key event
    emit(:key) { @query = input.dup }
  end
ensure
  C.close_screen
  if got
    @selects.delete got
    @selects.each do |sel, _|
      stdout.puts sel
    end
    stdout.puts got
  end
end