// SPDX-License-Identifier: GPL-2.0
#include <elf.h>
#include <inttypes.h>
#include <sys/ttydefaults.h>
#include <string.h>
#include "../../util/sort.h"
#include "../../util/util.h"
#include "../../util/hist.h"
#include "../../util/debug.h"
#include "../../util/symbol.h"
#include "../browser.h"
#include "../helpline.h"
#include "../libslang.h"

/* 2048 lines should be enough for a script output */
#define MAX_LINES               2048

/* 160 bytes for one output line */
#define AVERAGE_LINE_LEN        160

struct script_line {
        struct list_head node;
        char line[AVERAGE_LINE_LEN];
};

struct perf_script_browser {
        struct ui_browser b;
        struct list_head entries;
        const char *script_name;
        int nr_lines;
};

#define SCRIPT_NAMELEN  128
#define SCRIPT_MAX_NO   64
/*
 * Usually the full path for a script is:
 *      /home/username/libexec/perf-core/scripts/python/xxx.py
 *      /home/username/libexec/perf-core/scripts/perl/xxx.pl
 * So 256 should be long enough to contain the full path.
 */
#define SCRIPT_FULLPATH_LEN     256

/*
 * When success, will copy the full path of the selected script
 * into  the buffer pointed by script_name, and return 0.
 * Return -1 on failure.
 */
static int list_scripts(char *script_name)
{
        char *buf, *names[SCRIPT_MAX_NO], *paths[SCRIPT_MAX_NO];
        int i, num, choice, ret = -1;

        /* Preset the script name to SCRIPT_NAMELEN */
        buf = malloc(SCRIPT_MAX_NO * (SCRIPT_NAMELEN + SCRIPT_FULLPATH_LEN));
        if (!buf)
                return ret;

        for (i = 0; i < SCRIPT_MAX_NO; i++) {
                names[i] = buf + i * (SCRIPT_NAMELEN + SCRIPT_FULLPATH_LEN);
                paths[i] = names[i] + SCRIPT_NAMELEN;
        }

        num = find_scripts(names, paths);
        if (num > 0) {
                choice = ui__popup_menu(num, names);
                if (choice < num && choice >= 0) {
                        strcpy(script_name, paths[choice]);
                        ret = 0;
                }
        }

        free(buf);
        return ret;
}

static void script_browser__write(struct ui_browser *browser,
                                   void *entry, int row)
{
        struct script_line *sline = list_entry(entry, struct script_line, node);
        bool current_entry = ui_browser__is_current_entry(browser, row);

        ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
                                                       HE_COLORSET_NORMAL);

        ui_browser__write_nstring(browser, sline->line, browser->width);
}

static int script_browser__run(struct perf_script_browser *browser)
{
        int key;

        if (ui_browser__show(&browser->b, browser->script_name,
                             "Press ESC to exit") < 0)
                return -1;

        while (1) {
                key = ui_browser__run(&browser->b, 0);

                /* We can add some special key handling here if needed */
                break;
        }

        ui_browser__hide(&browser->b);
        return key;
}


int script_browse(const char *script_opt)
{
        char cmd[SCRIPT_FULLPATH_LEN*2], script_name[SCRIPT_FULLPATH_LEN];
        char *line = NULL;
        size_t len = 0;
        ssize_t retlen;
        int ret = -1, nr_entries = 0;
        FILE *fp;
        void *buf;
        struct script_line *sline;

        struct perf_script_browser script = {
                .b = {
                        .refresh    = ui_browser__list_head_refresh,
                        .seek       = ui_browser__list_head_seek,
                        .write      = script_browser__write,
                },
                .script_name = script_name,
        };

        INIT_LIST_HEAD(&script.entries);

        /* Save each line of the output in one struct script_line object. */
        buf = zalloc((sizeof(*sline)) * MAX_LINES);
        if (!buf)
                return -1;
        sline = buf;

        memset(script_name, 0, SCRIPT_FULLPATH_LEN);
        if (list_scripts(script_name))
                goto exit;

        sprintf(cmd, "perf script -s %s ", script_name);

        if (script_opt)
                strcat(cmd, script_opt);

        if (input_name) {
                strcat(cmd, " -i ");
                strcat(cmd, input_name);
        }

        strcat(cmd, " 2>&1");

        fp = popen(cmd, "r");
        if (!fp)
                goto exit;

        while ((retlen = getline(&line, &len, fp)) != -1) {
                strncpy(sline->line, line, AVERAGE_LINE_LEN);

                /* If one output line is very large, just cut it short */
                if (retlen >= AVERAGE_LINE_LEN) {
                        sline->line[AVERAGE_LINE_LEN - 1] = '\0';
                        sline->line[AVERAGE_LINE_LEN - 2] = '\n';
                }
                list_add_tail(&sline->node, &script.entries);

                if (script.b.width < retlen)
                        script.b.width = retlen;

                if (nr_entries++ >= MAX_LINES - 1)
                        break;
                sline++;
        }

        if (script.b.width > AVERAGE_LINE_LEN)
                script.b.width = AVERAGE_LINE_LEN;

        free(line);
        pclose(fp);

        script.nr_lines = nr_entries;
        script.b.nr_entries = nr_entries;
        script.b.entries = &script.entries;

        ret = script_browser__run(&script);
exit:
        free(buf);
        return ret;
}