///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2014, Industrial Light & Magic, a division of Lucas
// Digital Ltd. LLC
// 
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
// *       Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// *       Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// *       Neither the name of Industrial Light & Magic nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission. 
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////

//----------------------------------------------------------------------------
//
//      class Image
//
//----------------------------------------------------------------------------

#include "ImfImage.h"
#include <ImfChannelList.h>
#include <Iex.h>
#include <cassert>
#include <algorithm>

using namespace IMATH_NAMESPACE;
using namespace IEX_NAMESPACE;
using namespace std;

OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER

namespace {

int
levelSize (int min, int max, int l, LevelRoundingMode levelRoundingMode)
{
    assert (l >= 0);

    if (max < min)
        return 0;

    int a = max - min + 1;
    int b = (1 << l);
    int size = a / b;

    if (levelRoundingMode == ROUND_UP && size * b < a)
	size += 1;

    return std::max (size, 1);
}


Box2i
computeDataWindowForLevel
    (const Box2i& dataWindow,
     int lx, int ly,
     LevelRoundingMode lrMode)
{
    V2i levelMax =
        dataWindow.min +
        V2i (levelSize (dataWindow.min.x, dataWindow.max.x, lx, lrMode) - 1,
             levelSize (dataWindow.min.y, dataWindow.max.y, ly, lrMode) - 1);

    return Box2i (dataWindow.min, levelMax);
}

int
floorLog2 (int x)
{
    //
    // For x > 0, floorLog2(y) returns floor(log(x)/log(2)).
    //

    int y = 0;

    while (x > 1)
    {
	y +=  1;
	x >>= 1;
    }

    return y;
}


int
ceilLog2 (int x)
{
    //
    // For x > 0, ceilLog2(y) returns ceil(log(x)/log(2)).
    //

    int y = 0;
    int r = 0;

    while (x > 1)
    {
	if (x & 1)
	    r = 1;

	y +=  1;
	x >>= 1;
    }

    return y + r;
}


int
roundLog2 (int x, LevelRoundingMode levelRoundingMode)
{
    if (x < 1)
        return 1;

    return (levelRoundingMode == ROUND_DOWN)? floorLog2 (x): ceilLog2 (x);
}


int
computeNumXLevels
    (const Box2i& dataWindow,
     LevelMode levelMode,
     LevelRoundingMode levelRoundingMode)
{
    int n = 0;

    switch (levelMode)
    {
      case ONE_LEVEL:

	n = 1;
	break;

      case MIPMAP_LEVELS:

	{
	  int w = dataWindow.max.x - dataWindow.min.x + 1;
	  int h = dataWindow.max.y - dataWindow.min.y + 1;
	  n = roundLog2 (std::max (w, h), levelRoundingMode) + 1;
	}
        break;

      case RIPMAP_LEVELS:

	{
	  int w = dataWindow.max.x - dataWindow.min.x + 1;
	  n = roundLog2 (w, levelRoundingMode) + 1;
	}
	break;

      default:

        assert (false);
    }

    return n;
}


int
computeNumYLevels
    (const Box2i& dataWindow,
     LevelMode levelMode,
     LevelRoundingMode levelRoundingMode)
{
    int n = 0;

    switch (levelMode)
    {
      case ONE_LEVEL:

	n = 1;
	break;

      case MIPMAP_LEVELS:

	{
	  int w = dataWindow.max.x - dataWindow.min.x + 1;
	  int h = dataWindow.max.y - dataWindow.min.y + 1;
	  n = roundLog2 (std::max (w, h), levelRoundingMode) + 1;
	}
        break;

      case RIPMAP_LEVELS:

	{
	  int h = dataWindow.max.y - dataWindow.min.y + 1;
	  n = roundLog2 (h, levelRoundingMode) + 1;
	}
	break;

      default:

        assert (false);
    }

    return n;
}

} // namespace


Image::Image ():
    _dataWindow (Box2i (V2i (0, 0), V2i (-1, -1))),
    _levelMode (ONE_LEVEL),
    _levelRoundingMode (ROUND_DOWN),
    _channels(),
    _levels()
{
    // empty
}


Image::~Image ()
{
    clearLevels();
    clearChannels();
}


LevelMode
Image::levelMode () const
{
    return _levelMode;
}


LevelRoundingMode
Image::levelRoundingMode () const
{
    return _levelRoundingMode;
}


int
Image::numLevels () const
{
    if (_levelMode == ONE_LEVEL || _levelMode == MIPMAP_LEVELS)
        return numXLevels();
    else
        throw LogicExc ("Number of levels query for image "
                        "must specify x or y direction.");
}


int
Image::numXLevels () const
{
    return _levels.width();
}


int
Image::numYLevels () const
{
    return _levels.height();
}


const Box2i &
Image::dataWindow () const
{
    return _dataWindow;
}


const Box2i &
Image::dataWindowForLevel (int l) const
{
    return dataWindowForLevel (l, l);
}


const Box2i &
Image::dataWindowForLevel (int lx, int ly) const
{
    if (!levelNumberIsValid (lx, ly))
    {
        THROW (ArgExc,
               "Cannot get data window for invalid image "
               "level (" << lx << ", " << ly << ").");
    }

    return _levels[ly][lx]->dataWindow();
}


int
Image::levelWidth  (int lx) const
{
    if (lx < 0 || lx >= numXLevels())
    {
        THROW (ArgExc,
               "Cannot get level width for invalid "
               "image level number " << lx << ".");
    }

    return levelSize (_dataWindow.min.x, _dataWindow.max.x,
                      lx, _levelRoundingMode);
}


int
Image::levelHeight (int ly) const
{
    if (ly < 0 || ly >= numYLevels())
    {
        THROW (ArgExc,
               "Cannot get level height for invalid "
               "image level number " << ly << ".");
    }

    return levelSize (_dataWindow.min.y, _dataWindow.max.y,
                      ly, _levelRoundingMode);
}


void
Image::resize (const Imath::Box2i &dataWindow)
{
    resize (dataWindow, _levelMode, _levelRoundingMode);
}


void
Image::resize
    (const Imath::Box2i &dataWindow,
     LevelMode levelMode,
     LevelRoundingMode levelRoundingMode)
{
    try
    {
        clearLevels();

        int nx = computeNumXLevels (dataWindow, levelMode, levelRoundingMode);
        int ny = computeNumYLevels (dataWindow, levelMode, levelRoundingMode);

        _levels.resizeErase (ny, nx);

        for (int y = 0; y < ny; ++y)
        {
            for (int x = 0; x < nx; ++x)
            {
                if (levelMode == MIPMAP_LEVELS && x != y)
                {
                    _levels[y][x] = 0;
                    continue;
                }

                Box2i levelDataWindow =
                    computeDataWindowForLevel (dataWindow,
                                               x, y,
                                               levelRoundingMode);

                _levels[y][x] = newLevel (x, y, levelDataWindow);

                for (ChannelMap::iterator i = _channels.begin();
                     i != _channels.end();
                     ++i)
                {
                    _levels[y][x]->insertChannel (i->first,
                                                  i->second.type,
                                                  i->second.xSampling,
                                                  i->second.ySampling,
                                                  i->second.pLinear);
                }
            }
        }

        _dataWindow = dataWindow;
        _levelMode = levelMode;
        _levelRoundingMode = levelRoundingMode;
    }
    catch (...)
    {
        clearLevels();
        throw;
    }
}


void
Image::shiftPixels (int dx, int dy)
{
    for (ChannelMap::iterator i = _channels.begin(); i != _channels.end(); ++i)
    {
        if (dx % i->second.xSampling != 0)
        {
            THROW (ArgExc, "Cannot shift image horizontally by " << dx << " "
                           "pixels.  The shift distance must be a multiple "
                           "of the x sampling rate of all channels, but the "
                           "x sampling rate channel " << i->first << " "
                           "is " << i->second.xSampling << ".");
        }

        if (dy % i->second.ySampling != 0)
        {
            THROW (ArgExc, "Cannot shift image vertically by " << dy << " "
                           "pixels.  The shift distance must be a multiple "
                           "of the y sampling rate of all channels, but the "
                           "y sampling rate channel " << i->first << " "
                           "is " << i->second.ySampling << ".");
        }
    }

    _dataWindow.min.x += dx;
    _dataWindow.min.y += dy;
    _dataWindow.max.x += dx;
    _dataWindow.max.y += dy;

    for (int y = 0; y < _levels.height(); ++y)
        for (int x = 0; x < _levels.width(); ++x)
            if (_levels[y][x])
                _levels[y][x]->shiftPixels (dx, dy);
}


void
Image::insertChannel
    (const std::string &name,
     PixelType type,
     int xSampling,
     int ySampling,
     bool pLinear)
{
    try
    {
        _channels[name] = ChannelInfo (type, xSampling, ySampling, pLinear);

        for (int y = 0; y < _levels.height(); ++y)
            for (int x = 0; x < _levels.width(); ++x)
                if (_levels[y][x])
                    _levels[y][x]->insertChannel
                                    (name, type, xSampling, ySampling, pLinear);
    }
    catch (...)
    {
        eraseChannel (name);
        throw;
    }
}


void
Image::insertChannel (const string &name, const Channel &channel)
{
    insertChannel (name,
                   channel.type,
                   channel.xSampling,
                   channel.ySampling,
                   channel.pLinear);
}


void                   
Image::eraseChannel (const std::string &name)
{
    //
    // Note: eraseChannel() is called to clean up if an exception is
    // thrown during a call during insertChannel(), so eraseChannel()
    // must work correctly even after an incomplete insertChannel()
    // operation.
    //

    for (int y = 0; y < _levels.height(); ++y)
        for (int x = 0; x < _levels.width(); ++x)
            if (_levels[y][x])
                _levels[y][x]->eraseChannel (name);

    ChannelMap::iterator i = _channels.find (name);

    if (i != _channels.end())
        _channels.erase (i);
}


void
Image::clearChannels ()
{
    for (int y = 0; y < _levels.height(); ++y)
        for (int x = 0; x < _levels.width(); ++x)
            if (_levels[y][x])
                _levels[y][x]->clearChannels();
                
    _channels.clear();
}


void
Image::renameChannel (const string &oldName, const string &newName)
{
    if (oldName == newName)
        return;

    ChannelMap::iterator oldChannel = _channels.find (oldName);

    if (oldChannel == _channels.end())
    {
        THROW (ArgExc, "Cannot rename image channel " << oldName << " "
                       "to " << newName << ".  The image does not have "
                       "a channel called " << oldName << ".");
    }

    if (_channels.find (newName) != _channels.end())
    {
        THROW (ArgExc, "Cannot rename image channel " << oldName << " "
                       "to " << newName << ".  The image already has "
                       "a channel called " << newName << ".");
    }

    try
    {
        for (int y = 0; y < _levels.height(); ++y)
            for (int x = 0; x < _levels.width(); ++x)
                if (_levels[y][x])
                    _levels[y][x]->renameChannel (oldName, newName);

        _channels[newName] = oldChannel->second;
        _channels.erase (oldChannel);
    }
    catch (...)
    {
        eraseChannel (oldName);
        eraseChannel (newName);
        throw;
    }
}


void
Image::renameChannels (const RenamingMap &oldToNewNames)
{
    set <string> newNames;

    for (ChannelMap::const_iterator i = _channels.begin();
         i != _channels.end();
         ++i)
    {
        RenamingMap::const_iterator j = oldToNewNames.find (i->first);
        std::string newName = (j == oldToNewNames.end())? i->first: j->second;

        if (newNames.find (newName) != newNames.end())
        {
            THROW (ArgExc, "Cannot rename image channels.  More than one "
                           "channel would be named \"" << newName << "\".");
        }
        else
        {
            newNames.insert (newName);
        }
    }

    try
    {
        renameChannelsInMap (oldToNewNames, _channels);

        for (int y = 0; y < _levels.height(); ++y)
            for (int x = 0; x < _levels.width(); ++x)
                if (_levels[y][x])
                    _levels[y][x]->renameChannels (oldToNewNames);
    }
    catch (...)
    {
        clearChannels();
        throw;
    }
}


ImageLevel &
Image::level (int l)
{
    return level (l, l);
}


const ImageLevel &
Image::level (int l) const
{
    return level (l, l);
}


ImageLevel &
Image::level (int lx, int ly)
{
    if (!levelNumberIsValid (lx, ly))
    {
        THROW (ArgExc,
               "Cannot access image level with invalid "
               "level number (" << lx << ", " << ly << ").");
    }

    return *_levels[ly][lx];
}


const ImageLevel &
Image::level (int lx, int ly) const
{
    if (!levelNumberIsValid (lx, ly))
    {
        THROW (ArgExc,
               "Cannot access image level with invalid "
               "level number (" << lx << ", " << ly << ").");
    }

    return *_levels[ly][lx];
}


bool
Image::levelNumberIsValid (int lx, int ly) const
{
    return lx >= 0 && lx < _levels.width() &&
           ly >= 0 && ly < _levels.height() &&
           _levels[ly][lx] != 0;
}


void
Image::clearLevels ()
{
    _dataWindow = Box2i (V2i (0, 0), V2i (-1, -1));

    for (int y = 0; y < _levels.height(); ++y)
        for (int x = 0; x < _levels.width(); ++x)
            delete _levels[y][x];

    _levels.resizeErase (0, 0);
}


Image::ChannelInfo::ChannelInfo
    (PixelType type,
     int xSampling,
     int ySampling,
     bool pLinear)
:
    type (type),
    xSampling (xSampling),
    ySampling (ySampling),
    pLinear (pLinear)
{
    // empty
}



OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT