/*
 *        pic2img.cc
 *        Loading Doom-format pictures from a wad file.
 *        See the Unofficial Doom Specs, section [5-1].
 *        AYM 1998-??-??
 */


/*
This file is part of Yadex.

Yadex incorporates code from DEU 5.21 that was put in the public domain in
1994 by Raphaël Quinet and Brendon Wyber.

The rest of Yadex is Copyright © 1997-2003 André Majorel and others.

This program is free software; you can redistribute it and/or modify it 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; if not, write to the Free Software Foundation, Inc., 59 Temple
Place, Suite 330, Boston, MA 02111-1307, USA.
*/


#include "yadex.h"
#include "gcolour2.h"                /* colour0 */
#include "pic2img.h"
#include "wadfile.h"
#include "wads.h"


typedef enum
{ _MT_BADOFS, _MT_TOOLONG, _MT_TOOMANY } _msg_type_t;


static int add_msg(char type, int arg);
static void do_add_msg(char type, int arg);
static void flush_msg(const char *picname);


/*
 *        LoadPicture - read a picture from a wad file into an Img object
 *
 *        If img->is_null() is false, LoadPicture() does not allocate the
 *        buffer itself. The buffer and the picture don't have to have the
 *        same dimensions. Thanks to this, it can also be used to compose
 *        textures : you allocate a single buffer for the whole texture
 *        and then you call LoadPicture() on it once for each patch.
 *        LoadPicture() takes care of all the necessary clipping.
 *
 *        If img->is_null() is true, LoadPicture() sets the size of img
 *        to match that of the picture. This is useful in display_pic().
 *
 *        Return 0 on success, non-zero on failure.
 *
 *        If pic_x_offset == INT_MIN, the picture is centred horizontally.
 *        If pic_y_offset == INT_MIN, the picture is centred vertically.
 */

int LoadPicture(Img & img,        // Game image to load picture into
                const char *picname,        // Picture lump name
                const Lump_loc & picloc,        // Picture lump location
                int pic_x_offset,        // Coordinates of top left corner of picture
                int pic_y_offset,        // relative to top left corner of buffer
                int *pic_width,        // To return the size of the picture
                int *pic_height)        // (can be NULL)
{
    MDirPtr dir;
    i16 pic_width_;
    i16 pic_height_;
    i16 pic_intrinsic_x_ofs;
    i16 pic_intrinsic_y_ofs;
    u8 *ColumnData;
    u8 *Column;
    i32 *NeededOffsets;
    i32 CurrentOffset;
    int ColumnInMemory;
    long ActualBufLen;
    int pic_x;
    int pic_x0;
    int pic_x1;
    int pic_y0;
    int pic_y1;
    u8 *buf;                        /* This variable is set to point to the element of
                                   the image buffer where the top of the current column
                                   should be pasted. It can be off the image buffer! */

    // Locate the lump where the picture is
    if (picloc.wad != 0)
    {
        MasterDirectory dirbuf;
        dirbuf.wadfile = picloc.wad;
        dirbuf.dir.start = picloc.ofs;
        dirbuf.dir.size = picloc.len;
        dir = &dirbuf;
    }
    else
    {
        dir = (MDirPtr) FindMasterDir(cfg.MasterDir, picname);
        if (dir == NULL)
        {
            warn("picture %.*s does not exist.\n", WAD_PIC_NAME, picname);
            return 1;
        }
    }

    // Read the picture header
    dir->wadfile->seek(dir->dir.start);
    if (dir->wadfile->error())
    {
        warn("picture %.*s: can't seek to header, giving up\n",
             WAD_PIC_NAME, picname);
        return 1;
    }
    bool dummy_bytes = dir->wadfile->pic_format() == YGPF_NORMAL;
    bool long_header = dir->wadfile->pic_format() != YGPF_ALPHA;
    bool long_offsets = dir->wadfile->pic_format() == YGPF_NORMAL;
    if (long_header)
    {
        dir->wadfile->read_i16(&pic_width_);
        dir->wadfile->read_i16(&pic_height_);
        dir->wadfile->read_i16(&pic_intrinsic_x_ofs);        // Read but ignored
        dir->wadfile->read_i16(&pic_intrinsic_y_ofs);        // Read but ignored
        if (dir->wadfile->error())
        {
            warn("picture %.*s: read error in header, giving up\n",
                 WAD_PIC_NAME, picname);
            return 1;
        }
    }
    else
    {
        pic_width_ = dir->wadfile->read_u8();
        pic_height_ = dir->wadfile->read_u8();
        pic_intrinsic_x_ofs = dir->wadfile->read_u8();        // Read but ignored
        pic_intrinsic_y_ofs = dir->wadfile->read_u8();        // Read but ignored
        if (dir->wadfile->error())
        {
            warn("picture %.*s: read error in header, giving up\n",
                 WAD_PIC_NAME, picname);
            return 1;
        }
    }

    // If no buffer given by caller, allocate one.
    if (img.is_null())
    {
        // Sanity checks
        if (pic_width_ < 1 || pic_height_ < 1)
        {
            warn("picture %.*s: delirious dimensions %dx%d, giving up\n",
                 WAD_PIC_NAME, picname, (int) pic_width_, (int) pic_height_);
        }
        const int pic_width_max = 4096;
        if (pic_width_ > pic_width_max)
        {
            warn("picture %.*s: too wide (%d), clipping to %d\n",
                 WAD_PIC_NAME, picname, (int) pic_width_, pic_width_max);
            pic_width_ = pic_width_max;
        }
        const int pic_height_max = 4096;
        if (pic_height_ > pic_height_max)
        {
            warn("picture %.*s: too high (%d), clipping to %d\n",
                 WAD_PIC_NAME, picname, (int) pic_height_, pic_height_max);
            pic_height_ = pic_height_max;
        }
        img.resize(pic_width_, pic_height_);
    }
    int img_width = img.width();

    // Centre the picture.
    if (pic_x_offset == INT_MIN)
        pic_x_offset = (img_width - pic_width_) / 2;
    if (pic_y_offset == INT_MIN)
        pic_y_offset = (img.height() - pic_height_) / 2;

/* AYM 19971202: 17 kB is large enough for 128x128 patches. */
#define TEX_COLUMNBUFFERSIZE ((long) 17 * 1024)
/* Maximum number of bytes per column. The worst case is a
   509-high column, with every second pixel transparent. That
   makes 255 posts of 1 pixel, and a final FFh. The total is
   (255 x 5 + 1) = 1276 bytes per column. */
#define TEX_COLUMNSIZE  1300

    ColumnData = (u8 *) GetMemory(TEX_COLUMNBUFFERSIZE);
/* FIXME DOS and pic_width_ > 16000 */
    NeededOffsets = (i32 *) GetMemory((long) pic_width_ * sizeof(i32));

    if (long_offsets)
        dir->wadfile->read_i32(NeededOffsets, pic_width_);
    else
        for (int n = 0; n < pic_width_; n++)
        {
            i16 ofs;
            dir->wadfile->read_i16(&ofs);
            NeededOffsets[n] = ofs;
        }
    if (dir->wadfile->error())
    {
        warn("picture %.*s: read error in offset table, giving up\n",
             WAD_PIC_NAME, picname);
        FreeMemory(ColumnData);
        FreeMemory(NeededOffsets);
        return 1;
    }

    // Read first column data, and subsequent column data
    if (long_offsets && NeededOffsets[0] != 8 + (long) pic_width_ * 4
        || !long_offsets && NeededOffsets[0] != 4 + (long) pic_width_ * 2)
    {
        dir->wadfile->seek(dir->dir.start + NeededOffsets[0]);
        if (dir->wadfile->error())
        {
            warn("picture %.*s: can't seek to header, giving up\n",
                 WAD_PIC_NAME, picname);
            FreeMemory(ColumnData);
            FreeMemory(NeededOffsets);
            return 1;
        }
    }

    ActualBufLen = dir->wadfile->read_vbytes(ColumnData, TEX_COLUMNBUFFERSIZE);
    // FIXME should catch I/O errors

    // Clip the picture horizontally and vertically
    pic_x0 = -pic_x_offset;
    if (pic_x0 < 0)
        pic_x0 = 0;

    pic_x1 = img_width - pic_x_offset - 1;
    if (pic_x1 >= pic_width_)
        pic_x1 = pic_width_ - 1;

    pic_y0 = -pic_y_offset;
    if (pic_y0 < 0)
        pic_y0 = 0;

    pic_y1 = img.height() - pic_y_offset - 1;
    if (pic_y1 >= pic_height_)
        pic_y1 = pic_height_ - 1;

    // For each (non clipped) column of the picture...
    for (pic_x = pic_x0,
         buf = img.wbuf() + al_amax(pic_x_offset, 0) + img_width * pic_y_offset;
         pic_x <= pic_x1; pic_x++, buf++)
    {
        u8 *filedata;

        CurrentOffset = NeededOffsets[pic_x];
        ColumnInMemory = CurrentOffset >= NeededOffsets[0]
            && CurrentOffset + TEX_COLUMNSIZE <=
            NeededOffsets[0] + ActualBufLen;

        if (ColumnInMemory)
            Column = ColumnData + CurrentOffset - NeededOffsets[0];
        else
        {
            Column = (u8 *) GetMemory(TEX_COLUMNSIZE);
            dir->wadfile->seek(dir->dir.start + CurrentOffset);
            if (dir->wadfile->error())
            {
                int too_many = add_msg(_MT_BADOFS, (short) pic_x);
                FreeMemory(Column);
                if (too_many)        // This picture has too many errors. Give up.
                    goto pic_end;
                continue;        // Give up on this column
            }
            dir->wadfile->read_vbytes(Column, TEX_COLUMNSIZE);
            // FIXME should catch I/O errors
        }
        filedata = Column;

        // We now have the needed column data, one way or another, so write it

        // For each post of the column...
        {
            register u8 *post;
            for (post = filedata; *post != 0xff;)
            {
                int post_y_offset;        // Y-offset of top of post to origin of buffer
                int post_height;        // Height of post
                int post_pic_y0;        // Start and end of non-clipped part of post,
                int post_pic_y1;        // relative to top of picture
                int post_y0;        // Start and end of non-clipped part of post,
                int post_y1;        // relative to top of post

                if (post - filedata > TEX_COLUMNSIZE)
                {
                    int too_many = add_msg(_MT_TOOLONG, (short) pic_x);
                    if (too_many)        // This picture has too many errors. Give up.
                    {
                        if (!ColumnInMemory)
                            FreeMemory(Column);
                        goto pic_end;
                    }
                    break;        // Give up on this column
                }

                post_y_offset = *post++;
                post_height = *post++;
                if (dummy_bytes)
                    post++;        // Skip that dummy byte

                post_pic_y0 = post_y_offset;        // Clip the post vertically
                if (post_pic_y0 < pic_y0)
                    post_pic_y0 = pic_y0;

                post_pic_y1 = post_y_offset + post_height - 1;
                if (post_pic_y1 > pic_y1)
                    post_pic_y1 = pic_y1;

                post_y0 = post_pic_y0 - post_y_offset;
                post_y1 = post_pic_y1 - post_y_offset;


                {                // "Paste" the post onto the buffer
                    register img_pixel_t *b;
                    register const u8 *p = post + post_y0;
                    const u8 *const pmax = post + post_y1;
                    int buf_width = img_width;

                    for (b = buf + buf_width * (post_y_offset + post_y0);
                         p <= pmax; b += buf_width, p++)
                    {
#ifdef PARANOIA
                        if (b < img.buf())
                        {
                            nf_bug("Picture %.*s(%d): b < buffer",
                                   WAD_PIC_NAME, picname, (int) pic_x);
                            goto next_column;
                        }
#endif
                        *b = (*p == IMG_TRANSP) ? colour0 : *p;
                    }
                }

                post += post_height;
                if (dummy_bytes)
                    post++;        // Skip the trailing dummy byte
            }                        // Post loop
        }

#ifdef PARANOIA
      next_column:
#endif
        if (!ColumnInMemory)
            FreeMemory(Column);
    }                                // Column loop

  pic_end:
    FreeMemory(ColumnData);
    FreeMemory(NeededOffsets);
    flush_msg(picname);
#if 0
    c->flags |= HOOK_DRAWN;
#endif
    if (pic_width)
        *pic_width = pic_width_;
    if (pic_height)
        *pic_height = pic_height_;
    return 0;
}


/*
 *        List to hold pending warning messages
 */
typedef struct
{
    char type;
    short arg;
} _msg_t;
static _msg_t *_msg_list = 0;
static size_t _nmsg = 0;
const size_t _granularity = 128;
const size_t _max_msg = 20;


/*
 *        add_msg
 *        Add a warning message to the list
 *
 *        Return 0 on success, <>0 if the max number of messages
 *        has been reached.
 */
static int add_msg(char type, int arg)
{
    if (_nmsg >= _max_msg)
    {
        if (_nmsg == _max_msg)        // Test in case the caller ignores our return value
            do_add_msg(_MT_TOOMANY, arg);
        return 1;
    }
    do_add_msg(type, arg);
    return 0;
}


static void do_add_msg(char type, int arg)
{
    if ((_nmsg + 1) % _granularity == 1)        // Grow list if necessary
    {
        _msg_t *new_list = (_msg_t *) realloc(_msg_list,
                                              (_nmsg / _granularity +
                                               1) * _granularity *
                                              sizeof *_msg_list);
        if (new_list == 0)        // Not enough memory ? Ignore the new message
            return;
        _msg_list = new_list;
    }
    _msg_list[_nmsg].type = type;
    _msg_list[_nmsg].arg = arg;
    _nmsg++;
    return;
}


/*
 *        flush_msg
 *        Output all pending warning messages in an smart fashion
 */
static void flush_msg(const char *picname)
{
    if (_nmsg == 0 || _msg_list == 0)
        return;

    for (_msg_type_t t = _MT_BADOFS; t <= _MT_TOOLONG; ((int &) t)++)
    {
        size_t first_msg = AL_ASIZE_T_MAX;
        size_t last_msg = AL_ASIZE_T_MAX;
        const char *str = "unknown error";
        if (t == _MT_BADOFS)
            str = "bad file offset";
        else if (t == _MT_TOOLONG)
            str = "post too long";

        for (size_t n = 0; n < _nmsg; n++)
        {
            if (_msg_list[n].type == t)
            {
                if (first_msg == AL_ASIZE_T_MAX)
                {
                    first_msg = n;
                    last_msg = n;
                }
                else
                {
                    if (_msg_list[last_msg].arg != _msg_list[n].arg - 1)
                    {
                        warn("picture %.*s(%d",
                             WAD_PIC_NAME, picname,
                             (int) _msg_list[first_msg].arg);
                        if (last_msg != first_msg)
                            warn("-%d", (int) _msg_list[last_msg].arg);
                        warn("): %s. Corrupt wad ?\n", str);
                        first_msg = n;
                        last_msg = n;
                    }
                    else
                        last_msg = n;
                }
            }
        }
        if (first_msg != AL_ASIZE_T_MAX)
        {
            warn("picture %.*s(%d",
                 WAD_PIC_NAME, picname, (int) _msg_list[first_msg].arg);
            if (last_msg != first_msg)
                warn("-%d", (int) _msg_list[last_msg].arg);
            warn("): %s. Corrupt wad ?\n", str);
        }
    }

    if (_msg_list[_nmsg - 1].type == _MT_TOOMANY)
        warn("picture %.*s: too many errors. Giving up.\n", WAD_PIC_NAME,
             picname);
    _nmsg = 0;
    free(_msg_list);
    _msg_list = 0;
}