class TTY::Reader

# File lib/tty/reader.rb, line 68
def initialize(**options)
  @input     = options.fetch(:input) { $stdin }
  @output    = options.fetch(:output) { $stdout }
  @interrupt = options.fetch(:interrupt) { :error }
  @env       = options.fetch(:env) { ENV }

  @track_history = options.fetch(:track_history) { true }
  @history_cycle = options.fetch(:history_cycle) { false }
  exclude_proc   = ->(line) { line.strip == '' }
  @history_exclude    = options.fetch(:history_exclude) { exclude_proc }
  @history_duplicates = options.fetch(:history_duplicates) { false }

  @console   = select_console(input)
  @history   = History.new do |h|
    h.cycle = @history_cycle
    h.duplicates = @history_duplicates
    h.exclude = @history_exclude
  end
  @stop = false # gathering input
  @cursor = TTY::Cursor

  subscribe(self)
end

# File lib/tty/reader.rb, line 32
def self.windows?
  ::File::ALT_SEPARATOR == '\\'
end

# File lib/tty/reader.rb, line 344
def add_to_history(line)
  @history.push(line)
end

# File lib/tty/reader.rb, line 269
def clear_display(line, screen_width)
  total_lines  = count_screen_lines(line.size, screen_width)
  current_line = count_screen_lines(line.prompt_size + line.cursor, screen_width)
  lines_down = total_lines - current_line

  output.print(cursor.down(lines_down)) unless lines_down.zero?
  output.print(cursor.clear_lines(total_lines))
end

# File lib/tty/reader.rb, line 288
def count_screen_lines(line_or_size, screen_width = TTY::Screen.width)
  line_size = if line_or_size.is_a?(Integer)
                line_or_size
              else
                Line.sanitize(line_or_size).size
              end
  # new character + we don't want to add new line on screen_width
  new_chars = self.class.windows? ? -1 : 1
  1 + [0, (line_size - new_chars) / screen_width].max
end

# File lib/tty/reader.rb, line 152
def get_codes(options = {}, codes = [])
  opts = { echo: true, raw: false }.merge(options)
  char = console.get_char(opts)
  handle_interrupt if console.keys[char] == :ctrl_c
  return if char.nil?
  codes << char.ord

  condition = proc { |escape|
    (codes - escape).empty? ||
    (escape - codes).empty? &&
    !(64..126).cover?(codes.last)
  }

  while console.escape_codes.any?(&condition)
    get_codes(options, codes)
  end
  codes
end

# File lib/tty/reader.rb, line 352
def history_next
  @history.next
  @history.get
end

# File lib/tty/reader.rb, line 348
def history_next?
  @history.next?
end

# File lib/tty/reader.rb, line 361
def history_previous
  line = @history.get
  @history.previous
  line
end

# File lib/tty/reader.rb, line 357
def history_previous?
  @history.previous?
end

# File lib/tty/reader.rb, line 371
def inspect
  "#<#{self.class}: @input=#{input}, @output=#{output}>"
end

# File lib/tty/reader.rb, line 339
def keyctrl_d(*)
  @stop = true
end

# File lib/tty/reader.rb, line 134
def read_keypress(options = {})
  opts  = { echo: false, raw: true }.merge(options)
  codes = unbufferred { get_codes(opts) }
  char  = codes ? codes.pack('U*') : nil

  trigger_key_event(char) if char
  char
end

# File lib/tty/reader.rb, line 184
def read_line(prompt = '', **options)
  opts = { echo: true, raw: true }.merge(options)
  line = Line.new(prompt, '')
  screen_width = TTY::Screen.width

  output.print(line.prompt)

  while (codes = get_codes(opts)) && (code = codes[0])
    char = codes.pack('U*')
    trigger_key_event(char)

    break if [:ctrl_d, :ctrl_z].include?(console.keys[char])

    if opts[:raw] && opts[:echo]
      clear_display(line, screen_width)
    end

    if console.keys[char] == :backspace || BACKSPACE == code
      if !line.start?
        line.left
        line.delete
      end
    elsif console.keys[char] == :delete || DELETE == code
      line.delete
    elsif console.keys[char].to_s =~ /ctrl_/
      # skip
    elsif console.keys[char] == :up
      line.replace(history_previous) if history_previous?
    elsif console.keys[char] == :down
      line.replace(history_next? ? history_next : '')
    elsif console.keys[char] == :left
      line.left
    elsif console.keys[char] == :right
      line.right
    elsif console.keys[char] == :home
      line.move_to_start
    elsif console.keys[char] == :end
      line.move_to_end
    else
      if opts[:raw] && code == CARRIAGE_RETURN
        char = "\n"
        line.move_to_end
      end
      line.insert(char)
    end

    if (console.keys[char] == :backspace || BACKSPACE == code) && opts[:echo]
      if opts[:raw]
        output.print("\e[1X") unless line.start?
      else
        output.print(?\s + (line.start? ? '' : ?\b))
      end
    end

    if opts[:raw] && opts[:echo]
      output.print(line.to_s)
      if char == "\n"
        line.move_to_start
      elsif !line.end? # readjust cursor position
        output.print(cursor.backward(line.text_size - line.cursor))
      end
    end

    if [CARRIAGE_RETURN, NEWLINE].include?(code)
      output.puts unless opts[:echo]
      break
    end
  end
  if track_history? && opts[:echo]
    add_to_history(line.text.rstrip)
  end
  line.text
end

# File lib/tty/reader.rb, line 311
def read_multiline(*args)
  @stop = false
  lines = []
  loop do
    line = read_line(*args)
    break if !line || line == ''
    next  if line !~ /\S/ && !@stop
    if block_given?
      yield(line) unless line.to_s.empty?
    else
      lines << line unless line.to_s.empty?
    end
    break if @stop
  end
  lines
end

# File lib/tty/reader.rb, line 95
def select_console(input)
  if self.class.windows? && !env['TTY_TEST']
    WinConsole.new(input)
  else
    Console.new(input)
  end
end

# File lib/tty/reader.rb, line 332
def trigger(event, *args)
  publish(event, *args)
end

# File lib/tty/reader.rb, line 111
def unbufferred(&block)
  bufferring = output.sync
  # Immediately flush output
  output.sync = true
  block[] if block_given?
ensure
  output.sync = bufferring
end