////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 1993-2022 The Octave Project Developers
//
// See the file COPYRIGHT.md in the top-level directory of this
// distribution or <https://octave.org/copyright/>.
//
// This file is part of Octave.
//
// Octave is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Octave is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Octave; see the file COPYING.  If not, see
// <https://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////////////

#if defined (HAVE_CONFIG_H)
#  include "config.h"
#endif

#include <fstream>
#include <iostream>
#include <string>

#include "child-list.h"
#include "cmd-edit.h"
#include "oct-env.h"
#include "oct-syscalls.h"

#include "defaults.h"
#include "defun.h"
#include "error.h"
#include "errwarn.h"
#include "input.h"
#include "interpreter.h"
#include "interpreter-private.h"
#include "octave.h"
#include "ovl.h"
#include "pager.h"
#include "procstream.h"
#include "sighandlers.h"
#include "unwind-prot.h"
#include "utils.h"
#include "variables.h"

OCTAVE_BEGIN_NAMESPACE(octave)

  static bool
  pager_event_handler (pid_t pid, int status)
  {
    bool retval = false;

    if (pid > 0)
      {
        if (sys::wifexited (status) || sys::wifsignaled (status))
          {
            // Avoid warning() since that will put us back in the pager,
            // which would be bad news.

            std::cerr << "warning: connection to external pager lost (pid = "
                      << pid << ')' << std::endl;
            std::cerr << "warning: flushing pending output (please wait)"
                      << std::endl;

            // Request removal of this PID from the list of child
            // processes.

            retval = true;
          }
      }

    return retval;
  }

  // Assume our terminal wraps long lines.

  static bool
  more_than_a_screenful (const char *s, int len)
  {
    if (s)
      {
        int available_rows = command_editor::terminal_rows () - 2;

        int cols = command_editor::terminal_cols ();

        int count = 0;

        int chars_this_line = 0;

        for (int i = 0; i < len; i++)
          {
            if (*s++ == '\n')
              {
                count += chars_this_line / cols + 1;
                chars_this_line = 0;
              }
            else
              chars_this_line++;
          }

        if (count > available_rows)
          return true;
      }

    return false;
  }

  static std::string default_pager (void)
  {
    std::string pager_binary = sys::env::getenv ("PAGER");

    if (pager_binary.empty ())
      pager_binary = config::default_pager ();

    return pager_binary;
  }

  int
  pager_buf::sync (void)
  {
    output_system& output_sys = __get_output_system__ ();

    char *buf = pbase ();

    int len = pptr () - buf;

    if (output_sys.sync (buf, len))
      {
        flush_current_contents_to_diary ();

        seekoff (0, std::ios::beg);
      }

    return 0;
  }

  void
  pager_buf::flush_current_contents_to_diary (void)
  {
    char *buf = pbase () + m_diary_skip;

    std::size_t len = pptr () - buf;

    octave_diary.write (buf, len);

    m_diary_skip = 0;
  }

  void
  pager_buf::set_diary_skip (void)
  {
    m_diary_skip = pptr () - pbase ();
  }

  int
  diary_buf::sync (void)
  {
    output_system& output_sys = __get_output_system__ ();

    std::ofstream& external_diary_file = output_sys.external_diary_file ();

    if (output_sys.write_to_diary_file () && external_diary_file)
      {
        char *buf = pbase ();

        int len = pptr () - buf;

        if (len > 0)
          external_diary_file.write (buf, len);
      }

    seekoff (0, std::ios::beg);

    return 0;
  }

  pager_stream::pager_stream (void) : std::ostream (nullptr), m_pb (nullptr)
  {
    m_pb = new pager_buf ();
    rdbuf (m_pb);
    setf (unitbuf);
  }

  pager_stream::~pager_stream (void)
  {
    flush ();
    delete m_pb;
  }

  std::ostream& pager_stream::stream (void)
  {
    return *this;
  }

  void pager_stream::flush_current_contents_to_diary (void)
  {
    if (m_pb)
      m_pb->flush_current_contents_to_diary ();
  }

  void pager_stream::set_diary_skip (void)
  {
    if (m_pb)
      m_pb->set_diary_skip ();
  }

  // Reinitialize the pager buffer to avoid hanging on to large internal
  // buffers when they might not be needed.  This function should only be
  // called when the pager is not in use.  For example, just before
  // getting command-line input.

  void pager_stream::reset (void)
  {
    delete m_pb;
    m_pb = new pager_buf ();
    rdbuf (m_pb);
    setf (unitbuf);
  }

  diary_stream::diary_stream (void) : std::ostream (nullptr), m_db (nullptr)
  {
    m_db = new diary_buf ();
    rdbuf (m_db);
    setf (unitbuf);
  }

  diary_stream::~diary_stream (void)
  {
    flush ();
    delete m_db;
  }

  std::ostream& diary_stream::stream (void)
  {
    return *this;
  }

  // Reinitialize the diary buffer to avoid hanging on to large internal
  // buffers when they might not be needed.  This function should only be
  // called when the pager is not in use.  For example, just before
  // getting command-line input.

  void diary_stream::reset (void)
  {
    delete m_db;
    m_db = new diary_buf ();
    rdbuf (m_db);
    setf (unitbuf);
  }

  void flush_stdout (void)
  {
    output_system& output_sys = __get_output_system__ ();

    output_sys.flush_stdout ();
  }

  output_system::output_system (interpreter& interp)
    : m_interpreter (interp), m_pager_stream (), m_diary_stream (),
      m_external_pager (nullptr), m_external_diary_file (),
      m_diary_file_name ("diary"), m_PAGER (default_pager ()),
      m_PAGER_FLAGS (), m_page_output_immediately (false),
      m_page_screen_output (false), m_write_to_diary_file (false),
      m_really_flush_to_pager (false), m_flushing_output_to_pager (false)
  { }

  octave_value output_system::PAGER (const octave_value_list& args,
                                     int nargout)
  {
    return set_internal_variable (m_PAGER, args, nargout, "PAGER", false);
  }

  octave_value output_system::PAGER_FLAGS (const octave_value_list& args,
                                           int nargout)
  {
    return set_internal_variable (m_PAGER_FLAGS, args, nargout,
                                  "PAGER_FLAGS", false);
  }

  octave_value
  output_system::page_output_immediately (const octave_value_list& args,
                                          int nargout)
  {
    return set_internal_variable (m_page_output_immediately, args, nargout,
                                  "page_output_immediately");
  }

  octave_value
  output_system::page_screen_output (const octave_value_list& args,
                                     int nargout)
  {
    return set_internal_variable (m_page_screen_output, args, nargout,
                                  "page_screen_output");
  }

  std::string output_system::pager_command (void) const
  {
    std::string cmd = m_PAGER;

    if (! (cmd.empty () || m_PAGER_FLAGS.empty ()))
      cmd += ' ' + m_PAGER_FLAGS;

    return cmd;
  }

  void output_system::reset (void)
  {
    flush_stdout ();

    m_pager_stream.reset ();
    m_diary_stream.reset ();
  }

  void output_system::flush_stdout (void)
  {
    if (! m_flushing_output_to_pager)
      {
        unwind_protect_var<bool> restore_var1 (m_really_flush_to_pager);
        unwind_protect_var<bool> restore_var2 (m_flushing_output_to_pager);

        m_really_flush_to_pager = true;
        m_flushing_output_to_pager = true;

        std::ostream& pager_ostream = m_pager_stream.stream ();

        pager_ostream.flush ();

        clear_external_pager ();
      }
  }

  void output_system::close_diary (void)
  {
    // Try to flush the current buffer to the diary now, so that things
    // like
    //
    // function foo ()
    //   diary on;
    //   ...
    //   diary off;
    // endfunction
    //
    // will do the right thing.

    m_pager_stream.flush_current_contents_to_diary ();

    if (m_external_diary_file.is_open ())
      {
        octave_diary.flush ();
        m_external_diary_file.close ();
      }
  }

  void output_system::open_diary (void)
  {
    close_diary ();

    // If there is pending output in the pager buf, it should not go
    // into the diary file.

    m_pager_stream.set_diary_skip ();

    m_external_diary_file.open (m_diary_file_name.c_str (), std::ios::app);

    if (! m_external_diary_file)
      error ("diary: can't open diary file '%s'", m_diary_file_name.c_str ());
  }

  bool output_system::sync (const char *buf, int len)
  {
    // FIXME: The following seems to be a bit of a mess.

    if (m_interpreter.server_mode ()
        || ! m_interpreter.interactive ()
        || application::forced_interactive ()
        || m_really_flush_to_pager
        || (m_page_screen_output && m_page_output_immediately)
        || ! m_page_screen_output)
      {
        bool bypass_pager = (m_interpreter.server_mode ()
                             || ! m_interpreter.interactive ()
                             || application::forced_interactive ()
                             || ! m_page_screen_output
                             || (m_really_flush_to_pager
                                 && m_page_screen_output
                                 && ! m_page_output_immediately
                                 && ! more_than_a_screenful (buf, len)));

        if (len > 0)
          {
            do_sync (buf, len, bypass_pager);

            return true;
          }
      }

    return false;
  }

  void output_system::clear_external_pager (void)
  {
    if (m_external_pager)
      {
        child_list& kids = m_interpreter.get_child_list ();

        kids.remove (m_external_pager->pid ());

        delete m_external_pager;
        m_external_pager = nullptr;
      }
  }

  void output_system::start_external_pager (void)
  {
    if (m_external_pager)
      return;

    std::string pgr = pager_command ();

    if (! pgr.empty ())
      {
        m_external_pager = new oprocstream (pgr.c_str ());

        child_list& kids = m_interpreter.get_child_list ();

        kids.insert (m_external_pager->pid (),
                     pager_event_handler);
      }
  }

  void output_system::do_sync (const char *msg, int len, bool bypass_pager)
  {
    if (msg && len > 0)
      {
        if (bypass_pager)
          {
            if (m_interpreter.server_mode ())
              {
                event_manager& evmgr = m_interpreter.get_event_manager ();

                evmgr.interpreter_output (std::string (msg, len));
              }
            else
              {
                std::cout.write (msg, len);
                std::cout.flush ();
              }
          }
        else
          {
            start_external_pager ();

            if (m_external_pager)
              {
                if (m_external_pager->good ())
                  {
                    m_external_pager->write (msg, len);

                    m_external_pager->flush ();

#if defined (EPIPE)
                    if (errno == EPIPE)
                      m_external_pager->setstate (std::ios::failbit);
#endif
                  }
                else
                  {
                    // FIXME: something is not right with the
                    // pager.  If it died then we should receive a
                    // signal for that.  If there is some other problem,
                    // then what?
                  }
              }
            else
              {
                std::cout.write (msg, len);
                std::cout.flush ();
              }
          }
      }
  }

  std::ostream& __stdout__ (void)
  {
    output_system& output_sys = __get_output_system__ ();

    return output_sys.__stdout__ ();
  }

  std::ostream& __diary__ (void)
  {
    output_system& output_sys = __get_output_system__ ();

    return output_sys.__diary__ ();
  }

DEFMETHOD (diary, interp, args, nargout,
           doc: /* -*- texinfo -*-
@deftypefn  {} {} diary
@deftypefnx {} {} diary on
@deftypefnx {} {} diary off
@deftypefnx {} {} diary @var{filename}
@deftypefnx {} {[@var{status}, @var{diaryfile}] =} diary
Record a list of all commands @emph{and} the output they produce, mixed
together just as they appear on the terminal.

Valid options are:

@table @asis
@item on
Start recording a session in a file called @file{diary} in the current working
directory.

@item off
Stop recording the session in the diary file.

@item @var{filename}
Record the session in the file named @var{filename}.
@end table

With no input or output arguments, @code{diary} toggles the current diary
state.

If output arguments are requested, @code{diary} ignores inputs and returns
the current status.  The boolean @var{status} indicates whether recording is on
or off, and @var{diaryfile} is the name of the file where the session is
stored.
@seealso{history, evalc}
@end deftypefn */)
{
  int nargin = args.length ();

  if (nargin > 1)
    print_usage ();

  output_system& output_sys = interp.get_output_system ();

  if (nargout > 0)
    {
      // Querying diary variables
      if (nargout == 1)
        return ovl (output_sys.write_to_diary_file ());
      else
        return ovl (output_sys.write_to_diary_file (),
                    output_sys.diary_file_name ());
    }

  if (nargin == 0)
    {
      output_sys.write_to_diary_file (! output_sys.write_to_diary_file ());
      output_sys.open_diary ();
    }
  else
    {
      std::string arg = args(0).xstring_value ("diary: argument must be a string");

      if (arg == "on")
        {
          output_sys.write_to_diary_file (true);
          output_sys.open_diary ();
        }
      else if (arg == "off")
        {
          output_sys.close_diary ();
          output_sys.write_to_diary_file (false);
        }
      else
        {
          output_sys.diary_file_name (arg);
          output_sys.write_to_diary_file (true);
          output_sys.open_diary ();
        }
    }

  return ovl ();
}

DEFMETHOD (more, interp, args, ,
           doc: /* -*- texinfo -*-
@deftypefn  {} {} more
@deftypefnx {} {} more on
@deftypefnx {} {} more off
Turn output pagination on or off.

Without an argument, @code{more} toggles the current state.

The current state can be determined via @code{page_screen_output}.
@seealso{page_screen_output, page_output_immediately, PAGER, PAGER_FLAGS}
@end deftypefn */)
{
  int nargin = args.length ();

  if (nargin > 1)
    print_usage ();

  output_system& output_sys = interp.get_output_system ();

  if (nargin > 0)
    {
      std::string arg = args(0).xstring_value (R"(more: argument must be string "on" or "off")");

      if (arg == "on")
        output_sys.page_screen_output (true);
      else if (arg == "off")
        output_sys.page_screen_output (false);
      else
        error (R"(more: argument must be "on" or "off")");
    }
  else
    output_sys.page_screen_output (! output_sys.page_screen_output ());

  return ovl ();
}

DEFUN (terminal_size, args, ,
       doc: /* -*- texinfo -*-
@deftypefn  {} {[@var{rows}, @var{cols}] =} terminal_size ()
@deftypefnx {} {} terminal_size ([@var{rows}, @var{cols}])
Query or set the size of the terminal window.  If called with no arguments,
return a two-element row vector containing the current size of the terminal
window in characters (rows and columns).  If called with a two-element vector
of integer values, set the terminal size and return the previous setting.
Setting the size manually should not be needed when using readline for
command-line editing.
@seealso{list_in_columns}
@end deftypefn */)
{
  int nargin = args.length ();

  if (nargin > 1)
    print_usage ();

  RowVector size (2, 0.0);

  size(0) = command_editor::terminal_rows ();
  size(1) = command_editor::terminal_cols ();

  if (nargin == 1)
    {
      Matrix m = args(0).xmatrix_value ("argument must be a 2-element array");

      if (m.numel () != 2)
        error ("terminal_size: argument must be a 2-element array");

      int rows = math::x_nint (m(0));
      int cols = math::x_nint (m(1));

      if (rows <= 0 || cols <= 0)
        error ("terminal_size: rows and columns must be positive integers");

      command_editor::set_screen_size (rows, cols);
    }

  return ovl (size);
}

DEFMETHOD (page_output_immediately, interp, args, nargout,
           doc: /* -*- texinfo -*-
@deftypefn  {} {@var{val} =} page_output_immediately ()
@deftypefnx {} {@var{old_val} =} page_output_immediately (@var{new_val})
@deftypefnx {} {@var{old_val} =} page_output_immediately (@var{new_val}, "local")
Query or set the internal variable that controls whether Octave sends
output to the pager as soon as it is available.

When the value is @code{false}, Octave buffers its output and waits until just
before the prompt is printed to flush it to the pager.  This is the default.

When @code{page_screen_output} is @code{false}, this variable has no effect.

When called from inside a function with the @qcode{"local"} option, the
variable is changed locally for the function and any subroutines it calls.
The original variable value is restored when exiting the function.
@seealso{page_screen_output, more, PAGER, PAGER_FLAGS}
@end deftypefn */)
{
  output_system& output_sys = interp.get_output_system ();

  return output_sys.page_output_immediately (args, nargout);
}

DEFMETHOD (page_screen_output, interp, args, nargout,
           doc: /* -*- texinfo -*-
@deftypefn  {} {@var{val} =} page_screen_output ()
@deftypefnx {} {@var{old_val} =} page_screen_output (@var{new_val})
@deftypefnx {} {@var{old_val} =} page_screen_output (@var{new_val}, "local")
Query or set the internal variable that controls whether output intended
for the terminal window that is longer than one page is sent through a
pager.

This allows you to view one screenful at a time.  Some pagers
(such as @code{less}---@pxref{Installation}) are also capable of moving
backward on the output.

When called from inside a function with the @qcode{"local"} option, the
variable is changed locally for the function and any subroutines it calls.
The original variable value is restored when exiting the function.
@seealso{more, page_output_immediately, PAGER, PAGER_FLAGS}
@end deftypefn */)
{
  output_system& output_sys = interp.get_output_system ();

  return output_sys.page_screen_output (args, nargout);
}

DEFMETHOD (PAGER, interp, args, nargout,
           doc: /* -*- texinfo -*-
@deftypefn  {} {@var{val} =} PAGER ()
@deftypefnx {} {@var{old_val} =} PAGER (@var{new_val})
@deftypefnx {} {@var{old_val} =} PAGER (@var{new_val}, "local")
Query or set the internal variable that specifies the program to use
to display terminal output on your system.

The default value is normally @qcode{"less"}, @qcode{"more"}, or
@qcode{"pg"}, depending on what programs are installed on your system.
@xref{Installation}.

When called from inside a function with the @qcode{"local"} option, the
variable is changed locally for the function and any subroutines it calls.
The original variable value is restored when exiting the function.
@seealso{PAGER_FLAGS, page_output_immediately, more, page_screen_output}
@end deftypefn */)
{
  output_system& output_sys = interp.get_output_system ();

  return output_sys.PAGER (args, nargout);
}

DEFMETHOD (PAGER_FLAGS, interp, args, nargout,
           doc: /* -*- texinfo -*-
@deftypefn  {} {@var{val} =} PAGER_FLAGS ()
@deftypefnx {} {@var{old_val} =} PAGER_FLAGS (@var{new_val})
@deftypefnx {} {@var{old_val} =} PAGER_FLAGS (@var{new_val}, "local")
Query or set the internal variable that specifies the options to pass
to the pager.

When called from inside a function with the @qcode{"local"} option, the
variable is changed locally for the function and any subroutines it calls.
The original variable value is restored when exiting the function.
@seealso{PAGER, more, page_screen_output, page_output_immediately}
@end deftypefn */)
{
  output_system& output_sys = interp.get_output_system ();

  return output_sys.PAGER_FLAGS (args, nargout);
}

OCTAVE_END_NAMESPACE(octave)