/*      $NetBSD: field.c,v 1.32 2021/04/13 13:13:03 christos Exp $      */
/*-
 * Copyright (c) 1998-1999 Brett Lymn
 *                         (blymn@baea.com.au, brett_lymn@yahoo.com.au)
 * All rights reserved.
 *
 * This code has been donated to The NetBSD Foundation by the Author.
 *
 * 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. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 *
 *
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: field.c,v 1.32 2021/04/13 13:13:03 christos Exp $");

#include <sys/param.h>
#include <stdlib.h>
#include <strings.h>
#include <stdarg.h>
#include <form.h>
#include "internals.h"

extern FORM _formi_default_form;

FIELD _formi_default_field = {
        0, /* rows in the field */
        0, /* columns in the field */
        0, /* dynamic rows */
        0, /* dynamic columns */
        0, /* maximum growth */
        0, /* starting row in the form subwindow */
        0, /* starting column in the form subwindow */
        0, /* number of off screen rows */
        0, /* index of this field in form fields array. */
        0, /* number of buffers associated with this field */
        FALSE, /* set to true if buffer 0 has changed. */
        NO_JUSTIFICATION, /* justification style of the field */
        FALSE, /* set to true if field is in overlay mode */
        NULL, /* pointer to the current line cursor is on */
        0, /* starting char in string (horiz scroll) */
        NULL, /* starting line in field (vert scroll) */
        0, /* number of rows actually used in field */
        0, /* actual pos of cursor in row, not same as x pos due to tabs */
        0, /* x pos of cursor in field */
        0, /* y pos of cursor in field */
        0, /* start of a new page on the form if 1 */
        0, /* number of the page this field is on */
        A_NORMAL, /* character attributes for the foreground */
        A_NORMAL, /* character attributes for the background */
        ' ', /* padding character */
        DEFAULT_FORM_OPTS, /* options for the field */
        NULL, /* the form this field is bound to, if any */
        NULL, /* field above this one */
        NULL, /* field below this one */
        NULL, /* field to the left of this one */
        NULL, /* field to the right of this one */
        NULL,  /* user defined pointer. */
        NULL, /* used if fields are linked */
        NULL, /* type struct for the field */
        {NULL, NULL}, /* circle queue glue for sorting fields */
        NULL, /* args for field type. */
        NULL, /* pointer to the array of lines structures. */
        NULL, /* list of lines available for reuse */
        NULL, /* array of buffers for the field */
};

/* internal function prototypes */
static int
field_buffer_init(FIELD *field, int buffer, unsigned int len);
static FIELD *
_formi_create_field(FIELD *, int, int, int, int, int, int);

   
/*
 * Set the userptr for the field
 */
int
set_field_userptr(FIELD *field, void *ptr)
{
        FIELD *fp = (field == NULL) ? &_formi_default_field : field;

        fp->userptr = ptr;

        return E_OK;
}

/*
 * Return the userptr for the field.
 */

void *
field_userptr(FIELD *field)
{
        if (field == NULL)
                return _formi_default_field.userptr;
        else
                return field->userptr;
}

/*
 * Set the options for the designated field.
 */
int
set_field_opts(FIELD *field, Form_Options options)
{
        int i;
        
        FIELD *fp = (field == NULL) ? &_formi_default_field : field;

          /* not allowed to set opts if the field is the current one */
        if ((field != NULL) && (field->parent != NULL) &&
            (field->parent->cur_field == field->index))
                return E_CURRENT;
        
        if ((options & O_STATIC) == O_STATIC) {
                for (i = 0; i < fp->nbuf; i++) {
                        if (fp->buffers[i].length > fp->cols)
                                fp->buffers[i].string[fp->cols] = '\0';
                }
        }
        
        fp->opts = options;

          /* if appropriate, redraw the field */
        if ((field != NULL) && (field->parent != NULL)
            && (field->parent->posted == 1)) {
                _formi_redraw_field(field->parent, field->index);
                pos_form_cursor(field->parent);
                wrefresh(field->parent->scrwin);
        }
        
        return E_OK;
}

/*
 * Turn on the passed field options.
 */
int
field_opts_on(FIELD *field, Form_Options options)
{
        int i;
        
        FIELD *fp = (field == NULL) ? &_formi_default_field : field;

          /* not allowed to set opts if the field is the current one */
        if ((field != NULL) && (field->parent != NULL) &&
            (field->parent->cur_field == field->index))
                return E_CURRENT;
        
        if ((options & O_STATIC) == O_STATIC) {
                for (i = 0; i < fp->nbuf; i++) {
                        if (fp->buffers[i].length > fp->cols)
                                fp->buffers[i].string[fp->cols] = '\0';
                }
        }
        
        fp->opts |= options;
        
          /* if appropriate, redraw the field */
        if ((field != NULL) && (field->parent != NULL)
            && (field->parent->posted == 1)) {
                _formi_redraw_field(field->parent, field->index);
                pos_form_cursor(field->parent);
                wrefresh(field->parent->scrwin);
        }

        return E_OK;
}

/*
 * Turn off the passed field options.
 */
int
field_opts_off(FIELD *field, Form_Options options)
{
        FIELD *fp = (field == NULL) ? &_formi_default_field : field;

          /* not allowed to set opts if the field is the current one */
        if ((field != NULL) && (field->parent != NULL) &&
            (field->parent->cur_field == field->index))
                return E_CURRENT;
        
        fp->opts &= ~options;
        
          /* if appropriate, redraw the field */
        if ((field != NULL) && (field->parent != NULL)
            && (field->parent->posted == 1)) {
                _formi_redraw_field(field->parent, field->index);
                pos_form_cursor(field->parent);
                wrefresh(field->parent->scrwin);
        }
        
        return E_OK;
}

/*
 * Return the field options associated with the passed field.
 */
Form_Options
field_opts(FIELD *field)
{
        if (field == NULL)
                return _formi_default_field.opts;
        else
                return field->opts;
}

/*
 * Set the justification for the passed field.
 */
int
set_field_just(FIELD *field, int justification)
{
        FIELD *fp = (field == NULL) ? &_formi_default_field : field;

          /*
           * not allowed to set justification if the field is
           * the current one
           */
        if ((field != NULL) && (field->parent != NULL) &&
            (field->parent->cur_field == field->index))
                return E_CURRENT;
        
        if ((justification < MIN_JUST_STYLE) /* check justification valid */
            || (justification > MAX_JUST_STYLE))
                return E_BAD_ARGUMENT;

          /* only allow justification on static, single row fields */
        if (((fp->opts & O_STATIC) != O_STATIC) ||
            ((fp->rows + fp->nrows) > 1))
                return E_BAD_ARGUMENT;
        
        fp->justification = justification;

        _formi_init_field_xpos(fp);
        
        return E_OK;
}

/*
 * Return the justification style of the field passed.
 */
int
field_just(FIELD *field)
{
        if (field == NULL)
                return _formi_default_field.justification;
        else
                return field->justification;
}

/*
 * Return information about the field passed.
 */
int
field_info(FIELD *field, int *rows, int *cols, int *frow, int *fcol,
           int *nrow, int *nbuf)
{
        if (field == NULL)
                return E_BAD_ARGUMENT;

        *rows = field->rows;
        *cols = field->cols;
        *frow = field->form_row;
        *fcol = field->form_col;
        *nrow = field->nrows;
        *nbuf = field->nbuf;

        return E_OK;
}

/*
 * Report the dynamic field information.
 */
int
dynamic_field_info(FIELD *field, int *drows, int *dcols, int *max)
{
        if (field == NULL)
                return E_BAD_ARGUMENT;

        if ((field->opts & O_STATIC) == O_STATIC) {
                *drows = field->rows;
                *dcols = field->cols;
        } else {
                *drows = field->drows;
                *dcols = field->dcols;
        }
        
        *max = field->max;

        return E_OK;
}

/*
 * Init all the field variables, perform wrapping and other tasks
 * after the field buffer is set.
 */
static int
field_buffer_init(FIELD *field, int buffer, unsigned int len)
{
        int status;
        char *newp;
        
        if (buffer == 0) {
                field->start_char = 0;
                field->start_line = 0;
                field->row_xpos = 0;
                field->cursor_xpos = 0;
                field->cursor_ypos = 0;
                field->row_count = 1; /* must be at least one row  XXX need to shift old rows (if any) to free list??? */
                field->alines->length = len;
                if ((newp = realloc(field->alines->string,
                                    (size_t) len + 1)) == NULL)
                        return E_SYSTEM_ERROR;
                field->alines->string = newp;
                field->alines->allocated = len + 1;
                strlcpy(field->alines->string, field->buffers[buffer].string,
                        (size_t) len + 1);
                field->alines->expanded =
                        _formi_tab_expanded_length(field->alines->string,
                                                   0, field->alines->length);

                field->start_line = field->alines;
                field->cur_line = field->alines;
                
                  /* we have to hope the wrap works - if it does not then the
                     buffer is pretty much borked */
                status = _formi_wrap_field(field, field->cur_line);
                if (status != E_OK)
                        return status;

                  /*
                   * calculate the tabs for a single row field, the
                   * multiline case is handled when the wrap is done.
                   */
                if (field->row_count == 1)
                        _formi_calculate_tabs(field->alines);

                  /* redraw the field to reflect the new contents. If the field
                   * is attached....
                   */
                if ((field->parent != NULL) && (field->parent->posted == 1)) {
                        _formi_redraw_field(field->parent, field->index);
                          /* make sure cursor goes back to current field */
                        pos_form_cursor(field->parent);
                }
        }

        return E_OK;
}


/*
 * Set the field buffer to the string that results from processing
 * the given format (fmt) using sprintf.
 */
int
set_field_printf(FIELD *field, int buffer, char *fmt, ...)
{
        int len;
        va_list args;
        
        if (field == NULL)
                return E_BAD_ARGUMENT;

        if (buffer >= field->nbuf)
                return E_BAD_ARGUMENT;

        va_start(args, fmt);
          /* check for buffer already existing, free the storage */
        if (field->buffers[buffer].allocated != 0)
                free(field->buffers[buffer].string);

        len = vasprintf(&field->buffers[buffer].string, fmt, args);
        va_end(args);
        if (len < 0)
                return E_SYSTEM_ERROR;
        
        field->buffers[buffer].length = len;
        field->buffers[buffer].allocated = len + 1;
        if (((field->opts & O_STATIC) == O_STATIC) && (len > field->cols)
            && ((field->rows + field->nrows) == 1))
                len = field->cols;

        field->buffers[buffer].string[len] = '\0';
        return field_buffer_init(field, buffer, (unsigned int) len);
}
        
/*
 * Set the value of the field buffer to the value given.
 */

int
set_field_buffer(FIELD *field, int buffer, const char *value)
{
        unsigned int len;
        int status;
        
        if (field == NULL)
                return E_BAD_ARGUMENT;

        if (buffer >= field->nbuf) /* make sure buffer is valid */
                return E_BAD_ARGUMENT;

        len = (unsigned int) strlen(value);
        if (((field->opts & O_STATIC) == O_STATIC) && (len > field->cols)
            && ((field->rows + field->nrows) == 1))
                len = field->cols;

        _formi_dbg_printf( "%s: len = %d, value = %s, buffer=%d\n", __func__,
            len, value, buffer);
        if (field->buffers[buffer].string != NULL)
                _formi_dbg_printf("%s: string=%s, len = %d\n", __func__,
                    field->buffers[buffer].string,
                    field->buffers[buffer].length);
        else
                _formi_dbg_printf("%s: string=(null), len = 0\n", __func__);
        _formi_dbg_printf("%s: lines.len = %d\n", __func__,
            field->alines[0].length);
        
        if ((field->buffers[buffer].string = realloc(
            field->buffers[buffer].string, (size_t) len + 1)) == NULL)
                return E_SYSTEM_ERROR;

        strlcpy(field->buffers[buffer].string, value, (size_t) len + 1);
        field->buffers[buffer].length = len;
        field->buffers[buffer].allocated = len + 1;
        status = field_buffer_init(field, buffer, len);

        _formi_dbg_printf("%s: len = %d, value = %s\n", __func__, len, value);
        _formi_dbg_printf("%s: string = %s, len = %d\n", __func__,
            field->buffers[buffer].string, field->buffers[buffer].length);
        _formi_dbg_printf("%s: lines.len = %d\n", __func__,
                field->alines[0].length);

        return status;
}

/*
 * Return the requested field buffer to the caller.
 */
char *
field_buffer(FIELD *field, int buffer)
{

        char *reformat, *p;
        _FORMI_FIELD_LINES *linep;
        size_t bufsize, pos;
        
        if (field == NULL)
                return NULL;

        if (buffer >= field->nbuf)
                return NULL;

          /*
           * We force a sync from the line structs to the buffer here.
           * Traditional libform say we don't need to because it is
           * done on a REQ_VALIDATE but NetBSD libform previously did
           * not enforce this because the buffer contents were always
           * current.  Changes to line handling make this no longer so
           * - the line structs may contain different data to the
           * buffer if unsynced.
           */
        if (_formi_sync_buffer(field) != E_OK)
                return NULL;
        
        if ((field->opts & O_REFORMAT) != O_REFORMAT)
                return field->buffers[buffer].string;

        if (field->row_count <= 1)
                return strdup(field->buffers[buffer].string);

        /*
         * create a single string containing each line,
         * separated by newline, last line having no
         * newline, but NUL terminated.
         */
        bufsize = pos = 0;
        reformat = NULL;
        for (linep = field->alines; linep; linep = linep->next) {
                size_t len = strlen(linep->string);
                if (len + 1 >= bufsize - pos) {
                        bufsize += MAX(1024, 2 * len);
                        p = realloc(reformat, bufsize);
                        if (p == NULL) {
                                free(reformat);
                                return NULL;
                        }
                        reformat = p;
                }
                memcpy(reformat + pos, linep->string, len);
                pos += len;
                reformat[pos++] = linep->next ? '\n' : '\0';
        }
        return reformat;
}

/*
 * Set the buffer 0 field status.
 */
int
set_field_status(FIELD *field, int status)
{

        if (field == NULL)
                return E_BAD_ARGUMENT;

        if (status != FALSE)
                field->buf0_status = TRUE;
        else
                field->buf0_status = FALSE;

        return E_OK;
}

/*
 * Return the buffer 0 status flag for the given field.
 */
int
field_status(FIELD *field)
{

        if (field == NULL) /* the default buffer 0 never changes :-) */
                return FALSE;

        return field->buf0_status;
}

/*
 * Set the maximum growth for a dynamic field.
 */
int
set_max_field(FIELD *fptr, int max)
{
        FIELD *field = (fptr == NULL)? &_formi_default_field : fptr;

        if ((field->opts & O_STATIC) == O_STATIC) /* check if field dynamic */
                return E_BAD_ARGUMENT;

        if (max < 0) /* negative numbers are bad.... */
                return E_BAD_ARGUMENT;
        
        field->max = max;
        return E_OK;
}

/*
 * Set the field foreground character attributes.
 */
int
set_field_fore(FIELD *fptr, chtype attribute)
{
        FIELD *field = (fptr == NULL)? &_formi_default_field : fptr;

        field->fore = attribute;
        return E_OK;
}

/*
 * Return the foreground character attribute for the given field.
 */
chtype
field_fore(FIELD *field)
{
        if (field == NULL)
                return _formi_default_field.fore;
        else
                return field->fore;
}

/*
 * Set the background character attribute for the given field.
 */
int
set_field_back(FIELD *field, chtype attribute)
{
        if (field == NULL)
                _formi_default_field.back = attribute;
        else
                field->back = attribute;

        return E_OK;
}

/*
 * Get the background character attribute for the given field.
 */
chtype
field_back(FIELD *field)
{
        if (field == NULL)
                return _formi_default_field.back;
        else
                return field->back;
}

/*
 * Set the pad character for the given field.
 */
int
set_field_pad(FIELD *field, int pad)
{
        if (field == NULL)
                _formi_default_field.pad = pad;
        else
                field->pad = pad;

        return E_OK;
}

/*
 * Return the padding character for the given field.
 */
int
field_pad(FIELD *field)
{
        if (field == NULL)
                return _formi_default_field.pad;
        else
                return field->pad;
}

/*
 * Set the field initialisation function hook.
 */
int
set_field_init(FORM *form, Form_Hook function)
{
        if (form == NULL)
                _formi_default_form.field_init = function;
        else
                form->field_init = function;

        return E_OK;
}

/*
 * Return the function hook for the field initialisation.
 */
Form_Hook
field_init(FORM *form)
{
        if (form == NULL)
                return _formi_default_form.field_init;
        else
                return form->field_init;
}

/*
 * Set the field termination function hook.
 */
int
set_field_term(FORM *form, Form_Hook function)
{
        if (form == NULL)
                _formi_default_form.field_term = function;
        else
                form->field_term = function;

        return E_OK;
}

/*
 * Return the function hook defined for the field termination.
 */
Form_Hook
field_term(FORM *form)
{
        if (form == NULL)
                return _formi_default_form.field_term;
        else
                return form->field_term;
}

/*
 * Set the page flag on the given field to indicate it is the start of a
 * new page.
 */
int
set_new_page(FIELD *fptr, int page)
{
        FIELD *field = (fptr == NULL)? &_formi_default_field : fptr;

        if (field->parent != NULL) /* check if field is connected to a form */
                return E_CONNECTED;
        
        field->page_break = (page != FALSE);
        return E_OK;
}

/*
 * Return the page status for the given field.  TRUE is returned if the
 * field is the start of a new page.
 */
int
new_page(FIELD *field)
{
        if (field == NULL)
                return _formi_default_field.page_break;
        else
                return field->page_break;
}

/*
 * Return the index of the field in the form fields array.
 */
int
field_index(FIELD *field)
{
        if (field == NULL)
                return E_BAD_ARGUMENT;

        if (field->parent == NULL)
                return E_NOT_CONNECTED;

        return field->index;
}

/*
 * Internal function that does most of the work to create a new field.
 * The new field is initialised from the information in the prototype
 * field passed.
 * Returns NULL on error.
 */
static FIELD *
_formi_create_field(FIELD *prototype, int rows, int cols, int frow,
                    int fcol, int nrows, int nbuf)
{
        FIELD *new;
        
        if ((rows <= 0) || (cols <= 0) || (frow < 0) || (fcol < 0) ||
            (nrows < 0) || (nbuf < 0))
                return NULL;
        
        if ((new = malloc(sizeof(*new))) == NULL) {
                return NULL;
        }

          /* copy in the default field info */
        memcpy(new, prototype, sizeof(*new));

        new->nbuf = nbuf + 1;
        new->rows = rows;
        new->cols = cols;
        new->form_row = frow;
        new->form_col = fcol;
        new->nrows = nrows;
        new->link = new;
        return new;
}

/*
 * Create a new field structure.
 */
FIELD *
new_field(int rows, int cols, int frow, int fcol, int nrows, int nbuf)
{
        FIELD *new;
        int i;
        

        if ((new = _formi_create_field(&_formi_default_field, rows, cols,
                                       frow, fcol, nrows, nbuf)) == NULL)
                return NULL;
        
        if ((new->buffers = calloc(nbuf + 1, sizeof(*new->buffers))) == NULL) {
                free(new);
                return NULL;
        }

        /* Initialise the strings to a zero length string */
        for (i = 0; i < nbuf + 1; i++) {
                if ((new->buffers[i].string =
                    malloc(sizeof(*new->buffers[i].string))) == NULL) {
                        goto out;
                }
                new->buffers[i].string[0] = '\0';
                new->buffers[i].length = 0;
                new->buffers[i].allocated = 1;
        }

        if ((new->alines = malloc(sizeof(*new->alines))) == NULL) {
                goto out;
        }

        new->alines->prev = NULL;
        new->alines->next = NULL;
        new->alines->allocated = 0;
        new->alines->length = 0;
        new->alines->expanded = 0;
        new->alines->string = NULL;
        new->alines->hard_ret = FALSE;
        new->alines->tabs = NULL;
        new->start_line = new->alines;
        new->cur_line = new->alines;
        
        return new;
out:
        while (--i >= 0) {
                free(new->buffers[i].string);
        }
        free(new->buffers);
        free(new);
        return NULL;
}

/*
 * Duplicate the given field, including its buffers.
 */
FIELD *
dup_field(FIELD *field, int frow, int fcol)
{
        FIELD *new;
        size_t row_len, buf_len;
        
        if (field == NULL)
                return NULL;

        /* XXX: this right???? */
        if ((new = _formi_create_field(field, (int) field->rows,
                                       (int) field->cols,
                                       frow, fcol, (int) field->nrows,
                                       field->nbuf - 1)) == NULL)
                return NULL;

        row_len = (field->rows + field->nrows + 1) * field->cols;
        buf_len = (field->nbuf + 1) * row_len * sizeof(*new->buffers);
        
        /* XXX: dups buffers but not their strings? */
        if ((new->buffers = malloc(buf_len)) == NULL) {
                free(new);
                return NULL;
        }

          /* copy the buffers from the source field into the new copy */
        memcpy(new->buffers, field->buffers, buf_len);

        return new;
}

/*
 * Create a new field at the specified location by duplicating the given
 * field.  The buffers are shared with the parent field.
 */
FIELD *
link_field(FIELD *field, int frow, int fcol)
{
        FIELD *new;

        if (field == NULL)
                return NULL;
        
        if ((new = _formi_create_field(field, (int) field->rows,
                                       (int) field->cols,
                                       frow, fcol, (int) field->nrows,
                                       field->nbuf - 1)) == NULL)
                return NULL;

        new->link = field->link;
        field->link = new;
        
          /* we are done.  The buffer pointer was copied during the field
             creation. */
        return new;
}

/*
 * Release all storage allocated to the field
 */
int
free_field(FIELD *field)
{
        FIELD *flink;
        unsigned int i;
        _formi_tab_t *ts, *nts;
        
        if (field == NULL)
                return E_BAD_ARGUMENT;

        if (field->parent != NULL)
                return E_CONNECTED;

        if (field->link == field) { /* check if field linked */
                  /* no it is not - release the buffers */
                free(field->buffers);
                  /* free the tab structures */
                for (i = 0; i + 1 < field->row_count; i++) {
                        if (field->alines[i].tabs != NULL) {
                                ts = field->alines[i].tabs;
                                while (ts != NULL) {
                                        nts = ts->fwd;
                                        free(ts);
                                        ts = nts;
                                }
                        }
                }
        } else {
                  /* is linked, traverse the links to find the field referring
                   * to the one to be freed.
                   */
                for (flink = field->link; flink != field; flink = flink->link);
                flink->link = field->link;
        }

        free(field);
        return E_OK;
}