/* OpenSceneGraph example, osgphotoalbum.
*
*  Permission is hereby granted, free of charge, to any person obtaining a copy
*  of this software and associated documentation files (the "Software"), to deal
*  in the Software without restriction, including without limitation the rights
*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
*  copies of the Software, and to permit persons to whom the Software is
*  furnished to do so, subject to the following conditions:
*
*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
*  THE SOFTWARE.
*/

#include "PhotoArchive.h"

#include <osg/GLU>
#include <osg/Notify>
#include <osgDB/ReadFile>
#include <osgDB/fstream>

#include <osg/GraphicsContext>

#include <iostream>
#include <string.h>

const std::string FILE_IDENTIFER("osgphotoalbum photo archive");

class MyGraphicsContext {
    public:
        MyGraphicsContext()
        {
            osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
            traits->x = 0;
            traits->y = 0;
            traits->width = 1;
            traits->height = 1;
            traits->windowDecoration = false;
            traits->doubleBuffer = false;
            traits->sharedContext = 0;
            traits->pbuffer = true;

            _gc = osg::GraphicsContext::createGraphicsContext(traits.get());

            if (!_gc)
            {
                osg::notify(osg::NOTICE)<<"Failed to create pbuffer, failing back to normal graphics window."<<std::endl;
                
                traits->pbuffer = false;
                _gc = osg::GraphicsContext::createGraphicsContext(traits.get());
            }

            if (_gc.valid()) 
            
            
            {
                _gc->realize();
                _gc->makeCurrent();
                std::cout<<"Realized window"<<std::endl;
            }
        }
        
        bool valid() const { return _gc.valid() && _gc->isRealized(); }
        
    private:
        osg::ref_ptr<osg::GraphicsContext> _gc;
};

PhotoArchive::PhotoArchive(const std::string& filename)
{
    readPhotoIndex(filename);
}

bool PhotoArchive::readPhotoIndex(const std::string& filename)
{
    osgDB::ifstream in(filename.c_str());
    
    char* fileIndentifier = new char [FILE_IDENTIFER.size()];
    in.read(fileIndentifier,FILE_IDENTIFER.size());
    if (FILE_IDENTIFER!=fileIndentifier) return false;
    
    unsigned int numPhotos;
    in.read((char*)&numPhotos,sizeof(numPhotos));

    _photoIndex.resize(numPhotos);

    in.read((char*)&_photoIndex.front(),sizeof(PhotoHeader)*numPhotos);
    
    // success record filename.
    _archiveFileName = filename;
    
    return true;
}

void PhotoArchive::getImageFileNameList(FileNameList& filenameList)
{
    for(PhotoIndexList::const_iterator itr=_photoIndex.begin();
        itr!=_photoIndex.end();
        ++itr)
    {
        filenameList.push_back(std::string(itr->filename));
    }
                        
}

osg::Image* PhotoArchive::readImage(const std::string& filename,
                                    unsigned int target_s, unsigned target_t,
                                    float& original_s, float& original_t)
{
    for(PhotoIndexList::const_iterator itr=_photoIndex.begin();
        itr!=_photoIndex.end();
        ++itr)
    {
        if (filename==itr->filename)
        {
            const PhotoHeader& photoHeader = *itr;
        
            if  (target_s <= photoHeader.thumbnail_s &&
                 target_t <= photoHeader.thumbnail_t &&
                 photoHeader.thumbnail_position != 0)
            {
                osgDB::ifstream in(_archiveFileName.c_str(),std::ios::in | std::ios::binary);
                
                // find image
                in.seekg(photoHeader.thumbnail_position);
                
                // read image header
                ImageHeader imageHeader;
                in.read((char*)&imageHeader,sizeof(ImageHeader));
                unsigned char* data = new unsigned char[imageHeader.size];
                in.read((char*)data,imageHeader.size);
                
                osg::Image* image = new osg::Image;
                image->setImage(photoHeader.thumbnail_s,photoHeader.thumbnail_t,1,
                                imageHeader.pixelFormat,imageHeader.pixelFormat,imageHeader.type,
                                data,osg::Image::USE_NEW_DELETE);
                                
                original_s =  photoHeader.original_s;
                original_t =  photoHeader.original_t;
                
                return image;
            }
                 
            if  (photoHeader.fullsize_s &&
                 photoHeader.fullsize_t &&
                 photoHeader.fullsize_position != 0)
            {
                osgDB::ifstream in(_archiveFileName.c_str(),std::ios::in | std::ios::binary);
                
                // find image
                in.seekg(photoHeader.fullsize_position);
                
                // read image header
                ImageHeader imageHeader;
                in.read((char*)&imageHeader,sizeof(ImageHeader));
                unsigned char* data = new unsigned char[imageHeader.size];
                in.read((char*)data,imageHeader.size);
                
                osg::Image* image = new osg::Image;
                image->setImage(photoHeader.fullsize_s,photoHeader.fullsize_t,1,
                                imageHeader.pixelFormat,imageHeader.pixelFormat,imageHeader.type,
                                data,osg::Image::USE_NEW_DELETE);
                                
                original_s =  photoHeader.original_s;
                original_t =  photoHeader.original_t;
                
                return image;
           }

       }

    }
    return NULL;
}

void PhotoArchive::buildArchive(const std::string& filename, const FileNameList& imageList, unsigned int thumbnailSize, unsigned int maximumSize, bool /*compressed*/)
{

    PhotoIndexList photoIndex;
    photoIndex.reserve(imageList.size());
    for(FileNameList::const_iterator fitr=imageList.begin();
        fitr!=imageList.end();
        ++fitr)
    {
        PhotoHeader header;
        
        // set name
        strncpy(header.filename,fitr->c_str(),255);
        header.filename[255]=0;
        
        header.thumbnail_s = thumbnailSize;
        header.thumbnail_t = thumbnailSize;
        header.thumbnail_position = 0;
        
        header.fullsize_s = thumbnailSize;
        header.fullsize_t = thumbnailSize;
        header.fullsize_position = 0;

        photoIndex.push_back(header);
        
    }

    std::cout<<"Building photo archive containing "<<photoIndex.size()<<" pictures"<<std::endl;

    // create a graphics context so we can do data operations
    MyGraphicsContext context;

    // open up the archive for writing to    
    osgDB::ofstream out(filename.c_str(), std::ios::out | std::ios::binary);

    // write out file indentifier.
    out.write(FILE_IDENTIFER.c_str(),FILE_IDENTIFER.size());

    unsigned int numPhotos = photoIndex.size();
    out.write((char*)&numPhotos,sizeof(unsigned int));

    // write the photo index to ensure we can the correct amount of space
    // available.
    unsigned int startOfPhotoIndex = out.tellp();
    out.write((char*)&photoIndex.front(),sizeof(PhotoHeader)*photoIndex.size());

    unsigned int photoCount=1;    
    for(PhotoIndexList::iterator pitr=photoIndex.begin();
        pitr!=photoIndex.end();
        ++pitr,++photoCount)
    {
        PhotoHeader& photoHeader = *pitr;
        
        
        std::cout<<"Processing image "<<photoCount<<" of "<< photoIndex.size()<<" filename="<< photoHeader.filename << std::endl;
        std::cout<<"    reading image...";std::cout.flush();
        
        osg::ref_ptr<osg::Image> image = osgDB::readImageFile(photoHeader.filename);
        
        std::cout<<"done."<< std::endl;
        
        photoHeader.original_s = image->s();
        photoHeader.original_t = image->t();

        {

            std::cout<<"    creating thumbnail image...";
            // first need to rescale image to the require thumbnail size
            unsigned int newTotalSize = 
                image->computeRowWidthInBytes(thumbnailSize,image->getPixelFormat(),image->getDataType(),image->getPacking())*
                thumbnailSize;

            // need to sort out what size to really use...
            unsigned char* newData = new unsigned char [newTotalSize];
            if (!newData)
            {
                // should we throw an exception???  Just return for time being.
                osg::notify(osg::FATAL) << "Error scaleImage() did not succeed : out of memory."<<newTotalSize<<std::endl;
                return;
            }

            glPixelStorei(GL_PACK_ALIGNMENT,image->getPacking());
            glPixelStorei(GL_UNPACK_ALIGNMENT,image->getPacking());

            GLint status = gluScaleImage(image->getPixelFormat(),
                image->s(),
                image->t(),
                image->getDataType(),
                image->data(),
                thumbnailSize,
                thumbnailSize,
                image->getDataType(),
                newData);

            if (status!=0)
            {
               delete [] newData;

                osg::notify(osg::WARN) << "Error scaleImage() did not succeed : errorString = "<<gluErrorString((GLenum)status)<<std::endl;
            }
    
            // now set up the photo header.
            photoHeader.thumbnail_s = thumbnailSize;
            photoHeader.thumbnail_t = thumbnailSize;
            photoHeader.thumbnail_position = (unsigned int)out.tellp();

            // set up image header
            ImageHeader imageHeader;
            imageHeader.s = thumbnailSize;
            imageHeader.t = thumbnailSize;
            imageHeader.internalTextureformat = image->getInternalTextureFormat();
            imageHeader.pixelFormat = image->getPixelFormat();
            imageHeader.type = image->getDataType();
            imageHeader.size = newTotalSize;

            // write out image header and image data.
            out.write((char*)&imageHeader,sizeof(ImageHeader));
            out.write((char*)newData,imageHeader.size);
            
            delete [] newData;

            std::cout<<"done."<< std::endl;

        }
        
        {
            std::cout<<"    creating fullsize image...";std::cout.flush();


            photoHeader.fullsize_s = osg::minimum((unsigned int)image->s(),maximumSize);
            photoHeader.fullsize_t = osg::minimum((unsigned int)image->t(),maximumSize);
            photoHeader.fullsize_position = (unsigned int)out.tellp();

            // first need to rescale image to the require thumbnail size
            unsigned int newTotalSize = 
                image->computeRowWidthInBytes(photoHeader.fullsize_s,image->getPixelFormat(),image->getDataType(),image->getPacking())*
                photoHeader.fullsize_t;

            // need to sort out what size to really use...
            unsigned char* newData = new unsigned char [newTotalSize];
            if (!newData)
            {
                // should we throw an exception???  Just return for time being.
                osg::notify(osg::FATAL) << "Error scaleImage() did not succeed : out of memory."<<newTotalSize<<std::endl;
                return;
            }

            glPixelStorei(GL_PACK_ALIGNMENT,image->getPacking());
            glPixelStorei(GL_UNPACK_ALIGNMENT,image->getPacking());

            GLint status = gluScaleImage(image->getPixelFormat(),
                image->s(),
                image->t(),
                image->getDataType(),
                image->data(),
                photoHeader.fullsize_s,
                photoHeader.fullsize_t,
                image->getDataType(),
                newData);

            if (status!=0)
            {
               delete [] newData;

                osg::notify(osg::WARN) << "Error scaleImage() did not succeed : errorString = "<<gluErrorString((GLenum)status)<<std::endl;
            }

            ImageHeader imageHeader;
            imageHeader.s = photoHeader.fullsize_s;
            imageHeader.t = photoHeader.fullsize_t;
            imageHeader.internalTextureformat = image->getInternalTextureFormat();
            imageHeader.pixelFormat = image->getPixelFormat();
            imageHeader.type = image->getDataType();
            imageHeader.size = newTotalSize;

            out.write((char*)&imageHeader,sizeof(ImageHeader));
            out.write((char*)newData,imageHeader.size);
            //out.write((char*)image->data(),imageHeader.size);

            delete [] newData;

            std::cout<<"done."<< std::endl;
        }
        
    }

    // rewrite photo index now it has the correct sizes set
    out.seekp(startOfPhotoIndex);
    out.write((char*)&photoIndex.front(),sizeof(PhotoHeader)*photoIndex.size());

}
