///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2012, Weta Digital Ltd
// 
// 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 Weta Digital 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.
//
///////////////////////////////////////////////////////////////////////////


#ifndef INCLUDED_IMF_PARTHELPER_H
#define INCLUDED_IMF_PARTHELPER_H

//-----------------------------------------------------------------------------
//
//	Functions to help split channels into separate parts: provide a list of
//      channels, with desired views. call SplitChannels to assign a part to each
//      layer, or correct the name of the channel.
//      Also can enumerate the parts in a file and list which parts channels are in
//
//      This is a good way to offer a 'create Multipart file' checkbox to the user in a
//      write dialog box: Populate a list of MultiViewChannelName objects,
//      call SplitChannels with whether single or multipart files are required.
//      Then write the number of parts it specifies, using internal_name for the channel
//      names in the ChannelList and FrameBuffer objects. There should be no need
//      for different codepaths for single part and multipart files
//
//      Similarly, on reading a file as a MultiPartInputFile, use GetChannelsInMultiPartFile to
//      enumerate all channels in the file, using internal_name in FrameBuffer objects
//      to read the channel
//   
//
//-----------------------------------------------------------------------------

#include "ImfForward.h"
#include "ImfNamespace.h"
#include "ImfExport.h"
#include "ImfMultiPartInputFile.h"
#include "ImfChannelList.h"
#include "ImfStringVectorAttribute.h"
#include "ImfStandardAttributes.h"
#include "ImfMultiView.h"

#include <string>
#include <map>
#include <set>

OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER

struct MultiViewChannelName{
  
public:
  std::string name;         ///< name of channel
  std::string view;         ///< view for channel
  
  int part_number;          ///< part number: updated by SplitChannels
  std::string internal_name;///< name used in headers: in singlepart mode, may contain viewname
  
  virtual ~MultiViewChannelName() {}
    
    //return layer for this channel, or "" if no layer
    std::string getLayer() const 
    {
        std::size_t q=name.rfind('.');
	if(  q==name.npos  )
	{
	    return "";
	}
	return name.substr(0,q);
    
  }

  std::string getSuffix() const
  {
        std::size_t q=name.rfind('.');
	if(  q==name.npos  )
	{
	    return name;
	}
	return name.substr(q+1);
      
  }
  
};



//
///\brief assigns individual channels to different parts based on their layer and view name
///       input is an array, list, vector etc of MultiViewChannelName objects
///       on entry, each MultiViewChannelName name/view must be set (view can be empty if not multiview)
///
///       if singlepart set, then on exit part_number will be zero, and internal_name will have view name inserted
///       otherwise, each channel will be assigned to a different part based on its layer name and view name
///
/// @param begin pointer to first MultiViewChannelName item
/// @param end   pointer to end of MultiViewChannelName item array
/// @return      total number of parts required
//

template<typename T> int 
SplitChannels(const T & begin,const T & end,bool multipart=true,const std::string & heroView="")
{
    if(!multipart)
    {
	for(T i=begin;i!=end;i++)
	{
	    i->part_number=0;
	
	    //does this have a view name set?
	    if(i->view=="")
	    {
		i->internal_name=i->name;
	    }else{
		
		std::string lname = i->getLayer();
	   
		// no layer, only non-hero views get view name in layer name
	
	    
		if(lname=="")
		{
		    if(i->view==heroView)
		    {
			i->internal_name = i->name;
		    }else{
			i->internal_name = i->view+"."+i->name;
		    }
		}else{
		    i->internal_name = lname+"."+i->view+"."+i->getSuffix();
		}
	    }
	}
	// single part created
	return 1;
    }else{
	// step 1: extract individual layers and parts
	// for each layer, enumerate which views are active
	
	std::map< std::string , std::set< std::string > > viewsInLayers;
	for(T i=begin;i!=end;i++)
	{
	    viewsInLayers[i->getLayer()].insert(i->view);
	}
	
	// step 2: assign a part number to each layer/view
	
	std::map< std::pair<std::string,std::string> , int > layerToPart;
	
	int partCount=0;
	
	for(std::map< std::string , std::set< std::string > >::const_iterator layer=viewsInLayers.begin();
	    layer!=viewsInLayers.end();layer++)
	{
	    // if this layer has a heroView, insert that first
	    bool layer_has_hero = layer->second.find(heroView)!=layer->second.end();
	    if( layer_has_hero )
	    {
		layerToPart[ std::make_pair(layer->first,heroView) ] = partCount++;
	    }
	    
	    
	    // insert other layers which aren't the hero view
	    for(std::set< std::string >::const_iterator view=layer->second.begin();
		view!=layer->second.end();view++)
	    {
		if(*view!=heroView)
		{
		    layerToPart[ std::make_pair(layer->first,*view) ] = partCount++;
		}
	    }
		
	}
	
	// step 3: update part number of each provided channel
	
	for( T i=begin;i!=end;i++)
	{
	    i->internal_name=i->name;
	    i->part_number = layerToPart[ std::make_pair(i->getLayer(),i->view) ];
	}
	
	
	// return number of parts created
	return partCount;
    }
}

//
// populate the chans vector<MultiViewChannelName> with a list of channels in the file
// and their corresponding part number
//
template<class T> void
GetChannelsInMultiPartFile(const MultiPartInputFile & file,T & chans)
{
    bool has_multiview=false;
    StringVector mview; 
    if(file.parts()==1)
    {
	if(hasMultiView(file.header(0)))
	{
	    mview=multiView(file.header(0));
	    has_multiview=true;
	}
    }
    
    for(int p=0;p<file.parts();p++)
    {
	const ChannelList & c=file.header(p).channels();
	
	std::string view="";
	if(file.header(p).hasView())
	{
	    view=file.header(p).view();
	}
	for(ChannelList::ConstIterator i=c.begin();i!=c.end();i++)
	{
	    MultiViewChannelName m;
            m.name=std::string(i.name());
	    m.internal_name=m.name;

	    if(has_multiview)
	    {
		m.view=viewFromChannelName(m.name,mview);
		m.name=removeViewName(m.internal_name,m.view);
	    }else{
		m.view=view;
	    }
            m.part_number=p;
	    chans.push_back(m);
		
	}
    }
}

OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT

#endif