/*-
 * Copyright (c) 2023, Netflix, Inc
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <sys/types.h>

#include <err.h>
#include <errno.h>
#include <fts.h>
#include <grp.h>
#include <pwd.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#include "find.h"

/* translate \X to proper escape, or to itself if no special meaning */
static const char *esc = "\a\bcde\fghijklm\nopq\rs\tu\v";

static inline bool
isoct(char c)
{
        return (c >= '0' && c <= '7');
}

static inline bool
isesc(char c)
{
        return (c >= 'a' && c <= 'v' && esc[c - 'a'] != c);
}

static char *
escape(const char *str, bool *flush, bool *warned)
{
        char c;
        int value;
        char *tmpstr;
        size_t tmplen;
        FILE *fp;

        fp = open_memstream(&tmpstr, &tmplen);

        /*
         * Copy the str string into a new struct sbuf and return that expanding
         * the different ANSI escape sequences.
         */
        *flush = false;
        for (c = *str++; c; c = *str++) {
                if (c != '\\') {
                        putc(c, fp);
                        continue;
                }
                c = *str++;

                /*
                 * User error \ at end of string
                 */
                if (c == '\0') {
                        putc('\\', fp);
                        break;
                }

                /*
                 * \c terminates output now and is supposed to flush the output
                 * too...
                 */
                if (c == 'c') {
                        *flush = true;
                        break;
                }

                /*
                 * Is it octal? If so, decode up to 3 octal characters.
                 */
                if (isoct(c)) {
                        value = 0;
                        for (int i = 3; i-- > 0 && isoct(c);
                             c = *str++) {
                                value <<= 3;
                                value += c - '0';
                        }
                        str--;
                        putc((char)value, fp);
                        continue;
                }

                /*
                 * It's an ANSI X3.159-1989 escape, use the mini-escape lookup
                 * table to translate.
                 */
                if (isesc(c)) {
                        putc(esc[c - 'a'], fp);
                        continue;
                }

                /*
                 * Otherwise, it's self inserting. gnu find specifically says
                 * not to rely on this behavior though. gnu find will issue
                 * a warning here, while printf(1) won't.
                 */
                if (!*warned) {
                        warn("Unknown character %c after \\.", c);
                        *warned = true;
                }
                putc(c, fp);
        }
        fclose(fp);

        return (tmpstr);
}

static void
fp_ctime(FILE *fp, time_t t)
{
        char s[26];

        ctime_r(&t, s);
        s[24] = '\0';   /* kill newline, though gnu find info silent on issue */
        fputs(s, fp);
}

/*
 * Assumes all times are displayed in UTC rather than local time, gnu find info
 * page silent on the issue.
 *
 * Also assumes that gnu find doesn't support multiple character escape sequences,
 * which it's info page is also silent on.
 */
static void
fp_strftime(FILE *fp, time_t t, char mod)
{
        struct tm tm;
        char buffer[128];
        char fmt[3] = "% ";

        /*
         * Gnu libc extension we don't yet support -- seconds since epoch
         * Used in Linux kernel build, so we kinda have to support it here
         */
        if (mod == '@') {
                fprintf(fp, "%ju", (uintmax_t)t);
                return;
        }

        gmtime_r(&t, &tm);
        fmt[1] = mod;
        if (strftime(buffer, sizeof(buffer), fmt, &tm) == 0)
                errx(1, "Format bad or data too long for buffer"); /* Can't really happen ??? */
        fputs(buffer, fp);
}

void
do_printf(PLAN *plan, FTSENT *entry, FILE *fout)
{
        char buf[4096];
        struct stat sb;
        struct stat *sp;
        const char *path, *pend;
        char *all, *fmt;
        ssize_t ret;
        int c;
        bool flush, warned;

        warned = (plan->flags & F_HAS_WARNED) != 0;
        all = fmt = escape(plan->c_data, &flush, &warned);
        if (warned)
                plan->flags |= F_HAS_WARNED;
        for (c = *fmt++; c; c = *fmt++) {
                sp = entry->fts_statp;
                if (c != '%') {
                        putc(c, fout);
                        continue;
                }
                c = *fmt++;
                /* Style(9) deviation: case order same as gnu find info doc */
                switch (c) {
                case '%':
                        putc(c, fout);
                        break;
                case 'p': /* Path to file */
                        fputs(entry->fts_path, fout);
                        break;
                case 'f': /* filename w/o dirs */
                        fputs(entry->fts_name, fout);
                        break;
                case 'h':
                        /*
                         * path, relative to the starting point, of the file, or
                         * '.' if that's empty for some reason.
                         */
                        path = entry->fts_path;
                        pend = strrchr(path, '/');
                        if (pend == NULL)
                                putc('.', fout);
                        else
                                fwrite(path, pend - path, 1, fout);
                        break;
                case 'P': /* file with command line arg rm'd -- HOW? fts_parent? */
                        errx(1, "%%%c is unimplemented", c);
                case 'H': /* Command line arg -- HOW? */
                        errx(1, "%%%c is unimplemented", c);
                case 'g': /* gid human readable */
                        fputs(group_from_gid(sp->st_gid, 0), fout);
                        break;
                case 'G': /* gid numeric */
                        fprintf(fout, "%d", sp->st_gid);
                        break;
                case 'u': /* uid human readable */
                        fputs(user_from_uid(sp->st_uid, 0), fout);
                        break;
                case 'U': /* uid numeric */
                        fprintf(fout, "%d", sp->st_uid);
                        break;
                case 'm': /* mode in octal */
                        fprintf(fout, "%o", sp->st_mode & 07777);
                        break;
                case 'M': /* Mode in ls-standard form */
                        strmode(sp->st_mode, buf);
                        fwrite(buf, 10, 1, fout);
                        break;
                case 'k': /* kbytes used by file */
                        fprintf(fout, "%jd", (intmax_t)sp->st_blocks / 2);
                        break;
                case 'b': /* blocks used by file */
                        fprintf(fout, "%jd", (intmax_t)sp->st_blocks);
                        break;
                case 's': /* size in bytes of file */
                        fprintf(fout, "%ju", (uintmax_t)sp->st_size);
                        break;
                case 'S': /* sparseness of file */
                        fprintf(fout, "%3.1f",
                            (float)sp->st_blocks * 512 / (float)sp->st_size);
                        break;
                case 'd': /* Depth in tree */
                        fprintf(fout, "%ld", entry->fts_level);
                        break;
                case 'D': /* device number */
                        fprintf(fout, "%ju", (uintmax_t)sp->st_dev);
                        break;
                case 'F': /* Filesystem type */
                        errx(1, "%%%c is unimplemented", c);
                case 'l': /* object of symbolic link */
                        ret = readlink(entry->fts_accpath, buf, sizeof(buf));
                        if (ret > 0)
                                fwrite(buf, ret, 1, fout);
                        break;
                case 'i': /* inode # */
                        fprintf(fout, "%ju", (uintmax_t)sp->st_ino);
                        break;
                case 'n': /* number of hard links */
                        fprintf(fout, "%ju", (uintmax_t)sp->st_nlink);
                        break;
                case 'Y': /* -type of file, following 'l' types L loop ? error */
                        if (S_ISLNK(sp->st_mode)) {
                                if (stat(entry->fts_accpath, &sb) != 0) {
                                        switch (errno) {
                                        case ELOOP:
                                                putc('L', fout);
                                                break;
                                        case ENOENT:
                                                putc('N', fout);
                                                break;
                                        default:
                                                putc('?', fout);
                                                break;
                                        }
                                        break;
                                }
                                sp = &sb;
                        }
                        /* FALLTHROUGH */
                case 'y': /* -type of file, incl 'l' */
                        switch (sp->st_mode & S_IFMT) {
                        case S_IFIFO:
                                putc('p', fout);
                                break;
                        case S_IFCHR:
                                putc('c', fout);
                                break;
                        case S_IFDIR:
                                putc('d', fout);
                                break;
                        case S_IFBLK:
                                putc('b', fout);
                                break;
                        case S_IFREG:
                                putc('f', fout);
                                break;
                        case S_IFLNK:
                                putc('l', fout);
                                break;
                        case S_IFSOCK:
                                putc('s', fout);
                                break;
                        case S_IFWHT:
                                putc('w', fout);
                                break;
                        default:
                                putc('U', fout);
                                break;
                        }
                        break;
                case 'a': /* access time ctime */
                        fp_ctime(fout, sp->st_atime);
                        break;
                case 'A': /* access time with next char strftime format */
                        fp_strftime(fout, sp->st_atime, *fmt++);
                        break;
                case 'B': /* birth time with next char strftime format */
#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
                        if (sp->st_birthtime != 0)
                                fp_strftime(fout, sp->st_birthtime, *fmt);
#endif
                        fmt++;
                        break;  /* blank on systems that don't support it */
                case 'c': /* status change time ctime */
                        fp_ctime(fout, sp->st_ctime);
                        break;
                case 'C': /* status change time with next char strftime format */
                        fp_strftime(fout, sp->st_ctime, *fmt++);
                        break;
                case 't': /* modification change time ctime */
                        fp_ctime(fout, sp->st_mtime);
                        break;
                case 'T': /* modification time with next char strftime format */
                        fp_strftime(fout, sp->st_mtime, *fmt++);
                        break;
                case 'Z': /* empty string for compat SELinux context string */
                        break;
                /* Modifier parsing here, but also need to modify above somehow */
                case '#': case '-': case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9': case '.':
                        errx(1, "Format modifier %c not yet supported: '%s'", c, all);
                /* Any FeeeBSD-specific modifications here -- none yet */
                default:
                        errx(1, "Unknown format %c '%s'", c, all);
                }
        }
        if (flush)
                fflush(fout);
        free(all);
}