/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program 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 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

//
// 3DSMax HeadSpin exporter
//
#include "HeadSpin.h"
#include "Max.h"
#include "istdplug.h"
#include "Notify.h"
#include <commdlg.h>
#include "bmmlib.h"
#include "INode.h"

#include "plConvert.h"
#include "hsResMgr.h"
#include "hsTemplates.h"

#include "hsConverterUtils.h"
#include "hsControlConverter.h"
#include "plMeshConverter.h"
#include "hsMaterialConverter.h"
#include "plLayerConverter.h"
#include "UserPropMgr.h"
#include "hsStringTokenizer.h"
#include "MaxExport/plErrorMsg.h"
#include "hsVertexShader.h"
#include "plLightMapGen.h"
#include "plBitmapCreator.h"
#include "plgDispatch.h"

#include "pnMessage/plTimeMsg.h"
#include "MaxComponent/plComponent.h"
#include "MaxMain/plMaxNode.h"
#include "plMessage/plNodeCleanupMsg.h"
#include "pnSceneObject/plSceneObject.h"
#include "MaxComponent/plClusterComponent.h"

#include "plPhysX/plSimulationMgr.h"
#include "MaxMain/plPhysXCooking.h"
#include "MaxExport/plExportProgressBar.h"


#include "MaxMain/plGetLocationDlg.h"

#ifdef HS_DEBUGGING
#define HS_NO_TRY
#endif

plConvert::plConvert() : fWarned(0)
{
}

plConvert& plConvert::Instance()
{
    static plConvert theInstance;
    return theInstance;
}

hsBool plConvert::IOK()
{
    return (!fQuit && !fpErrorMsg->IsBogus() ) ? true: false;
}

hsBool plConvert::Convert()
{
#ifndef HS_NO_TRY
    try
#endif
    {
    fSettings->fReconvert = false;
    fWarned = 0;

    fInterface->SetIncludeXRefsInHierarchy(TRUE);

    plMaxNode *pNode = (plMaxNode *)fInterface->GetRootNode();
    AddMessageToQueue(new plTransformMsg(nil, nil, nil, nil));
    AddMessageToQueue(new plDelayedTransformMsg(nil, nil, nil, nil));

    IFindDuplicateNames();

    plExportProgressBar bar;
    hsBool  retVal  = true; // sometime, we might look at this

    if( !IAutoClusterRecur(pNode) )
    {
        fQuit = true;
    }

    if(IOK())
    {
        bar.Start("Clear Old Data");
        retVal = pNode->DoAllRecur( &plMaxNode::ClearData, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        bar.Start("Convert Validate");
        retVal = pNode->DoRecur( &plMaxNode::ConvertValidate, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        bar.Start("Components Initialize");
        retVal = pNode->DoRecur( &plMaxNode::SetupPropertiesPass, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        bar.Start("Prepare for skinning");
        retVal = pNode->DoRecur( &plMaxNode::PrepareSkin, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        bar.Start("Make Scene Object");
        retVal = pNode->DoRecur( &plMaxNode::MakeSceneObject, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        bar.Start("Make Physical");
        plPhysXCooking::Init();
        retVal = pNode->DoRecur( &plMaxNode::MakePhysical, fpErrorMsg, fSettings, &bar );
        plPhysXCooking::Shutdown();
    }
    if(IOK())
    {
        bar.Start("Component Preconvert");
        retVal = pNode->DoRecur( &plMaxNode::FirstComponentPass, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        bar.Start("Make Controller");
        retVal = pNode->DoRecur( &plMaxNode::MakeController, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {   // must be before mesh
        bar.Start("Make Coord Interface");
        retVal = pNode->DoRecur( &plMaxNode::MakeCoordinateInterface, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {   // must be after coord interface but before pool data is created.
        bar.Start("Make Connections");
        retVal = pNode->DoRecur( &plMaxNode::MakeParentOrRoomConnection, fpErrorMsg, fSettings, &bar );
    }

    if(IOK())
    {   // must be before simulation
        bar.Start("Make Mesh");
        retVal = pNode->DoRecur( &plMaxNode::MakeMesh, fpErrorMsg, fSettings, &bar );
    }

    if(IOK())
    {   // doesn't matter when
        bar.Start("Make Light");
        retVal = pNode->DoRecur( &plMaxNode::MakeLight, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {   // doesn't matter when
        bar.Start("Make Occluder");
        retVal = pNode->DoRecur( &plMaxNode::MakeOccluder, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {   // must be after mesh
        bar.Start("Make Modifiers");
        retVal = pNode->DoRecur( &plMaxNode::MakeModifiers, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        bar.Start("Convert Components");
        retVal = pNode->DoRecur( &plMaxNode::ConvertComponents, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        // do this after convert
        bar.Start("Set Up Interface References");
        retVal = pNode->DoRecur( &plMaxNode::MakeIfaceReferences, fpErrorMsg, fSettings, &bar );
    }

    if(IOK() && fSettings->fDoPreshade)
    {
        // These need to be opened after the components have had a chance to flag the MaxNodes
        plLightMapGen::Instance().Open(fInterface, fInterface->GetTime(), fSettings->fDoLightMap);
        hsVertexShader::Instance().Open();

        bar.Start("Preshade Geometry");
        retVal = pNode->DoRecur( &plMaxNode::ShadeMesh, fpErrorMsg, fSettings, &bar );

        plLightMapGen::Instance().Close();
        hsVertexShader::Instance().Close();
    }

    if(IOK())
    {
        // Do this next-to-last--allows all the components to free up any temp data they kept around
        bar.Start("Component DeInit");
        retVal = pNode->DoRecur( &plMaxNode::DeInitComponents, fpErrorMsg, fSettings, &bar );
    }
    if(IOK())
    {
        // Do this very last--it de-inits and frees all the maxNodeDatas lying around
        bar.Start("Clear MaxNodeDatas");
        retVal = pNode->DoAllRecur( &plMaxNode::ClearMaxNodeData, fpErrorMsg, fSettings, &bar );
    }
//  fpErrorMsg->Set();

    DeInit();

    fInterface->SetIncludeXRefsInHierarchy(FALSE);

    return IOK();
    }
#ifndef HS_NO_TRY
    catch(plErrorMsg& err)
    {
        DeInit();
        fInterface->SetIncludeXRefsInHierarchy(FALSE);
        err.Show();
        return false;
    }
    catch(...)
    {
        DeInit();
        fInterface->SetIncludeXRefsInHierarchy(FALSE);
      fpErrorMsg->Set(true, "plConvert", "Unknown error during convert\n");
      fpErrorMsg->Show();
      return false;
    }
#endif
}

//#include "MaxMain/plMaxNodeData.h"
//#include <set>

hsBool ConvertList(hsTArray<plMaxNode*>& nodes, PMaxNodeFunc p, plErrorMsg *errMsg, plConvertSettings *settings)
{
    for (int i = 0; i < nodes.Count(); i++)
    {
        (nodes[i]->*p)(errMsg, settings);
        
        if (errMsg && errMsg->IsBogus())
            return false;
    }

    return true;
}

hsBool plConvert::Convert(hsTArray<plMaxNode*>& nodes)
{
#ifndef HS_NO_TRY
    try
#endif
    {
    fSettings->fReconvert = true;

    hsBool retVal = true;

    if (IOK())
        retVal = ConvertList(nodes, &plMaxNode::ClearData, fpErrorMsg, fSettings);

    if(IOK())
        retVal = ConvertList(nodes, &plMaxNode::ConvertValidate,         fpErrorMsg, fSettings);
    if(IOK())
        retVal = ConvertList(nodes, &plMaxNode::SetupPropertiesPass,     fpErrorMsg, fSettings);
    if(IOK())   
        retVal = ConvertList(nodes, &plMaxNode::PrepareSkin,             fpErrorMsg, fSettings);
    if(IOK())   
        retVal = ConvertList(nodes, &plMaxNode::MakeSceneObject,         fpErrorMsg, fSettings);
    if(IOK())   
        retVal = ConvertList(nodes, &plMaxNode::FirstComponentPass,      fpErrorMsg, fSettings);
    if(IOK())   
        retVal = ConvertList(nodes, &plMaxNode::MakeController,          fpErrorMsg,fSettings);
    if(IOK())   
        retVal = ConvertList(nodes, &plMaxNode::MakeCoordinateInterface, fpErrorMsg, fSettings);// must be before mesh
    if(IOK())
        retVal = ConvertList(nodes, &plMaxNode::MakeParentOrRoomConnection,  fpErrorMsg, fSettings); // after coord, before mesh (or any other pool data).

    // These shouldn't be opened until the components have had a chance to flag the MaxNodes
    plLightMapGen::Instance().Open(fInterface, fInterface->GetTime(), fSettings->fDoLightMap);
    hsVertexShader::Instance().Open();

    if(IOK())   
        retVal = ConvertList(nodes, &plMaxNode::MakeMesh, fpErrorMsg, fSettings);    // must be before simulation

    if(IOK())                       // doesn't matter when
        retVal = ConvertList(nodes, &plMaxNode::MakeLight,                   fpErrorMsg, fSettings);
    if(IOK())                       // doesn't matter when
        retVal = ConvertList(nodes, &plMaxNode::MakeOccluder,                fpErrorMsg, fSettings);
    if(IOK())                       // must be after mesh
        retVal = ConvertList(nodes, &plMaxNode::MakeModifiers,               fpErrorMsg, fSettings);
    if(IOK())   
        retVal = ConvertList(nodes, &plMaxNode::ConvertComponents,           fpErrorMsg, fSettings);
    if(IOK())
        retVal = ConvertList(nodes, &plMaxNode::ShadeMesh,                   fpErrorMsg, fSettings);

    // These may be used by components, so don't close them till the end.
    plLightMapGen::Instance().Close();
    hsVertexShader::Instance().Close();

    plgDispatch::MsgSend(new plTransformMsg(nil, nil, nil, nil));
    plgDispatch::MsgSend(new plDelayedTransformMsg(nil, nil, nil, nil));
    DeInit();

    return IOK();   
    }
#ifndef HS_NO_TRY
    catch(plErrorMsg& err)
    {
        err.Show();
        return false;
    }
    catch(...)
    {
        hsMessageBox("Unknown error during convert", "plConvert", hsMessageBoxNormal);
        return false;
    }
#endif
}

hsBool plConvert::Init(Interface *ip, plErrorMsg* msg, plConvertSettings *settings)
{
    fInterface = ip;
    fpErrorMsg = msg;
    fSettings = settings;

    // Move us to time 0, so that things like initial transforms are always consistent with the 0th frame.
    // This saves our asses from things like the patch-generation process later
    ip->SetTime( 0, false );

    hsConverterUtils::Instance().Init(true, fpErrorMsg);
    plBitmapCreator::Instance().Init(true, fpErrorMsg);
    hsMaterialConverter::Instance().Init(true, fpErrorMsg);
    hsControlConverter::Instance().Init(fpErrorMsg);
    plMeshConverter::Instance().Init(true, fpErrorMsg);
    plLayerConverter::Instance().Init(true, fpErrorMsg);

    plGetLocationDlg::Instance().ResetDefaultLocation();

    fQuit = false;

    return true;
}

void plConvert::DeInit()
{
    // Undo any autogenerated clusters.
    IAutoUnClusterRecur(fInterface->GetRootNode());

    // clear out the message queue
    for (int i = 0; i < fMsgQueue.Count(); i++)
        plgDispatch::MsgSend(fMsgQueue[i]);

    fMsgQueue.Reset();

    hsControlConverter::Instance().DeInit();
    plMeshConverter::Instance().DeInit();
    plLayerConverter::Instance().DeInit();
    // Moving this to the end of writing the files out. Yes, this means that any unused mipmaps still get
    // written to disk, including ones loaded on preload, but it's the only way to get shared texture pages
    // to work without loading in the entire age worth of reffing objects. - 5.30.2002 mcn
//  plBitmapCreator::Instance().DeInit();

    plNodeCleanupMsg *clean = new plNodeCleanupMsg();
    plgDispatch::MsgSend( clean );
}

void plConvert::AddMessageToQueue(plMessage* msg)
{
    fMsgQueue.Append(msg);
}

void plConvert::SendEnvironmentMessage(plMaxNode* pNode, plMaxNode* efxRegion, plMessage* msg, hsBool ignorePhysicals )
{
    for (int i = 0; i < pNode->NumberOfChildren(); i++)
        SendEnvironmentMessage((plMaxNode *)pNode->GetChildNode(i), efxRegion, msg, ignorePhysicals );

    // don't call ourself...
    if (pNode == efxRegion)
        return;

    // send the scene object this message:
    if (efxRegion->Contains( ((INode*)pNode)->GetNodeTM(hsConverterUtils::Instance().GetTime(pNode->GetInterface())).GetRow(3)) &&
        pNode->GetSceneObject() && ( !ignorePhysicals || !pNode->IsPhysical() ) )
        msg->AddReceiver( pNode->GetSceneObject()->GetKey() );
}

plMaxNode* plConvert::GetRootNode() 
{
    return (plMaxNode *)fInterface->GetRootNode();
}

BOOL plConvert::IAutoClusterRecur(INode* node)
{
    plMaxNode* maxNode = (plMaxNode*)node;
    plComponentBase* comp = maxNode->ConvertToComponent();

    if( comp && (comp->ClassID() == CLUSTER_COMP_CID) )
    {
        plClusterComponent* clust = (plClusterComponent*)comp;
        // Cluster decides if it needs autogen
        if( clust->AutoGen(fpErrorMsg) )
            return false;
    }
    int i;
    for( i = 0; i < node->NumberOfChildren(); i++ )
    {
        if( !IAutoClusterRecur(node->GetChildNode(i)) )
            return false;
    }
    return true;
}

BOOL plConvert::IAutoUnClusterRecur(INode* node)
{
    plMaxNode* maxNode = (plMaxNode*)node;
    plComponentBase* comp = maxNode->ConvertToComponent();

    if( comp && (comp->ClassID() == CLUSTER_COMP_CID) )
    {
        plClusterComponent* clust = (plClusterComponent*)comp;
        // Cluster remembers whether it was autogen'd.
        clust->AutoClear(fpErrorMsg);
    }
    int i;
    for( i = 0; i < node->NumberOfChildren(); i++ )
    {
        IAutoUnClusterRecur(node->GetChildNode(i));
    }
    return true;
}

bool plConvert::IFindDuplicateNames()
{
    INode *node = fInterface->GetRootNode();
    const char *name = ISearchNames(node, node);

    if (!name)
        return false;
    
    fpErrorMsg->Set(true,
        "Error in Conversion of Scene Objects",
        "Two objects in the scene share the name '%s'.\nUnique names are necessary during the export process.\n",
        name
        );
    fpErrorMsg->Show();

    return true;
}

// Recursivly search nodes for duplicate names, and return when one is found
const char *plConvert::ISearchNames(INode *node, INode *root)
{
    int count = ICountNameOccurances(root, node->GetName());
    if (count > 1)
        return node->GetName();

    for (int i = 0; i < node->NumberOfChildren(); i++)
    {
        const char *name = ISearchNames(node->GetChildNode(i), root);
        if (name)
            return name;
    }

    return nil;
}

// Recursivly search nodes for this name, and return the number of times found
int plConvert::ICountNameOccurances(INode *node, const char *name)
{
    int count = 0;

    if (!stricmp(name, node->GetName()))
        count++;

    for (int i = 0; i < node->NumberOfChildren(); i++)
        count += ICountNameOccurances(node->GetChildNode(i), name);

    return count;
}