/*
Copyright (C) 2001-2006, William Joseph.
All Rights Reserved.

This file is part of GtkRadiant.

GtkRadiant 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.

GtkRadiant 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 GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

#if !defined(INCLUDED_IMAGELIB_H)
#define INCLUDED_IMAGELIB_H

#include "iimage.h"
#include "iarchive.h"
#include "idatastream.h"
#include <stdlib.h>

struct RGBAPixel
{
  unsigned char red, green, blue, alpha;
};

class RGBAImage : public Image
{
  RGBAImage(const RGBAImage& other);
  RGBAImage& operator=(const RGBAImage& other);
public:
  RGBAPixel* pixels;
  unsigned int width, height;

  RGBAImage(unsigned int _width, unsigned int _height)
    : pixels(new RGBAPixel[_width * _height]), width(_width), height(_height)
  {
  }
  ~RGBAImage()
  {
    delete pixels;
  }

  void release()
  {
    delete this;
  }
  byte* getRGBAPixels() const
  {
    return reinterpret_cast<byte*>(pixels);
  }
  unsigned int getWidth() const
  {
    return width;
  }
  unsigned int getHeight() const
  {
    return height;
  }
};

class RGBAImageFlags : public RGBAImage
{
public:
  int m_surfaceFlags;
  int m_contentFlags;
  int m_value;
  RGBAImageFlags(unsigned short _width, unsigned short _height, int surfaceFlags, int contentFlags, int value) :
    RGBAImage(_width, _height), m_surfaceFlags(surfaceFlags), m_contentFlags(contentFlags), m_value(value)
  {
  }

  int getSurfaceFlags() const
  {
    return m_surfaceFlags;
  }
  int getContentFlags() const
  {
    return m_contentFlags;
  }
  int getValue() const
  {
    return m_value;
  }
};


inline InputStream::byte_type* ArchiveFile_loadBuffer(ArchiveFile& file, std::size_t& length)
{
  InputStream::byte_type* buffer = (InputStream::byte_type*)malloc(file.size() + 1);
  length = file.getInputStream().read(buffer, file.size());
  buffer[file.size()] = 0;
  return buffer;
}

inline void ArchiveFile_freeBuffer(InputStream::byte_type* buffer)
{
  free(buffer);
}

class ScopedArchiveBuffer
{
public:
  std::size_t length;
  InputStream::byte_type* buffer;

  ScopedArchiveBuffer(ArchiveFile& file)
  {
    buffer = ArchiveFile_loadBuffer(file, length);
  }
  ~ScopedArchiveBuffer()
  {
    ArchiveFile_freeBuffer(buffer);
  }
};

class PointerInputStream : public InputStream
{
  const byte* m_read;
public:
  PointerInputStream(const byte* pointer)
    : m_read(pointer)
  {
  }
  std::size_t read(byte* buffer, std::size_t length)
  {
    const byte* end = m_read + length;
    while(m_read != end)
    {
      *buffer++ = *m_read++;
    }
    return length;
  }
  void seek(std::size_t offset)
  {
    m_read += offset;
  }
  const byte* get()
  {
    return m_read;
  }
};

#endif