// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.


#include "std_afx.h"
#include "object_viewer.h"
#include "texture_anim_dlg.h"
#include "attrib_dlg.h"
#include "texture_chooser.h"
#include "nel/3d/ps_particle.h"
#include "nel/3d/ps_particle_basic.h"
#include "nel/3d/texture_grouped.h"
#include "nel/3d/texture_file.h"


#include "nel/misc/smart_ptr.h"
#include "multi_tex_dlg.h"


/////////////////////////////////////////////////////////////////////////////
// CTextureAnimDlg dialog


CTextureAnimDlg::CTextureAnimDlg(CParticleWorkspace::CNode *ownerNode, 
								 NL3D::CPSTexturedParticle *p,
								 NL3D::CPSMultiTexturedParticle *mtp /*= NULL*/) 
								: _Node(ownerNode),
								  _EditedParticle(p),
								  _TextureChooser(NULL),
								  _TextureIndexDialog(NULL),
								  _MTP(mtp),
								  _MultiTexDlg(NULL)
{	
	nlassert(p);
	//{{AFX_DATA_INIT(CTextureAnimDlg)	
	m_EnableTextureAnim = p->getTextureGroup() ? TRUE : FALSE;
	m_MultiTexEnable = FALSE;
	//}}AFX_DATA_INIT
}

CTextureAnimDlg::~CTextureAnimDlg()
{	
	if (_MultiTexDlg)
	{
		_MultiTexDlg->DestroyWindow();
		delete _MultiTexDlg;
	}
	cleanCtrl();	
}



BOOL CTextureAnimDlg::EnableWindow( BOOL bEnable)
{
	if (_TextureChooser) _TextureChooser->EnableWindow(bEnable);	
	GetDlgItem(IDC_CHOOSE_TEXTURES)->EnableWindow(bEnable & m_EnableTextureAnim);
	GetDlgItem(IDC_ENABLE_TEXTURE_ANIM)->EnableWindow(bEnable);
	if (_MTP)
	{		
		((CButton *) GetDlgItem(IDC_MULTITEX))->EnableWindow(bEnable);
		GetDlgItem(IDC_EDIT_MULTITEX)->EnableWindow(bEnable & (_MTP->isMultiTextureEnabled() ? 1 : 0));			
	}
	if (_TextureIndexDialog)
	{
		_TextureIndexDialog->EnableWindow(bEnable);
	}
	return CDialog::EnableWindow(bEnable);
}

void CTextureAnimDlg::init(sint x, sint y, CWnd *pParent)
{
	Create(IDD_TEXTURE_ANIM, pParent); 
	RECT r;
	GetClientRect(&r);
	MoveWindow(x, y, x + r.right, y + r.bottom);
	setupCtrl();
	if (!_MTP)
	{
		GetDlgItem(IDC_MULTITEX)->ShowWindow(FALSE);
		GetDlgItem(IDC_EDIT_MULTITEX)->ShowWindow(FALSE);
		GetDlgItem(IDC_MULTITEX_BORDER)->ShowWindow(FALSE);
	}
	ShowWindow(SW_SHOW);
}

void CTextureAnimDlg::cleanCtrl(void)
{
	if (_TextureChooser)
	{
		_TextureChooser->DestroyWindow();
		delete _TextureChooser;
		_TextureChooser = NULL;
	}
	if (_TextureIndexDialog)
	{
		_TextureIndexDialog->DestroyWindow();
		delete _TextureIndexDialog;
		_TextureIndexDialog = NULL;
	}
}


void CTextureAnimDlg::setupCtrl(void)
{
	// is there an animation ?
	if (_EditedParticle->getTextureGroup())
	{
		if (!_TextureIndexDialog)
		{
			
			_TextureIndexDialog = new CAttribDlgInt("TEXTURE_INDEX", _Node, 0, _EditedParticle->getTextureGroup()->getNbTextures() - 1);			
			_TextureIndexWrapper.P = _EditedParticle;
			_TextureIndexDialog->setWrapper(&_TextureIndexWrapper );			
			_TextureIndexDialog->setSchemeWrapper(&_TextureIndexWrapper );

			HBITMAP bmh = LoadBitmap(::AfxGetInstanceHandle(), MAKEINTRESOURCE(IDB_ANIM_SEQUENCE));
			_TextureIndexDialog->init(bmh, 0, 30, this);		
			m_ChooseTextures.EnableWindow(TRUE);
		}
		if (_MTP)
		{
			int display = _MTP->isMultiTextureEnabled() ? 1 : 0;
			m_MultiTexEnable = display;
			GetDlgItem(IDC_EDIT_MULTITEX)->EnableWindow(display);		
			GetDlgItem(IDC_MULTITEX)->EnableWindow(TRUE);
		}	
	}
	else // no animation, just show a texture chooser
	{
		_TextureChooser = new CTextureChooser(_MTP, _Node);			
		_TextureWrapper.P = _EditedParticle;
		_TextureChooser->setWrapper(&_TextureWrapper);
		_TextureChooser->init(0, 30, this);
		m_ChooseTextures.EnableWindow(FALSE);

		if (_MTP)
		{
			
			((CButton *) GetDlgItem(IDC_MULTITEX))->SetCheck(0);
			GetDlgItem(IDC_EDIT_MULTITEX)->EnableWindow(0);		
			GetDlgItem(IDC_MULTITEX)->EnableWindow(0);
		}	
	}

	UpdateData(FALSE);
}




void CTextureAnimDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CTextureAnimDlg)
	DDX_Control(pDX, IDC_CHOOSE_TEXTURES, m_ChooseTextures);
	DDX_Check(pDX, IDC_ENABLE_TEXTURE_ANIM, m_EnableTextureAnim);
	DDX_Check(pDX, IDC_MULTITEX, m_MultiTexEnable);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CTextureAnimDlg, CDialog)
	//{{AFX_MSG_MAP(CTextureAnimDlg)
	ON_BN_CLICKED(IDC_CHOOSE_TEXTURES, OnChooseTextures)
	ON_BN_CLICKED(IDC_ENABLE_TEXTURE_ANIM, OnEnableTextureAnim)
	ON_BN_CLICKED(IDC_MULTITEX, OnMultiTex)
	ON_BN_CLICKED(IDC_EDIT_MULTITEX, OnEditMultitex)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTextureAnimDlg message handlers

void CTextureAnimDlg::OnChooseTextures() 
{
	
	_GradientInterface.P = _EditedParticle;	
	CValueGradientDlg vd(&_GradientInterface, _Node, false, this, NULL, false, 1);	
	_GradientInterface.Dlg = &vd;
	vd.DoModal();	
}

void CTextureAnimDlg::OnEnableTextureAnim() 
{
	UpdateData();
	if (!m_EnableTextureAnim)
	{
		_EditedParticle->setTexture(NULL);
	}
	else
	{
		// put a dummy texture as a first texture
		NLMISC::CSmartPtr<NL3D::ITexture> tex = (NL3D::ITexture *) new NL3D::CTextureFile(std::string(""));
		NL3D::CTextureGrouped *tg = new NL3D::CTextureGrouped;
		tg->setTextures(&tex, 1);
		_EditedParticle->setTextureGroup(tg);
		_EditedParticle->setTextureIndex(0);		
	}
	cleanCtrl();
	setupCtrl();
	updateModifiedFlag();
}


////////////////////////////////////////////////////////
// CTextureAnimDlg::CGradientInterface implementation //
////////////////////////////////////////////////////////



CEditAttribDlg *CTextureAnimDlg::CGradientInterface::createDialog(uint index, CValueGradientDlg *grad, CParticleWorkspace::CNode *ownerNode)
{
	CTextureChooser *tc = new CTextureChooser(NULL, ownerNode);
	_TextureWrapper.P = P;
	_TextureWrapper.Dlg = Dlg;
	_TextureWrapper.Index = index;
	_TextureWrapper.OwnerNode = ownerNode;
	tc->setWrapper(&_TextureWrapper);
	return tc;
}
void CTextureAnimDlg::CGradientInterface::modifyGradient(TAction action, uint index)
{
	nlassert(P);
	nlassert(P->getTextureGroup());
	std::vector< NLMISC::CSmartPtr<NL3D::ITexture> > textureList;
	textureList.resize(P->getTextureGroup()->getNbTextures());
	P->getTextureGroup()->getTextures(&textureList[0]);

	switch(action)
	{
		case IValueGradientDlgClient::Add:
		{
			// we duplicate the last texture, so that they have the same size
			NLMISC::CSmartPtr<NL3D::ITexture> lastTex = textureList[textureList.size() - 1];
			textureList.push_back(lastTex);		
		}
		break;
		case IValueGradientDlgClient::Insert:
		{
			// we duplicate the current texture, so that they have the same size
			NLMISC::CSmartPtr<NL3D::ITexture> tex = textureList[index];
			textureList.insert(textureList.begin() + index, tex);			
		}			
		break;
		case IValueGradientDlgClient::Delete:		
			textureList.erase(textureList.begin() + index);						
		break;
	}

	P->getTextureGroup()->setTextures(&textureList[0], (uint)textureList.size());
}
void CTextureAnimDlg::CGradientInterface::displayValue(CDC *dc, uint index, sint x, sint y)
{
	const uint tSize = 20;
	NLMISC::CSmartPtr<NL3D::ITexture> tex = P->getTextureGroup()->getTexture(index);
	tex->generate();

	// make copy of the texture
	NLMISC::CBitmap cb(* ((NL3D::ITexture *) tex));

	cb.convertToType(NLMISC::CBitmap::RGBA);
	cb.resample(tSize, tSize);
	

	uint32 *dat  = (uint32 *) &(cb.getPixels()[0]);

	HBITMAP myBitmap = ::CreateBitmap(tSize, tSize, 1, 32, dat);
	
	HDC bitmapDc = ::CreateCompatibleDC(dc->m_hDC);
	HGDIOBJ old = ::SelectObject(bitmapDc, myBitmap);

	// display the texture
	::BitBlt(dc->m_hDC, x + 20, y + 10, tSize, tSize, bitmapDc, 0, 0, SRCCOPY);

	// free resources
	::SelectObject(bitmapDc, old);
	::DeleteDC(bitmapDc);
	::DeleteObject(myBitmap);

}
uint32 CTextureAnimDlg::CGradientInterface::getSchemeSize(void) const
{
	nlassert(P->getTextureGroup());
	return P->getTextureGroup()->getNbTextures();
}
uint32 CTextureAnimDlg::CGradientInterface::getNbSteps(void) const
{
	return 1;
}
void CTextureAnimDlg::CGradientInterface::setNbSteps(uint32 value)
{
	// this should never be called, as we don't allow nbsteps to be called
	nlassert(false);
}


///////////////////////////////////////////////////////////////////////////
// CTextureAnimDlg::CGradientInterface::CTextureWrapper implementation //
///////////////////////////////////////////////////////////////////////////


NL3D::ITexture *CTextureAnimDlg::CGradientInterface::CTextureWrapper::get(void)
{
	nlassert(P);
	nlassert(P->getTextureGroup());
	return P->getTextureGroup()->getTexture(Index);
}
void CTextureAnimDlg::CGradientInterface::CTextureWrapper::set(NL3D::ITexture *t)
{
	nlassert(P);
	nlassert(P->getTextureGroup());

	// if a texture is added, it must have the same size than other textures
	if (P->getTextureGroup()->getNbTextures() > 1)
	{
		NLMISC::CSmartPtr<NL3D::ITexture> tex = P->getTextureGroup()->getTexture(0);
		tex->generate();
		t->generate();

		if (t->getWidth() != tex->getWidth() || t->getHeight() != tex->getHeight())
		{
			::MessageBox(NULL, "All textures must have the same size !", "error", MB_OK);
			return;
		}

		if (t->PixelFormat != tex->PixelFormat)
		{
			::MessageBox(NULL, "All textures must have the same pixel format !", "error", MB_OK);
			return;
		}
	}

	std::vector< NLMISC::CSmartPtr<NL3D::ITexture> > textureList;
	textureList.resize(P->getTextureGroup()->getNbTextures());
	P->getTextureGroup()->getTextures(&textureList[0]);

	textureList[Index] = t;


	P->getTextureGroup()->setTextures(&textureList[0], (uint)textureList.size());
	
	Dlg->invalidateGrad();
}

void CTextureAnimDlg::OnMultiTex() 
{
	UpdateData();
	_MTP->enableMultiTexture(m_MultiTexEnable ? true : false /* VC WARNING */);
	setupCtrl();
	updateModifiedFlag();
}

void CTextureAnimDlg::childPopupClosed(CWnd *child)
{
	nlassert(_MultiTexDlg == child);
	_MultiTexDlg->DestroyWindow();
	delete _MultiTexDlg;
	_MultiTexDlg = NULL;
	EnableWindow(TRUE);
}

void CTextureAnimDlg::OnEditMultitex() 
{	
	EnableWindow(FALSE);
	_MultiTexDlg = new 	CMultiTexDlg(_Node, _MTP, this, this);
	_MultiTexDlg->init(this);
}