/*
 *
 * Usage:
 *	  procname getcursor
 */
HIDDEN int
fbo_getcursor_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv)
{
    struct fb_obj *fbop = (struct fb_obj *)clientData;
    int status;
    int mode;
    int x, y;
    struct bu_vls vls;

    if (argc != 2) {
	bu_vls_init(&vls);
	bu_vls_printf(&vls, "helplib fb_getcursor");
	Tcl_Eval(interp, bu_vls_addr(&vls));
	bu_vls_free(&vls);
	return TCL_ERROR;
    }

    status = fb_getcursor(fbop->fbo_fbs.fbs_fbp, &mode, &x, &y);
    if (status == 0) {
	bu_vls_init(&vls);
	bu_vls_printf(&vls, "%d %d %d", mode, x, y);
	Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
	bu_vls_free(&vls);

	return TCL_OK;
    }

    return TCL_ERROR;
}

static void
_bu_close_files()
{
    struct _bu_tf_list *popped;
    if (!_bu_tf) {
	return;
    }

    /* close all files, free their nodes, and unlink */
    while (BU_LIST_WHILE(popped, _bu_tf_list, &(_bu_tf->l))) {
	BU_LIST_DEQUEUE(&(popped->l));
	if (popped) {
	    if (popped->fd != -1) {
		close(popped->fd);
		popped->fd = -1;
	    }
	    if (BU_VLS_IS_INITIALIZED(&popped->fn) && bu_vls_addr(&popped->fn)) {
		unlink(bu_vls_addr(&popped->fn));
		bu_vls_free(&popped->fn);
	    }
	    bu_free(popped, "free bu_temp_file node");
	}
    }

    /* free the head */
    if (_bu_tf->fd != -1) {
	close(_bu_tf->fd);
	_bu_tf->fd = -1;
    }
    if (BU_VLS_IS_INITIALIZED(&_bu_tf->fn) && bu_vls_addr(&_bu_tf->fn)) {
	unlink(bu_vls_addr(&_bu_tf->fn));
	bu_vls_free(&_bu_tf->fn);
    }
    bu_free(_bu_tf, "free bu_temp_file head");
}

struct bu_mapped_file *
bu_open_mapped_file_with_path(char *const *path, const char *name, const char *appl)

/* file name */
/* non-null only when app. will use 'apbuf' */
{
    char * const *pathp = path;
    struct bu_vls str = BU_VLS_INIT_ZERO;
    struct bu_mapped_file *ret;

    BU_ASSERT_PTR(name, !=, NULL);
    BU_ASSERT_PTR(pathp, !=, NULL);

    /* Do not resort to path for a rooted filename */
    if (name[0] == '/')
	return bu_open_mapped_file(name, appl);

    /* Try each path prefix in sequence */
    for (; *pathp != NULL; pathp++) {
	bu_vls_strcpy(&str, *pathp);
	bu_vls_putc(&str, '/');
	bu_vls_strcat(&str, name);

	ret = bu_open_mapped_file(bu_vls_addr(&str), appl);
	if (ret) {
	    bu_vls_free(&str);
	    return ret;
	}
    }

    /* Failure, none of the opens succeeded */
    bu_vls_free(&str);
    return (struct bu_mapped_file *)NULL;
}

HIDDEN void
cho_deleteProc(ClientData clientData)
{
    struct bu_cmdhist_obj *chop = (struct bu_cmdhist_obj *)clientData;
    struct bu_cmdhist *curr, *next;

    /* free list of commands */
    curr = BU_LIST_NEXT(bu_cmdhist, &chop->cho_head.l);
    while (BU_LIST_NOT_HEAD(curr, &chop->cho_head.l)) {
	curr = BU_LIST_NEXT(bu_cmdhist, &chop->cho_head.l);
	next = BU_LIST_PNEXT(bu_cmdhist, curr);

	bu_vls_free(&curr->h_command);

	BU_LIST_DEQUEUE(&curr->l);
	bu_free((genptr_t)curr, "cho_deleteProc: curr");
	curr = next;
    }

    bu_vls_free(&chop->cho_name);
    bu_vls_free(&chop->cho_head.h_command);

    BU_LIST_DEQUEUE(&chop->l);
    BU_PUT(chop, struct bu_cmdhist_obj);
}

static int
X_dm(int	argc,
     char	*argv[])
{
    if (!strcmp(argv[0], "set")) {
	struct bu_vls	vls;

	bu_vls_init(&vls);

	if (argc < 2) {
	    /* Bare set command, print out current settings */
	    bu_vls_struct_print2(&vls, "dm_X internal variables", X_vparse, (const char *)dmp );
	} else if (argc == 2) {
	    bu_vls_struct_item_named(&vls, X_vparse, argv[1], (const char *)dmp, ',');
	} else {
	    struct bu_vls tmp_vls;

	    bu_vls_init(&tmp_vls);
	    bu_vls_printf(&tmp_vls, "%s=\"", argv[1]);
	    bu_vls_from_argv(&tmp_vls, argc-2, (const char **)argv+2);
	    bu_vls_putc(&tmp_vls, '\"');
	    bu_struct_parse(&tmp_vls, X_vparse, (char *)dmp);
	    bu_vls_free(&tmp_vls);
	}

	Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
	bu_vls_free(&vls);

	return TCL_OK;
    }

    return common_dm(argc, argv);
}

/**
 * compares an input units string to a reference units name and
 * returns truthfully if they match.  the comparison ignores any
 * embedded whitespace and is case insensitive.
 */
static int
units_name_matches(const char *input, const char *name)
{
    const char *cp;
    int match;
    struct bu_vls normalized_input = BU_VLS_INIT_ZERO;
    struct bu_vls normalized_name = BU_VLS_INIT_ZERO;

    /* convert NULL */
    if (!input)
	input = "";
    if (!name)
	name = "";

    /* skip spaces */
    while (isspace((unsigned char)*input))
	input++;
    while (isspace((unsigned char)*name))
	name++;

    /* quick exit */
    if (tolower((unsigned char)input[0]) != tolower((unsigned char)name[0]))
	return 0;

    cp = input;
    /* skip spaces, convert to lowercase */
    while (*cp != '\0') {
	if (!isspace((unsigned char)*cp))
	    bu_vls_putc(&normalized_input, tolower((unsigned char)*cp));
	cp++;
    }

    cp = name;
    /* skip spaces, convert to lowercase */
    while (*cp != '\0') {
	if (!isspace((unsigned char)*cp))
	    bu_vls_putc(&normalized_name, tolower((unsigned char)*cp));
	cp++;
    }

    /* trim any trailing 's' for plurality */
    if (bu_vls_addr(&normalized_input)[bu_vls_strlen(&normalized_input)-1] == 's') {
	bu_vls_trunc(&normalized_input, -1);
    }
    if (bu_vls_addr(&normalized_name)[bu_vls_strlen(&normalized_name)-1] == 's') {
	bu_vls_trunc(&normalized_name, -1);
    }

    /* compare */
    match = BU_STR_EQUAL(bu_vls_addr(&normalized_input), bu_vls_addr(&normalized_name));

    bu_vls_free(&normalized_input);
    bu_vls_free(&normalized_name);

    return match;
}

/**
 * Checks for the existence of a specified object.
 */
int
ged_exists(struct ged *gedp, int argc, const char *argv_orig[])
{
    /* struct directory *dp;*/
    static const char *usage = "object";
    struct exists_data ed;
    struct bu_vls message = BU_VLS_INIT_ZERO;
    int result;
    char **argv = bu_dup_argv(argc, argv_orig);

    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);
    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);

    /* initialize result */
    bu_vls_trunc(gedp->ged_result_str, 0);

    /* must be wanting help */
    if (argc == 1) {
        bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage);
        return GED_HELP;
    }
    /*
      if (argc != 2) {
      bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage);
      return GED_ERROR;
      }
    */

    ed.t_wp = &argv[1];
    ed.gedp = gedp;
    ed.t_wp_op = NULL;
    ed.message = &message;
    result = oexpr(t_lex(*(ed.t_wp), &ed), &ed);

    if (result)
        bu_vls_printf(gedp->ged_result_str, "1");
    else
        bu_vls_printf(gedp->ged_result_str, "0");

    if (bu_vls_strlen(ed.message) > 0) {
        bu_vls_printf(gedp->ged_result_str, "%s", bu_vls_addr(ed.message));
        bu_vls_free(&message);
        return GED_ERROR;
    }

    bu_vls_free(&message);
    if (*(ed.t_wp) != NULL && *++(ed.t_wp) != NULL) {
        return GED_ERROR;
    } else {
        return GED_OK;
    }
}

/*
 * Listen for framebuffer clients.
 *
 * Usage:
 *	  procname listen port
 *
 * Returns the port number actually used.
 *
 */
HIDDEN int
fbo_listen_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv)
{
    struct fb_obj *fbop = (struct fb_obj *)clientData;
    struct bu_vls vls;

    bu_vls_init(&vls);

    if (fbop->fbo_fbs.fbs_fbp == FBIO_NULL) {
	bu_vls_printf(&vls, "%s listen: framebuffer not open!\n", argv[0]);
	Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
	bu_vls_free(&vls);

	return TCL_ERROR;
    }

    /* return the port number */
    if (argc == 2) {
	bu_vls_printf(&vls, "%d", fbop->fbo_fbs.fbs_listener.fbsl_port);
	Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
	bu_vls_free(&vls);

	return TCL_OK;
    }

    if (argc == 3) {
	int port;

	if (sscanf(argv[2], "%d", &port) != 1) {
	    Tcl_AppendResult(interp, "listen: bad value - ", argv[2], "\n", (char *)NULL);
	    return TCL_ERROR;
	}

	if (port >= 0)
	    fbs_open(interp, &fbop->fbo_fbs, port);
	else {
	    fbs_close(interp, &fbop->fbo_fbs);
	}
	bu_vls_printf(&vls, "%d", fbop->fbo_fbs.fbs_listener.fbsl_port);
	Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL);
	bu_vls_free(&vls);

	return TCL_OK;
    }

    bu_vls_printf(&vls, "helplib fb_listen");
    Tcl_Eval(interp, bu_vls_addr(&vls));
    bu_vls_free(&vls);

    return TCL_ERROR;
}

int
bu_cmdhist_add(void *clientData, int argc, const char **argv)
{
    struct bu_cmdhist_obj *chop = (struct bu_cmdhist_obj *)clientData;
    struct bu_vls vls = BU_VLS_INIT_ZERO;
    struct timeval zero;

    if (argc != 3) {
	bu_log("ERROR: expecting only three arguments\n");
	return BRLCAD_ERROR;
    }

    if (UNLIKELY(argv[2][0] == '\n' || argv[2][0] == '\0'))
	return BRLCAD_OK;

    bu_vls_strcpy(&vls, argv[2]);
    if (argv[2][strlen(argv[2])-1] != '\n')
	bu_vls_putc(&vls, '\n');

    zero.tv_sec = zero.tv_usec = 0L;
    cmdhist_record(chop, &vls, &zero, &zero, BRLCAD_OK);

    bu_vls_free(&vls);

    /* newly added command is in chop->cho_curr */
    return BRLCAD_OK;
}

/**
 * P L O T _ L O A D M A T R I X
 *
 * Load a new transformation matrix.  This will be followed by
 * many calls to plot_draw().
 */
HIDDEN int
plot_loadMatrix(struct dm *dmp, fastf_t *mat, int which_eye)
{
    Tcl_Obj *obj;

    if (!dmp)
	return TCL_ERROR;

    obj = Tcl_GetObjResult(dmp->dm_interp);
    if (Tcl_IsShared(obj))
	obj = Tcl_DuplicateObj(obj);

    if (((struct plot_vars *)dmp->dm_vars.priv_vars)->debug) {
	struct bu_vls tmp_vls = BU_VLS_INIT_ZERO;

	Tcl_AppendStringsToObj(obj, "plot_loadMatrix()\n", (char *)NULL);

	bu_vls_printf(&tmp_vls, "which eye = %d\t", which_eye);
	bu_vls_printf(&tmp_vls, "transformation matrix = \n");
	bu_vls_printf(&tmp_vls, "%g %g %g %g\n", mat[0], mat[4], mat[8], mat[12]);
	bu_vls_printf(&tmp_vls, "%g %g %g %g\n", mat[1], mat[5], mat[9], mat[13]);
	bu_vls_printf(&tmp_vls, "%g %g %g %g\n", mat[2], mat[6], mat[10], mat[14]);
	bu_vls_printf(&tmp_vls, "%g %g %g %g\n", mat[3], mat[7], mat[11], mat[15]);

	Tcl_AppendStringsToObj(obj, bu_vls_addr(&tmp_vls), (char *)NULL);
	bu_vls_free(&tmp_vls);
    }

    MAT_COPY(plotmat, mat);
    Tcl_SetObjResult(dmp->dm_interp, obj);
    return TCL_OK;
}

void
rt_pr_partitions(const struct rt_i *rtip, register const struct partition *phead, const char *title)
{
    register const struct partition *pp;
    struct bu_vls v = BU_VLS_INIT_ZERO;

    RT_CHECK_RTI(rtip);

    bu_log_indent_vls(&v);
    bu_vls_strcat(&v, "------");
    bu_vls_strcat(&v, title);
    bu_vls_strcat(&v, "\n");
    bu_log_indent_delta(2);

    for (pp = phead->pt_forw; pp != phead; pp = pp->pt_forw) {
	RT_CHECK_PT(pp);
	rt_pr_pt_vls(&v, rtip, pp);
    }
    bu_log_indent_delta(-2);
    bu_log_indent_vls(&v);
    bu_vls_strcat(&v, "------\n");

    bu_log("%s", bu_vls_addr(&v));
    bu_vls_free(&v);
}

int
Wgl_dm_init(struct dm_list	*o_dm_list,
	    int			argc,
	    char		*argv[])
{
    struct bu_vls vls;

    dm_var_init(o_dm_list);

    /* register application provided routines */
    cmd_hook = Wgl_dm;

    Tk_DeleteGenericHandler(doEvent, (ClientData)NULL);

    if ((dmp = dm_open(interp, DM_TYPE_WGL, argc-1, argv)) == DM_NULL)
	return TCL_ERROR;

    /*XXXX this eventually needs to move into Wgl's private structure */
    dmp->dm_vp = &view_state->vs_vop->vo_scale;
    dmp->dm_perspective = mged_variables->mv_perspective_mode;

    eventHandler = Wgl_doevent;
    Tk_CreateGenericHandler(doEvent, (ClientData)NULL);
    (void)DM_CONFIGURE_WIN(dmp);

    bu_vls_init(&vls);
    bu_vls_printf(&vls, "mged_bind_dm %s", bu_vls_addr(&pathName));
    Tcl_Eval(interp, bu_vls_addr(&vls));
    bu_vls_free(&vls);

    return TCL_OK;
}

/*
 *
 * Get editing string and call ged_red
 */
int
f_red(ClientData UNUSED(clientData), Tcl_Interp *interpreter, int argc, const char *argv[])
{
    const char **av;
    struct bu_vls editstring = BU_VLS_INIT_ZERO;

    CHECK_DBI_NULL;

    if (argc != 2) {
	Tcl_Eval(interpreter, "help red");
	return TCL_ERROR;
    }

    get_editor_string(&editstring);

    av = (const char **)bu_calloc(4, sizeof(char *), "f_red: av");

    av[0] = argv[0];
    av[1] = "-E";
    av[2] = bu_vls_addr(&editstring);
    av[3] = argv[1];

    if ( ged_red(gedp, 4, (const char **)av) == GED_ERROR ) {
	Tcl_AppendResult(interpreter, "Error: ", bu_vls_addr(gedp->ged_result_str), (char *)NULL);
    } else {
	Tcl_AppendResult(interpreter, bu_vls_addr(gedp->ged_result_str), (char *)NULL);
    }

    bu_vls_free(&editstring);
    bu_free((void *)av, "f_red: av");
    return TCL_OK;
}

void
rt_pr_region(register const struct region *rp)
{
    struct bu_vls v = BU_VLS_INIT_ZERO;

    RT_CK_REGION(rp);

    bu_log("REGION %s (bit %d)\n", rp->reg_name, rp->reg_bit);
    bu_log("instnum=%ld, id=%d, air=%d, gift_material=%d, los=%d\n",
	   rp->reg_instnum,
	   rp->reg_regionid, rp->reg_aircode,
	   rp->reg_gmater, rp->reg_los);
    if (rp->reg_is_fastgen != REGION_NON_FASTGEN) {
	bu_log("reg_is_fastgen = %s mode\n",
	       rp->reg_is_fastgen == REGION_FASTGEN_PLATE ?
	       "plate" : "volume");
    }
    if (rp->reg_mater.ma_color_valid)
	bu_log("Color %d %d %d\n",
	       (int)rp->reg_mater.ma_color[0]*255,
	       (int)rp->reg_mater.ma_color[1]*255,
	       (int)rp->reg_mater.ma_color[2]*255);
    if (rp->reg_mater.ma_temperature > 0)
	bu_log("Temperature %g degrees K\n", INTCLAMP(rp->reg_mater.ma_temperature));
    if (rp->reg_mater.ma_shader && rp->reg_mater.ma_shader[0] != '\0')
	bu_log("Shader '%s'\n", rp->reg_mater.ma_shader);

    rt_pr_tree_vls(&v, rp->reg_treetop);
    bu_log("%s %ld %s\n", rp->reg_name,
	   rp->reg_instnum, bu_vls_addr(&v));
    bu_vls_free(&v);
}

int
X_dm_init(struct dm_list	*o_dm_list,
	  int			argc,
	  char			*argv[])
{
    struct bu_vls vls;

    dm_var_init(o_dm_list);

    /* register application provided routines */
    cmd_hook = X_dm;

    Tk_DeleteGenericHandler(doEvent, (ClientData)NULL);
    if ((dmp = dm_open(interp, DM_TYPE_X, argc-1, argv)) == DM_NULL)
	return TCL_ERROR;

    /* keep display manager in sync */
    dmp->dm_perspective = mged_variables->mv_perspective_mode;

    eventHandler = X_doevent;
    Tk_CreateGenericHandler(doEvent, (ClientData)NULL);
    (void)DM_CONFIGURE_WIN(dmp);

    bu_vls_init(&vls);
    bu_vls_printf(&vls, "mged_bind_dm %s", bu_vls_addr(&pathName));
    Tcl_Eval(interp, bu_vls_addr(&vls));
    bu_vls_free(&vls);

    return TCL_OK;
}

static int
list_geometry(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const *objv)
{
    static struct db_i *dbip;
    struct directory *dp;
    int i;
    struct bu_vls tclstr = BU_VLS_INIT_ZERO;

    if (objc < 3) {
	Tcl_WrongNumArgs(interp, 1, objv, "file varname");
	return TCL_ERROR;
    }

    if ((dbip = db_open(Tcl_GetString(objv[1]), "r")) == DBI_NULL) {
	bu_log("Unable to open geometry file (%s)\n", Tcl_GetString(objv[1]));
	return TCL_ERROR;
    }
    db_dirbuild(dbip);
    for (i = 0; i < RT_DBNHASH; i++) {
	for (dp = dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) {
	    if (dp->d_flags & RT_DIR_HIDDEN) continue;
	    bu_vls_sprintf(&tclstr, "set %s [concat $%s [list %s]]", Tcl_GetString(objv[2]), Tcl_GetString(objv[2]), dp->d_namep);
	    Tcl_Eval(interp, bu_vls_addr(&tclstr));
	}
    }
    db_close(dbip);
    bu_vls_free(&tclstr);
    return TCL_OK;
}

HIDDEN int
dm_bestXType_tcl(void *clientData, int argc, const char **argv)
{
    Tcl_Interp *interp = (Tcl_Interp *)clientData;
    Tcl_Obj *obj;
    const char *best_dm;
    char buffer[256] = {0};

    if (argc != 2) {
	struct bu_vls vls = BU_VLS_INIT_ZERO;

	bu_vls_printf(&vls, "helplib dm_bestXType");
	Tcl_Eval(interp, bu_vls_addr(&vls));
	bu_vls_free(&vls);
	return TCL_ERROR;
    }

    obj = Tcl_GetObjResult(interp);
    if (Tcl_IsShared(obj))
	obj = Tcl_DuplicateObj(obj);
    snprintf(buffer, 256, "%s", argv[1]);
    best_dm = dm_bestXType(buffer);
    if (best_dm) {
	Tcl_AppendStringsToObj(obj, best_dm, (char *)NULL);
	Tcl_SetObjResult(interp, obj);
	return TCL_OK;
    }
    return TCL_ERROR;
}

int
compare_tcl_combs(Tcl_Obj *obj1, struct directory *dp1, Tcl_Obj *obj2)
{
    int junk;
    struct bu_vls adjust = BU_VLS_INIT_ZERO;
    int different = 0;

    /* first check if there is any difference */
    if (BU_STR_EQUAL(Tcl_GetStringFromObj(obj1, &junk), Tcl_GetStringFromObj(obj2, &junk)))
	return 0;

    if (mode != HUMAN) {
	bu_vls_printf(&adjust, "db adjust %s", dp1->d_namep);
    }

    different = do_compare(PARAMS, &adjust, obj1, obj2, dp1->d_namep);

    if (mode != HUMAN) {
	printf("%s\n", bu_vls_addr(&adjust));
    }

    bu_vls_free(&adjust);

    return different;
}

/*
 * Validate points data file unit string and output conversion factor
 * to millimeters. If string is not a standard units identifier, the
 * function assumes a custom conversion factor was specified. A valid
 * null terminated string is expected as input. The function returns
 * GED_ERROR if the unit string is invalid or if null pointers were
 * passed to the function.
 */
int
str2mm(const char *units_string, double *conv_factor, struct bu_vls *ged_result_str)
{
    struct bu_vls str = BU_VLS_INIT_ZERO;
    double tmp_value = 0.0;
    char *endp = (char *)NULL;
    int ret = GED_OK;

    if ((units_string == (char *)NULL) || (conv_factor == (double *)NULL)) {
        bu_vls_printf(ged_result_str, "NULL pointer(s) passed to function 'str2mm'.\n");
        ret = GED_ERROR;
    } else {
        bu_vls_strcat(&str, units_string);
        bu_vls_trimspace(&str);

        tmp_value = strtod(bu_vls_addr(&str), &endp);
        if ((endp != bu_vls_addr(&str)) && (*endp == '\0')) {
            /* convert to double success */
            *conv_factor = tmp_value;
        } else if ((tmp_value = bu_mm_value(bu_vls_addr(&str))) > 0.0) {
            *conv_factor = tmp_value;
        } else {
            bu_vls_printf(ged_result_str, "Invalid units string '%s'\n", units_string);
            ret = GED_ERROR;
        }
    }

    bu_vls_free(&str);

    return ret;
}

/*
 * P R _ W A I T _ S T A T U S
 *
 * Interpret the status return of a wait() system call,
 * for the edification of the watching luser.
 * Warning:  This may be somewhat system specific, most especially
 * on non-UNIX machines.
 */
static void
pr_wait_status(Tcl_Interp *interp,
	       int status)
{
    int sig = status & 0x7f;
    int core = status & 0x80;
    int ret = status >> 8;
    struct bu_vls tmp_vls = BU_VLS_INIT_ZERO;

    if (status == 0) {
	Tcl_AppendResult(interp, "Normal exit\n", (char *)NULL);
	return;
    }

    bu_vls_printf(&tmp_vls, "Abnormal exit x%x", status);

    if (core)
	bu_vls_printf(&tmp_vls, ", core dumped");

    if (sig)
	bu_vls_printf(&tmp_vls, ", terminating signal = %d", sig);
    else
	bu_vls_printf(&tmp_vls, ", return (exit) code = %d", ret);

    Tcl_AppendResult(interp, bu_vls_addr(&tmp_vls), "\n", (char *)NULL);
    bu_vls_free(&tmp_vls);
}