/****************************************************************************
 * apps/graphics/pdcurses/pdc_getstr.c
 * Public Domain Curses
 * RCSID("$Id: getstr.c,v 1.51 2008/07/14 04:24:51 wmcbrine Exp $")
 *
 *   Copyright (C) 2017 Gregory Nutt. All rights reserved.
 *   Adapted by: Gregory Nutt <gnutt@nuttx.org>
 *
 * Adapted from the original public domain pdcurses by Gregory Nutt and
 * released as part of NuttX under the 3-clause BSD license:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name NuttX nor the names of its contributors may be
 *    used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************/

/* Name: getstr
 *
 * Synopsis:
 *       int getstr(char *str);
 *       int wgetstr(WINDOW *win, char *str);
 *       int mvgetstr(int y, int x, char *str);
 *       int mvwgetstr(WINDOW *win, int y, int x, char *str);
 *       int getnstr(char *str, int n);
 *       int wgetnstr(WINDOW *win, char *str, int n);
 *       int mvgetnstr(int y, int x, char *str, int n);
 *       int mvwgetnstr(WINDOW *win, int y, int x, char *str, int n);
 *
 *       int get_wstr(wint_t *wstr);
 *       int wget_wstr(WINDOW *win, wint_t *wstr);
 *       int mvget_wstr(int y, int x, wint_t *wstr);
 *       int mvwget_wstr(WINDOW *win, int, int, wint_t *wstr);
 *       int getn_wstr(wint_t *wstr, int n);
 *       int wgetn_wstr(WINDOW *win, wint_t *wstr, int n);
 *       int mvgetn_wstr(int y, int x, wint_t *wstr, int n);
 *       int mvwgetn_wstr(WINDOW *win, int y, int x, wint_t *wstr, int n);
 *
 * Description:
 *       These routines call wgetch() repeatedly to build a string,
 *       interpreting erase and kill characters along the way, until a
 *       newline or carriage return is received. When PDCurses is built
 *       with wide-character support enabled, the narrow-character
 *       functions convert the wgetch()'d values into a multibyte string
 *       in the current locale before returning it. The resulting string
 *       is placed in the area pointed to by *str. The routines with n as
 *       the last argument read at most n characters.
 *
 *       Note that there's no way to know how long the buffer passed to
 *       wgetstr() is, so use wgetnstr() to avoid buffer overflows.
 *
 * Return Value:
 *       This functions return ERR on failure or any other value on
 *       success.
 *
 * Portability                                X/Open    BSD    SYS V
 *       getstr                                  Y       Y       Y
 *       wgetstr                                 Y       Y       Y
 *       mvgetstr                                Y       Y       Y
 *       mvwgetstr                               Y       Y       Y
 *       getnstr                                 Y       -      4.0
 *       wgetnstr                                Y       -      4.0
 *       mvgetnstr                               Y       -       -
 *       mvwgetnstr                              Y       -       -
 *       get_wstr                                Y
 *       wget_wstr                               Y
 *       mvget_wstr                              Y
 *       mvwget_wstr                             Y
 *       getn_wstr                               Y
 *       wgetn_wstr                              Y
 *       mvgetn_wstr                             Y
 *       mvwgetn_wstr                            Y
 */

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include "curspriv.h"

/****************************************************************************
 * Pre-processor Definitions
 ****************************************************************************/

#define MAXLINE 255

/****************************************************************************
 * Public Functions
 ****************************************************************************/

int wgetnstr(WINDOW *win, char *str, int n)
{
#ifdef CONFIG_PDCURSES_WIDE
  wchar_t wstr[MAXLINE + 1];

  if (n < 0 || n > MAXLINE)
    {
      n = MAXLINE;
    }

  if (wgetn_wstr(win, (wint_t *) wstr, n) == ERR)
    {
      return ERR;
    }

  return PDC_wcstombs(str, wstr, n);
#else
  int ch;
  int i;
  int num;
  int x;
  int chars;
  char *p;
  bool stop;
  bool oldecho;
  bool oldcbreak;
  bool oldnodelay;
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif

  PDC_LOG(("wgetnstr() - called\n"));

  if (!win || !str)
    {
      return ERR;
    }

  chars = 0;
  p = str;
  stop = false;

  x = win->_curx;

  oldcbreak  = SP->cbreak;      /* Remember states */
  oldecho    = SP->echo;
  oldnodelay = win->_nodelay;

  SP->echo   = false;           /* We do echo ourselves */
  cbreak();                     /* Ensure each key is returned immediately */
  win->_nodelay = false;        /* Don't return -1 */

  wrefresh(win);

  while (!stop)
    {
      ch = wgetch(win);

      switch (ch)
        {
        case '\t':
          ch = ' ';
          num = TABSIZE - (win->_curx - x) % TABSIZE;
          for (i = 0; i < num; i++)
            {
              if (chars < n)
                {
                  if (oldecho)
                    {
                      waddch(win, ch);
                    }

                  *p++ = ch;
                  ++chars;
                }
              else
                {
                  beep();
                }
            }
          break;

        case _ECHAR:           /* CTRL-H -- Delete character */
          if (p > str)
            {
              if (oldecho)
                {
                  waddstr(win, "\b \b");
                }

              ch = (unsigned char)(*--p);
              if ((ch < ' ') && (oldecho))
                {
                  waddstr(win, "\b \b");
                }

              chars--;
            }
          break;

        case _DLCHAR:          /* CTRL-U -- Delete line */
          while (p > str)
            {
              if (oldecho)
                {
                  waddstr(win, "\b \b");
                }

              ch = (unsigned char)(*--p);
              if ((ch < ' ') && (oldecho))
                {
                  waddstr(win, "\b \b");
                }
            }

          chars = 0;
          break;

        case _DWCHAR:          /* CTRL-W -- Delete word */

          while ((p > str) && (*(p - 1) == ' '))
            {
              if (oldecho)
                {
                  waddstr(win, "\b \b");
                }

              --p;              /* Remove space */
              chars--;
            }
          while ((p > str) && (*(p - 1) != ' '))
            {
              if (oldecho)
                {
                  waddstr(win, "\b \b");
                }

              ch = (unsigned char)(*--p);
              if ((ch < ' ') && (oldecho))
                {
                  waddstr(win, "\b \b");
                }

              chars--;
            }
          break;

        case '\n':
        case '\r':
          stop = true;
          if (oldecho)
            {
              waddch(win, '\n');
            }
          break;

        default:
          if (chars < n)
            {
              if (!SP->key_code && ch < 0x100)
                {
                  *p++ = ch;
                  if (oldecho)
                    {
                      waddch(win, ch);
                    }

                  chars++;
                }
            }
          else
            {
              beep();
            }

          break;

        }

      wrefresh(win);
    }

  *p = '\0';

  SP->echo = oldecho;           /* restore old settings */
  SP->cbreak = oldcbreak;
  win->_nodelay = oldnodelay;

  return OK;
#endif
}

int getstr(char *str)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("getstr() - called\n"));

  return wgetnstr(stdscr, str, MAXLINE);
}

int wgetstr(WINDOW *win, char *str)
{
  PDC_LOG(("wgetstr() - called\n"));

  return wgetnstr(win, str, MAXLINE);
}

int mvgetstr(int y, int x, char *str)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("mvgetstr() - called\n"));

  if (move(y, x) == ERR)
    {
      return ERR;
    }

  return wgetnstr(stdscr, str, MAXLINE);
}

int mvwgetstr(WINDOW *win, int y, int x, char *str)
{
  PDC_LOG(("mvwgetstr() - called\n"));

  if (wmove(win, y, x) == ERR)
    {
      return ERR;
    }

  return wgetnstr(win, str, MAXLINE);
}

int getnstr(char *str, int n)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("getnstr() - called\n"));

  return wgetnstr(stdscr, str, n);
}

int mvgetnstr(int y, int x, char *str, int n)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("mvgetnstr() - called\n"));

  if (move(y, x) == ERR)
    {
      return ERR;
    }

  return wgetnstr(stdscr, str, n);
}

int mvwgetnstr(WINDOW *win, int y, int x, char *str, int n)
{
  PDC_LOG(("mvwgetnstr() - called\n"));

  if (wmove(win, y, x) == ERR)
    {
      return ERR;
    }

  return wgetnstr(win, str, n);
}

#ifdef CONFIG_PDCURSES_WIDE
int wgetn_wstr(WINDOW *win, wint_t *wstr, int n)
{
  int ch;
  int i;
  int num;
  int x;
  int chars;
  char *p;
  bool stop;
  bool oldecho;
  bool oldcbreak;
  bool oldnodelay;
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif

  PDC_LOG(("wgetn_wstr() - called\n"));

  if (!win || !wstr)
    {
      return ERR;
    }

  chars = 0;
  p     = wstr;
  stop  = false;

  x     = win->_curx;

  oldcbreak = SP->cbreak;       /* remember states */
  oldecho = SP->echo;
  oldnodelay = win->_nodelay;

  SP->echo = false;             /* we do echo ourselves */
  cbreak();                     /* ensure each key is returned immediately */
  win->_nodelay = false;        /* don't return -1 */

  wrefresh(win);

  while (!stop)
    {
      ch = wgetch(win);
      switch (ch)
        {
        case '\t':
          ch = ' ';
          num = TABSIZE - (win->_curx - x) % TABSIZE;
          for (i = 0; i < num; i++)
            {
              if (chars < n)
                {
                  if (oldecho)
                    {
                      waddch(win, ch);
                    }

                  *p++ = ch;
                  ++chars;
                }
              else
                {
                  beep();
                }
            }
          break;

        case _ECHAR:           /* CTRL-H -- Delete character */
          if (p > wstr)
            {
              if (oldecho)
                {
                  waddstr(win, "\b \b");
                }

              ch = *--p;
              if ((ch < ' ') && (oldecho))
                {
                  waddstr(win, "\b \b");
                }

              chars--;
            }
          break;

        case _DLCHAR:          /* CTRL-U -- Delete line */
          while (p > wstr)
            {
              if (oldecho)
                {
                  waddstr(win, "\b \b");
                }

              ch = *--p;
              if ((ch < ' ') && (oldecho))
                {
                  waddstr(win, "\b \b");
                }
            }

          chars = 0;
          break;

        case _DWCHAR:          /* CTRL-W -- Delete word */
          while ((p > wstr) && (*(p - 1) == ' '))
            {
              if (oldecho)
                {
                  waddstr(win, "\b \b");
                }

              --p;              /* remove space */
              chars--;
            }

          while ((p > wstr) && (*(p - 1) != ' '))
            {
              if (oldecho)
                {
                  waddstr(win, "\b \b");
                }

              ch = *--p;
              if ((ch < ' ') && (oldecho))
                {
                  waddstr(win, "\b \b");
                }

              chars--;
            }
          break;

        case '\n':
        case '\r':
          stop = true;
          if (oldecho)
            {
              waddch(win, '\n');
            }
          break;

        default:
          if (chars < n)
            {
              if (!SP->key_code)
                {
                  *p++ = ch;
                  if (oldecho)
                    {
                      waddch(win, ch);
                    }

                  chars++;
                }
            }
          else
            {
              beep();
            }

          break;
        }

      wrefresh(win);
    }

  *p = '\0';

  SP->echo = oldecho;           /* restore old settings */
  SP->cbreak = oldcbreak;
  win->_nodelay = oldnodelay;

  return OK;
}

int get_wstr(wint_t *wstr)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("get_wstr() - called\n"));

  return wgetn_wstr(stdscr, wstr, MAXLINE);
}

int wget_wstr(WINDOW *win, wint_t *wstr)
{
  PDC_LOG(("wget_wstr() - called\n"));

  return wgetn_wstr(win, wstr, MAXLINE);
}

int mvget_wstr(int y, int x, wint_t *wstr)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("mvget_wstr() - called\n"));

  if (move(y, x) == ERR)
    {
      return ERR;
    }

  return wgetn_wstr(stdscr, wstr, MAXLINE);
}

int mvwget_wstr(WINDOW *win, int y, int x, wint_t *wstr)
{
  PDC_LOG(("mvwget_wstr() - called\n"));

  if (wmove(win, y, x) == ERR)
    {
      return ERR;
    }

  return wgetn_wstr(win, wstr, MAXLINE);
}

int getn_wstr(wint_t *wstr, int n)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("getn_wstr() - called\n"));

  return wgetn_wstr(stdscr, wstr, n);
}

int mvgetn_wstr(int y, int x, wint_t *wstr, int n)
{
#ifdef CONFIG_PDCURSES_MULTITHREAD
  FAR struct pdc_context_s *ctx = PDC_ctx();
#endif
  PDC_LOG(("mvgetn_wstr() - called\n"));

  if (move(y, x) == ERR)
    {
      return ERR;
    }

  return wgetn_wstr(stdscr, wstr, n);
}

int mvwgetn_wstr(WINDOW *win, int y, int x, wint_t *wstr, int n)
{
  PDC_LOG(("mvwgetn_wstr() - called\n"));

  if (wmove(win, y, x) == ERR)
    {
      return ERR;
    }

  return wgetn_wstr(win, wstr, n);
}
#endif