module TTY::Screen

def self.private_module_function(name)
  module_function(name)
  private_class_method(name)
end

def command_exist?(command)
  exts = env.fetch("PATHEXT", "").split(::File::PATH_SEPARATOR)
  env.fetch("PATH", "").split(::File::PATH_SEPARATOR).any? do |dir|
    file = ::File.join(dir, command)
    ::File.exist?(file) ||
      exts.any? { |ext| ::File.exist?("#{file}#{ext}") }
  end
end

def height
  size[0]
end

def ioctl?(control, buf)
  ($stdout.ioctl(control, buf) >= 0) ||
    ($stdin.ioctl(control, buf) >= 0) ||
    ($stderr.ioctl(control, buf) >= 0)
rescue SystemCallError
  false
end

def jruby?; true end

def jruby?; false end

def nonzero_column?(column)
  column.to_i > 0
end

def run_command(*args)
  %x(#{args.join(" ")})
rescue IOError, SystemCallError
  nil
end

def size(verbose: false)
  size_from_java(verbose: verbose) ||
  size_from_win_api(verbose: verbose) ||
  size_from_ioctl ||
  size_from_io_console(verbose: verbose) ||
  size_from_readline(verbose: verbose) ||
  size_from_tput ||
  size_from_stty ||
  size_from_env ||
  size_from_ansicon ||
  size_from_default
end

def size_from_ansicon
  return unless env["ANSICON"] =~ /\((.*)x(.*)\)/
  size = [::Regexp.last_match(2).to_i, ::Regexp.last_match(1).to_i]
  size if nonzero_column?(size[1])
end

def size_from_default
  DEFAULT_SIZE
end

def size_from_env
  return unless env["COLUMNS"] =~ /^\d+$/
  size = [(env["LINES"] || env["ROWS"]).to_i, env["COLUMNS"].to_i]
  size if nonzero_column?(size[1])
end

def size_from_io_console(verbose: false)
  return unless output.tty?
  require "io/console" unless IO.method_defined?(:winsize)
  return unless output.respond_to?(:winsize)
  size = output.winsize
  size if nonzero_column?(size[1])
rescue Errno::EOPNOTSUPP
  # no support for winsize on output
rescue LoadError
  warn "no native io/console support or io-console gem" if verbose
end

def size_from_ioctl
  buffer = Array.new(TIOCGWINSZ_BUF_LEN, 0).pack(TIOCGWINSZ_BUF_FMT)
  if ioctl?(TIOCGWINSZ, buffer) ||
     ioctl?(TIOCGWINSZ_PPC, buffer) ||
     ioctl?(TIOCGWINSZ_SOL, buffer)
    rows, cols, = buffer.unpack(TIOCGWINSZ_BUF_FMT)
    [rows, cols] if nonzero_column?(cols)
  end
end

def size_from_ioctl; nil end

def size_from_java(verbose: false)
  require "java"
  java_import "jline.TerminalFactory"
  terminal = TerminalFactory.get
  size = [terminal.get_height, terminal.get_width]
  size if nonzero_column?(size[1])
rescue
  warn "failed to import java terminal package" if verbose
end

def size_from_java(verbose: false); nil end

def size_from_readline(verbose: false)
  return unless output.tty?
  require "readline" unless defined?(::Readline)
  return unless ::Readline.respond_to?(:get_screen_size)
  size = ::Readline.get_screen_size
  size if nonzero_column?(size[1])
rescue LoadError
  warn "no readline gem" if verbose
rescue NotImplementedError
end

def size_from_stty
  return unless output.tty? && command_exist?("stty")
  out = run_command("stty", "size")
  return unless out
  size = out.split.map(&:to_i)
  size if nonzero_column?(size[1])
end

def size_from_tput
  return unless output.tty? && command_exist?("tput")
  lines = run_command("tput", "lines")
  return unless lines
  cols = run_command("tput", "cols")
  [lines.to_i, cols.to_i] if nonzero_column?(cols)
end

def size_from_win_api(verbose: false)
  require "fiddle" unless defined?(Fiddle)
  kernel32 = Fiddle::Handle.new("kernel32")
  get_std_handle = Fiddle::Function.new(
    kernel32["GetStdHandle"], [-Fiddle::TYPE_INT], Fiddle::TYPE_INT)
  get_console_buffer_info = Fiddle::Function.new(
    kernel32["GetConsoleScreenBufferInfo"],
    [Fiddle::TYPE_LONG, Fiddle::TYPE_VOIDP], Fiddle::TYPE_INT)
  format = "SSSSSssssSS"
  buffer = ([0] * format.size).pack(format)
  stdout_handle = get_std_handle.(STDOUT_HANDLE)
  get_console_buffer_info.(stdout_handle, buffer)
  _, _, _, _, _, left, top, right, bottom, = buffer.unpack(format)
  size = [bottom - top + 1, right - left + 1]
  size if nonzero_column?(size[1] - 1)
rescue LoadError
  warn "no native fiddle module found" if verbose
rescue Fiddle::DLError
  # non windows platform or no kernel32 lib
end

def size_from_win_api(verbose: false); nil end

def width
  size[1]
end

def windows?; true end

def windows?; false end