/* ui.cpp --

   This file is part of the UPX executable compressor.

   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 1996-2000 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
   and/or modify them under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; see the file COPYING.
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   Markus F.X.J. Oberhumer                   Laszlo Molnar
   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
 */


#include "conf.h"
#include "file.h"
#include "screen.h"
#include "ui.h"
#include "packer.h"


#if 1 && defined(USE_SCREEN)
#define UI_USE_SCREEN
#endif


enum {
    M_QUIET,        // nothing at all '-qqq'
    M_INFO,         // print a one line info after compression '-qq'
    M_MSG,          // print "compressing", then "\r" and M_INFO
    M_CB_TERM,      // 1 line callback using stdout
    M_CB_SCREEN     // 2 line callback using screen
};


struct UiPacker::State
{
    int mode;

    unsigned u_len;
    unsigned step;
    unsigned next_update;

    int pass;
    int total_passes;

    // message stuff
    char msg_buf[1+79+1];
    int pos;            // last progress bar position
    int counter;        // for spinner

    int bar_pos;
    int bar_len;
    int pass_digits;    // number of digits needed to print total_passes

#if defined(UI_USE_SCREEN)
    screen_t *screen;
    int b_cx, b_cy;
    int s_cx, s_cy;
    int s_fg, s_bg;
    int c_fg;
    int scroll_up;
    int cursor_shape;
#else
    void *screen;
#endif

    // debug
    unsigned progress_updates;
};


long UiPacker::total_files = 0;
long UiPacker::total_files_done = 0;
long UiPacker::total_c_len = 0;
long UiPacker::total_u_len = 0;
long UiPacker::total_fc_len = 0;
long UiPacker::total_fu_len = 0;
long UiPacker::update_c_len = 0;
long UiPacker::update_u_len = 0;
long UiPacker::update_fc_len = 0;
long UiPacker::update_fu_len = 0;

#define clear_cb()    memset(&cb, 0, sizeof(cb))


static const char header_line1[] =
    "        File size         Ratio      Format      Name\n";
static const char header_line2[] =
#ifdef __MSDOS__
    "   ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ   ÄÄÄÄÄÄ   ÄÄÄÄÄÄÄÄÄÄÄ   ÄÄÄÄÄÄÄÄÄÄÄ\n";
#else
    "   --------------------   ------   -----------   -----------\n";
#endif


static const char *mkline(unsigned long fu_len, unsigned long fc_len,
                          unsigned long u_len, unsigned long c_len,
                          const char *format_name, const char *filename,
                          bool decompress=false)
{
    static char buf[2000];
    char r[7+1];
    const char *f;

#if 0
    unsigned ratio = get_ratio(fc_len,fu_len);
    upx_snprintf(r,sizeof(r)," %1d.%03d", ratio / 10000, (ratio % 10000) / 10);
#else
    unsigned ratio = get_ratio(fc_len,fu_len, 1000);
    upx_snprintf(r,sizeof(r),"%3d.%02d%%", ratio / 1000, (ratio % 1000) / 10);
    UNUSED(u_len); UNUSED(c_len);
#endif
    if (decompress)
        f = "%10ld <-%10ld  %7s  %13s  %s";
    else
        f = "%10ld ->%10ld  %7s  %13s  %s";
    upx_snprintf(buf,sizeof(buf),f,
                 fu_len, fc_len, r, center_string(format_name,13), filename);
    return buf;
}


/*************************************************************************
//
**************************************************************************/

UiPacker::UiPacker(const Packer *p_) :
    p(p_), s(NULL)
{
    clear_cb();

    s = new State;
    memset(s,0,sizeof(*s));
    s->msg_buf[0] = '\r';

#if defined(UI_USE_SCREEN)
    // ugly hack
    s->screen = sobject_get_screen();
#endif

    if (opt->verbose < 0)
        s->mode = M_QUIET;
    else if (opt->verbose == 0 || !isatty(STDOUT_FILENO))
        s->mode = M_INFO;
    else if (opt->verbose == 1 || opt->no_progress)
        s->mode = M_MSG;
    else if (!s->screen)
        s->mode = M_CB_TERM;
    else
        s->mode = M_CB_SCREEN;
}


UiPacker::~UiPacker()
{
    clear_cb();
    delete s; s = NULL;
}


/*************************************************************************
// start callback
**************************************************************************/

void UiPacker::startCallback(unsigned u_len, unsigned step,
                             int pass, int total_passes)
{
    s->u_len = u_len;
    s->step = step;
    s->next_update = step;

    s->pass = pass;
    s->total_passes = total_passes;

    s->bar_len = 64;
    s->pos = -2;
    s->counter = 0;
    s->bar_pos = 1;             // because of the leading `\r'
    s->progress_updates = 0;
    s->pass_digits = 0;

    clear_cb();

    if (s->pass < 0)            // no callback wanted
        return;

    if (s->mode <= M_INFO)
        return;
    if (s->mode == M_MSG)
    {
        if (pass <= 1)
        {
            con_fprintf(stdout,"Compressing %s [%s]",p->fi->getName(),p->getName());
            fflush(stdout);
            printSetNl(2);
        }
        return;
    }

    cb.callback = callback;
    cb.user = this;

    if (s->mode == M_CB_TERM)
    {
        const char *fname = fn_basename(p->fi->getName());
        int l = (int) strlen(fname);
        if (l > 0 && l <= 30)
        {
            strcpy(&s->msg_buf[s->bar_pos], fname);
            s->bar_pos += l;
            s->msg_buf[s->bar_pos++] = ' ';
            s->msg_buf[s->bar_pos++] = ' ';
            s->bar_len -= l + 2;
        }
    }

    // set pass
    if (total_passes > 1)
    {
        do {
            s->pass_digits++;
            total_passes /= 10;
        } while (total_passes > 0);
        int l = sprintf(&s->msg_buf[s->bar_pos], "%*d/%*d  ",
                        s->pass_digits, s->pass,
                        s->pass_digits, s->total_passes);
        if (l > 0 && s->bar_len - l > 10)
        {
            s->bar_len -= l;
            s->bar_pos += l;
        }
    }

#if defined(UI_USE_SCREEN)
    if (s->mode == M_CB_SCREEN)
    {
        s->screen->getCursor(s->screen,&s->s_cx,&s->s_cy);
        s->s_fg = s->screen->getFg(s->screen);
        s->s_bg = s->screen->getBg(s->screen);

        // FIXME: this message can be longer than one line.
        //        must adapt endCallback() for this case.
        con_fprintf(stdout,"Compressing %s [%s]\n",p->fi->getName(),p->getName());
        s->screen->getCursor(s->screen,&s->b_cx,&s->b_cy);
        if (s->b_cy == s->s_cy)
            s->scroll_up++;
        if (s->screen->hideCursor)
            s->cursor_shape = s->screen->hideCursor(s->screen);
    }
#endif /* UI_USE_SCREEN */
}


// may only get called directly after startCallback()
void UiPacker::firstCallback()
{
    if (s->pos == -2)
        doCallback(0, 0);
}


// make sure we reach 100% in the progress bar
void UiPacker::finalCallback(unsigned u_len, unsigned c_len)
{
    s->next_update = u_len;
    doCallback(u_len, c_len);
}


/*************************************************************************
// end callback
**************************************************************************/

void UiPacker::endCallback()
{
    if (s->pass < 0)            // no callback wanted
        return;

    const bool done = (s->total_passes <= 0 || s->pass >= s->total_passes);

    if (s->mode == M_CB_TERM)
    {
        if (done)
            printClearLine(stdout);
        else
            printSetNl(2);
    }

    // restore screen
#if defined(UI_USE_SCREEN)
    if (s->mode == M_CB_SCREEN)
    {
#if 0
        if (s->scroll_up)
            s->screen->scrollDown(screen,s->scroll_up);
        else
            s->screen->clearLine(s->screen,s->s_cy+1);
        s->screen->clearLine(s->screen,s->s_cy);
        s->screen->setCursor(s->screen,s->s_cx,s->s_cy);
#else
        assert(s->s_cx == 0 && s->b_cx == 0);
        s->screen->clearLine(s->screen,s->b_cy-1);
        s->screen->clearLine(s->screen,s->b_cy);
        s->screen->setCursor(s->screen,s->b_cx,s->b_cy-1);
#endif
        s->screen->setFg(s->screen,s->s_fg);
        s->screen->setBg(s->screen,s->s_bg);
        if (s->cursor_shape > 0)
            s->screen->setCursorShape(s->screen,s->cursor_shape);
    }
#endif /* UI_USE_SCREEN */

    clear_cb();
#if 0
    printf("callback: pass %d, step %6d, updates %6d\n",
           s->pass, s->step, s->progress_updates);
#endif
}


/*************************************************************************
// the callback
**************************************************************************/

void __UPX_ENTRY UiPacker::callback(upx_uint isize, upx_uint osize, int state, void * user)
{
    //printf("%6d %6d %d\n", is, os, state);
    if (state != -1 && state != 3) return;
    if (user)
    {
        UiPacker *uip = reinterpret_cast<UiPacker *>(user);
        uip->doCallback(isize,osize);
    }
}


void UiPacker::doCallback(unsigned isize, unsigned osize)
{
    static const char spinner[] = "|\\-/";

    if (s->pass < 0)            // no callback wanted
        return;

    if (s->u_len == 0 || isize > s->u_len)
        return;
    // check if we should update the display
    if (s->step > 0 && isize > 0 && isize < s->u_len)
    {
        if (isize < s->next_update)
            return;
        s->next_update += s->step;
    }

#if 0
    printf("%6d %6d %6d %6d\n", isize, osize, s->step, s->next_update);
    return;
#endif

    // compute progress position
    int pos = -1;
    if (isize > 0)
        pos = get_ratio(isize,s->u_len) * s->bar_len / 10000;
    if (pos < s->pos)
        return;
    if (pos < 0 && pos == s->pos)
        return;

    // fill the progress bar
    char *m = &s->msg_buf[s->bar_pos];
    *m++ = '[';
    for (int i = 0; i < s->bar_len; i++)
    {
#ifdef __MSDOS__
        //*m++ = i <= pos ? '\xdb' : '.';
        //*m++ = i <= pos ? '\xb0' : '\x07';
        //*m++ = i <= pos ? '\xb1' : '\x07';
        *m++ = i <= pos ? '\xfe' : '\xf9';
#else
        *m++ = i <= pos ? '*' : '.';
#endif
    }
    *m++ = ']';

    // compute current compression ratio
    unsigned ratio = 100*100;
    if (osize > 0)
        ratio = get_ratio(osize,isize);

    sprintf(m,"  %3d.%1d%%  %c ",
            ratio / 100, (ratio % 100) / 10,
            spinner[s->counter]);
    assert((int)strlen(s->msg_buf) < 1 + 80);

    s->pos = pos;
    s->counter = (s->counter + 1) & 3;
    s->progress_updates++;

    if (s->mode == M_CB_TERM)
    {
        const char *msg = &s->msg_buf[0];
        int fg = con_fg(stdout,FG_CYAN);
        con_fprintf(stdout,"%s",msg);      // avoid backslash interpretation
        (void) con_fg(stdout,fg);
        fflush(stdout);
        printSetNl(1);
        UNUSED(fg);
        return;
    }

#if defined(UI_USE_SCREEN)
    if (s->mode == M_CB_SCREEN)
    {
        const char *msg = &s->msg_buf[1];
#if 0
        s->screen->putString(s->screen,msg,s->b_cx,s->b_cy);
#else
        // FIXME: this doesn't honor `--mono' etc.
        int attr = FG_CYAN | s->s_bg;
        s->screen->putStringAttr(s->screen,msg,attr,s->b_cx,s->b_cy);
#endif
        s->screen->refresh(s->screen);
    }
#endif /* UI_USE_SCREEN */
}


/*************************************************************************
// pack
**************************************************************************/

void UiPacker::uiPackStart(const OutputFile *fo)
{
    total_files++;
    UNUSED(fo);
}


void UiPacker::uiPackEnd(const OutputFile *fo)
{
    uiUpdate(fo->getBytesWritten());

    if (s->mode == M_QUIET)
        return;
    if (s->mode == M_MSG)
    {
        // We must put this here and not in endCallback() as we may
        // have multiple passes.
        printClearLine(stdout);
    }

    const char *name = p->fi->getName();
    if (opt->output_name)
        name = opt->output_name;
    else if (opt->to_stdout)
        name = "<stdout>";
    con_fprintf(stdout,"%s\n",
                mkline(p->ph.u_file_size, fo->getBytesWritten(),
                       p->ph.u_len, p->ph.c_len,
                       p->getName(), fn_basename(name)));
    printSetNl(0);
}


void UiPacker::uiPackTotal()
{
    uiListTotal();
    uiFooter("Packed");
}


/*************************************************************************
// unpack
**************************************************************************/

void UiPacker::uiUnpackStart(const OutputFile *fo)
{
    total_files++;
    UNUSED(fo);
}


void UiPacker::uiUnpackEnd(const OutputFile *fo)
{
    uiUpdate(-1, fo->getBytesWritten());

    const char *name = p->fi->getName();
    if (opt->output_name)
        name = opt->output_name;
    else if (opt->to_stdout)
        name = "<stdout>";
    con_fprintf(stdout,"%s\n",
                mkline(fo->getBytesWritten(), p->file_size,
                       p->ph.u_len, p->ph.c_len,
                       p->getName(), fn_basename(name), true));
    printSetNl(0);
}


void UiPacker::uiUnpackTotal()
{
    uiListTotal(true);
    uiFooter("Unpacked");
}


/*************************************************************************
// list
**************************************************************************/

void UiPacker::uiListStart()
{
    total_files++;
}


void UiPacker::uiList(long fu_len)
{
    if (fu_len < 0)
        fu_len = p->ph.u_file_size;
    const char *name = p->fi->getName();
    con_fprintf(stdout,"%s\n",
                mkline(fu_len, p->file_size,
                       p->ph.u_len, p->ph.c_len,
                       p->getName(), name));
    printSetNl(0);
}


void UiPacker::uiListEnd()
{
    uiUpdate();
}


void UiPacker::uiListTotal(bool decompress)
{
    if (opt->verbose >= 1 && total_files >= 2)
    {
        char name[32];
        upx_snprintf(name,sizeof(name),"[ %ld file%s ]", total_files_done, total_files_done == 1 ? "" : "s");
        con_fprintf(stdout,"%s%s\n",
                    header_line2,
                    mkline(total_fu_len, total_fc_len,
                           total_u_len, total_c_len,
                           "", name, decompress));
        printSetNl(0);
    }
}


/*************************************************************************
// test
**************************************************************************/

void UiPacker::uiTestStart()
{
    total_files++;

    if (opt->verbose >= 1)
    {
        con_fprintf(stdout,"testing %s ", p->fi->getName());
        fflush(stdout);
        printSetNl(1);
    }
}


void UiPacker::uiTestEnd()
{
    if (opt->verbose >= 1)
    {
        con_fprintf(stdout,"[OK]\n");
        fflush(stdout);
        printSetNl(0);
    }
    uiUpdate();
}


void UiPacker::uiTestTotal()
{
    uiFooter("Tested");
}


/*************************************************************************
// info
**************************************************************************/

bool UiPacker::uiFileInfoStart()
{
    total_files++;

    int fg = con_fg(stdout,FG_CYAN);
    con_fprintf(stdout,"%s [%s]\n", p->fi->getName(), p->getName());
    fg = con_fg(stdout,fg);
    UNUSED(fg);
    if (p->ph.c_len > 0)
    {
        con_fprintf(stdout,"  %8ld bytes", (long)p->file_size);
        con_fprintf(stdout,", compressed by UPX %d, method %d, level %d, filter 0x%02x/0x%02x\n",
                    p->ph.version, p->ph.method, p->ph.level, p->ph.filter, p->ph.filter_cto);
        return false;
    }
    else
    {
        con_fprintf(stdout,"  %8ld bytes", (long)p->file_size);
        con_fprintf(stdout,", not compressed by UPX\n");
        return true;
    }
}

void UiPacker::uiFileInfoEnd()
{
    uiUpdate();
}


void UiPacker::uiFileInfoTotal()
{
}


/*************************************************************************
// util
**************************************************************************/

void UiPacker::uiHeader()
{
    static bool done = false;
    if (done)
        return;
    done = true;
    if (opt->cmd == CMD_TEST || opt->cmd == CMD_FILEINFO)
        return;
    if (opt->verbose >= 1)
    {
        con_fprintf(stdout,"%s%s", header_line1, header_line2);
    }
}


void UiPacker::uiFooter(const char *t)
{
    static bool done = false;
    if (done)
        return;
    done = true;
    if (opt->verbose >= 1)
    {
        long n1 = total_files;
        long n2 = total_files_done;
        long n3 = total_files - total_files_done;
        if (n3 == 0)
            con_fprintf(stdout,"\n%s %ld file%s.\n",
                        t, n1, n1 == 1 ? "" : "s");
        else
            con_fprintf(stdout,"\n%s %ld file%s: %ld ok, %ld error%s.\n",
                        t, n1, n1 == 1 ? "" : "s", n2, n3, n3 == 1 ? "" : "s");
    }
}


void UiPacker::uiUpdate(long fc_len, long fu_len)
{
    update_fc_len = (fc_len >= 0) ? fc_len : p->file_size;
    update_fu_len = (fu_len >= 0) ? fu_len : p->ph.u_file_size;
    update_c_len = p->ph.c_len;
    update_u_len = p->ph.u_len;
}


void UiPacker::uiConfirmUpdate()
{
    total_files_done++;
    total_fc_len += update_fc_len;
    total_fu_len += update_fu_len;
    total_c_len += update_c_len;
    total_u_len += update_u_len;
}


/*
vi:ts=4:et
*/