/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized 
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the 
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file MultiplePrc.cpp

This file demonstrates how to programmatically create and read multiple PRC files
from a CAD assembly using HOOPS Exchange.
The input is the CAD assembly file path and a directory.
The program generates multiple PRC files from this CAD assembly.

This mode is supported for the following format: V4, V5, ProE, UG, SLDW.
With other formats, only one PRC file is generated.

***********************************************************************************************************************/

#define _CRT_SECURE_NO_DEPRECATE 1

#include <stdio.h>
#include <iostream>
#include <fstream>
#include <set>
#include <string>
#include <algorithm>

#define INITIALIZE_A3D_API
#include <A3DSDKIncludes.h>
#include <direct.h>



//######################################################################################################################
A3DVoid A3DCheckFree(A3DPtr ptr)
{
	free(ptr);
}

//######################################################################################################################
A3DPtr A3DCheckMalloc(size_t uiToAlloc)
{
	return malloc(uiToAlloc);
}

//######################################################################################################################
#define CHECK_RET(function_call) {\
	iRet = function_call; if(iRet != A3D_SUCCESS) { std::cout << "Error number=" << iRet << std::endl; return iRet; }\
}

//######################################################################################################################
std::string ExtractFileName(const A3DUTF8Char* pcIn)
{
	std::string strIn(pcIn);
	int lastSlash = (int) strIn.rfind("/");
	if(lastSlash < 0)
		lastSlash = (int) strIn.rfind("\\");
	std::string tmp = strIn.substr(size_t(lastSlash)+1);
	return tmp;
}

//######################################################################################################################
std::string ExtractFilePath(const A3DUTF8Char* pcIn)
{
	std::string strIn(pcIn);
	int lastSlash = (int) strIn.rfind("/");
	if(lastSlash < 0)
		lastSlash = (int) strIn.rfind("\\");
	std::string tmp = strIn.substr(0,size_t(lastSlash));
	return tmp;
}

//######################################################################################################################
std::string ExtractRelativePath(const A3DUTF8Char* pcIn,const A3DUTF8Char* pcDirRoot)
{
	std::string strTotalPath = ExtractFilePath(pcIn);
	std::string strRootPath(pcDirRoot);

	std::string strRelativePath;
	size_t uiTotalPathSize = strTotalPath.size();
	size_t uiRootPathSize = strRootPath.size();
	if(uiTotalPathSize > uiRootPathSize)
	{
		strRelativePath = strTotalPath.substr(uiRootPathSize);
	}
	return strRelativePath;
}

//######################################################################################################################
bool DirExists(const std::string& dirName_in)
{
	DWORD ftyp = GetFileAttributesA(dirName_in.c_str());
	if (ftyp == INVALID_FILE_ATTRIBUTES)
		return false;  

	if (ftyp & FILE_ATTRIBUTE_DIRECTORY)
		return true;  

	return false; 
}

//######################################################################################################################
std::string ExtractChoreFileName(std::string pcIn)
{
	std::string strIn(pcIn);
	int lastPoint = (int) strIn.rfind(".");
	std::string tmp = strIn.substr(0, size_t(lastPoint));
	return tmp;
}

//######################################################################################################################
int TreatFile(A3DSDKHOOPSExchangeLoader &sHoopsExchangeLoader, 
			  A3DUTF8Char** ppMappedNativePaths,
			  A3DUTF8Char** ppMappedPRCPaths, 
			  unsigned int &idxmap,
			  bool bIsAssembly,
			  char* acUTF8FileName, char* acUTF8InDir, char* acUTF8OutDir)
{
	int iRet;
	std::string strMainFileName = acUTF8FileName;

	// --- REREAD the native file without dependencies
	if(sHoopsExchangeLoader.m_psModelFile != NULL)
		A3DAsmModelFileDelete(sHoopsExchangeLoader.m_psModelFile);
	sHoopsExchangeLoader.m_psModelFile = NULL;
	A3DImport sImport2(strMainFileName.c_str());
	sImport2.m_sLoadData.m_sIncremental.m_bLoadNoDependencies = true;
	iRet = sHoopsExchangeLoader.Import(sImport2);
	if(iRet != A3D_SUCCESS && iRet != A3D_LOAD_MISSING_COMPONENTS && iRet != A3D_LOAD_MULTI_MODELS_CADFILE)
		return iRet;

	// --- EXPORT as PRC
	std::string strRelativePath = ExtractRelativePath(strMainFileName.c_str(), acUTF8InDir);
	std::string strChorefilename = ExtractFileName(strMainFileName.c_str());
	std::string strOutMainFileName = acUTF8OutDir;
	strOutMainFileName += strRelativePath;

	if( DirExists(strOutMainFileName) == false)
	{
#ifdef _MSC_VER
		_mkdir(strOutMainFileName.c_str());
#else
		mkdir(strOutMainFileName.c_str());
#endif
	}

	strOutMainFileName += "\\__";
	strOutMainFileName += strChorefilename;
	strOutMainFileName += ".prc";
	A3DExport sExport(strOutMainFileName.c_str());
	CHECK_RET(sHoopsExchangeLoader.Export(sExport));

	// update the map NATIVE-PRC
	std::string strCurrentPRCName = strMainFileName;
	strCurrentPRCName += ".prc";
	ppMappedNativePaths[idxmap] = (A3DUTF8Char*) A3DCheckMalloc(1024 * sizeof(A3DUTF8Char));
	strcpy(ppMappedNativePaths[idxmap], strMainFileName.c_str());  //acUTF8FileName if we don't want the path
	ppMappedPRCPaths[idxmap] = (A3DUTF8Char*) A3DCheckMalloc(1024 * sizeof(A3DUTF8Char));
	strcpy(ppMappedPRCPaths[idxmap], strOutMainFileName.c_str());  //strCurrentPRCName.c_str()) if we don't want the path
	idxmap++;

	CHECK_RET(A3DAsmModelFileDelete(sHoopsExchangeLoader.m_psModelFile));
	sHoopsExchangeLoader.m_psModelFile = NULL;

	return 0;
}

//######################################################################################################################
bool SortByExtensionInPath(const std::string& strExtensionAsm,
						   const std::string& strExtensionPrt,
						   const std::string& strTestingPath,
						   const std::string& strPath,
						   std::set<std::string>& a_rsCollectedAsmFilesPath, 
						   std::set<std::string>& a_rsCollectedPartFilesPath)
{
	char sDrive[256];
	char sDir[256];
	char sFileName[256];
	char sExtension[256];
	_splitpath(strTestingPath.c_str(),sDrive,sDir,sFileName,sExtension);

	std::string szExtension(sExtension);
	std::transform(szExtension.begin(), szExtension.end(), szExtension.begin(), ::tolower);

	size_t sAsm = szExtension.find(strExtensionAsm);
	size_t sPrt =  szExtension.find(strExtensionPrt);
	if(sAsm == std::string::npos && sPrt == std::string::npos)
		return false;
	if(sAsm > sPrt)
		a_rsCollectedAsmFilesPath.insert(strPath);
	else
		a_rsCollectedPartFilesPath.insert(strPath);
	return true;
}

bool SortFilePath(const A3DEModellerType& eType, const std::string& a_rsPath,
				  std::set<std::string>& a_rsCollectedAsmFilesPath, 
				  std::set<std::string>& a_rsCollectedPartFilesPath)
{
	switch(eType)
	{
	case kA3DModellerProE:
		{
			std::string szRealPath = a_rsPath;
			size_t iDotPos = a_rsPath.find_last_of('.');
			if(iDotPos != std::string::npos)
				szRealPath.erase (szRealPath.begin()+iDotPos, szRealPath.end());

			return SortByExtensionInPath("asm", "prt", szRealPath,a_rsPath,a_rsCollectedAsmFilesPath,a_rsCollectedPartFilesPath);
		}
	case kA3DModellerSlw:
		return SortByExtensionInPath("sldasm", "sldprt",a_rsPath, a_rsPath,a_rsCollectedAsmFilesPath,a_rsCollectedPartFilesPath);
	case kA3DModellerCatiaV5:
		return SortByExtensionInPath("catproduct", "catpart", a_rsPath,a_rsPath,a_rsCollectedAsmFilesPath,a_rsCollectedPartFilesPath);
	case kA3DModellerCatia:
		return SortByExtensionInPath("session", "model", a_rsPath,a_rsPath,a_rsCollectedAsmFilesPath,a_rsCollectedPartFilesPath);
	case kA3DModellerInventor:
		return SortByExtensionInPath("iam", "ipt", a_rsPath,a_rsPath,a_rsCollectedAsmFilesPath,a_rsCollectedPartFilesPath);
	case kA3DModellerSE:
		return SortByExtensionInPath("asm", "par", a_rsPath,a_rsPath,a_rsCollectedAsmFilesPath,a_rsCollectedPartFilesPath);
	default : return false;
	}
}

//######################################################################################################################
A3DStatus GetAllFileDependenciesFromFilelist(A3DUTF8Char*& a_rpcFilelist,
											 std::set<std::string>& a_rsCollectedAsmFilesPath, 
											 std::set<std::string>& a_rsCollectedPartFilesPath)
{
	std::ifstream oFile;
	oFile.open(a_rpcFilelist);

	while (!oFile.eof())
	{
		std::string szFilePath;
		getline(oFile,szFilePath);

		A3DEModellerType eType;
		A3DStatus iRet = A3DGetFileFormat(szFilePath.c_str(), &eType);
		if(iRet != A3D_SUCCESS)
			return iRet;

		if(!SortFilePath(eType,szFilePath,a_rsCollectedAsmFilesPath, a_rsCollectedPartFilesPath))
			return A3D_LOAD_MISSING_COMPONENTS;
	}

	oFile.close();

	return A3D_SUCCESS;
}

//######################################################################################################################
A3DStatus GetAllFileDependencies(std::string& a_rszCurFile,
								 A3DSDKHOOPSExchangeLoader& a_rsHoopsExchangeLoader,
								 std::set<std::string>& a_rsCollectedAsmFilesPath, 
								 std::set<std::string>& a_rsCollectedPartFilesPath)
{
	// Load file
	A3DImport sImport(a_rszCurFile.c_str());
	sImport.m_sLoadData.m_sIncremental.m_bLoadNoDependencies = true;
	A3DStatus iRet = a_rsHoopsExchangeLoader.Import(sImport);
	if(iRet != A3D_SUCCESS && iRet != A3D_LOAD_MISSING_COMPONENTS && iRet != A3D_LOAD_MULTI_MODELS_CADFILE)
		return iRet;

	// Extract sub-file names
	A3DUns32 i = 0;
	A3DUns32 nbPartFiles = 0;
	A3DUTF8Char** ppPartPaths = NULL;
	A3DUns32 nbAssemblyFiles = 0;
	A3DUTF8Char** ppAssemblyPaths = NULL;
	A3DUns32 uNbMissingFiles = 0;
	A3DUTF8Char** ppMissingFilesPaths = NULL;
	CHECK_RET(A3DAsmGetFilesPathFromModelFile(a_rsHoopsExchangeLoader.m_psModelFile, &nbPartFiles, &ppPartPaths, &nbAssemblyFiles, &ppAssemblyPaths, &uNbMissingFiles, &ppMissingFilesPaths));
	for(i = 0; i < nbAssemblyFiles; i ++)
	{
		a_rsCollectedAsmFilesPath.insert(ppAssemblyPaths[i]);
	}
	for(i = 0; i < nbPartFiles; i ++)
	{
		a_rsCollectedPartFilesPath.insert(ppPartPaths[i]);
		a_rsCollectedAsmFilesPath.erase(ppPartPaths[i]);
	}

	// Free model file
	if(a_rsHoopsExchangeLoader.m_psModelFile != NULL)
	{
		A3DAsmModelFileDelete(a_rsHoopsExchangeLoader.m_psModelFile);
		a_rsHoopsExchangeLoader.m_psModelFile = NULL;
	}

	// Load Sub assembly files
	for(i = 0; i < nbAssemblyFiles; i ++)
	{
		std::string szSubFileName(ppAssemblyPaths[i]);
		if(szSubFileName != a_rszCurFile)
		{
			GetAllFileDependencies(szSubFileName, a_rsHoopsExchangeLoader, a_rsCollectedAsmFilesPath, a_rsCollectedPartFilesPath);
		}
	}

	// Free filenames intermediate storage
	CHECK_RET(A3DAsmGetFilesPathFromModelFile(NULL, &nbPartFiles, &ppPartPaths, &nbAssemblyFiles, &ppAssemblyPaths, &uNbMissingFiles, &ppMissingFilesPaths));

	return A3D_SUCCESS;
}

//######################################################################################################################
// Main function
#ifdef _MSC_VER
int wmain(A3DInt32 iArgc, A3DUniChar** ppcArgv) 
#else
int main(int iArgc, A3DUTF8Char** ppcArgv) 
#endif
{
	if(iArgc != 4 && iArgc != 5)
	{
#ifdef _MSC_VER
		_tprintf(_T("Usage:\n %s <Roots CAD file path> <Input CAD File directory> <Output directory path> <Filelist (optional)>\n"), ppcArgv[0]);
#else
		printf("Usage:\n %s <input CAD file path> <Output directory path>\n", ppcArgv[0]);
#endif
		return A3D_ERROR;
	}

	/////////////////////////////////////////////
	// 1- Initialize HOOPS Exchange.
	/////////////////////////////////////////////
#ifdef _MSC_VER
#	ifdef _WIN64
	const TCHAR* pcLibPath = _T("..\\..\\..\\..\\bin\\win64\\");
#	else
	const TCHAR* pcLibPath = _T("..\\..\\..\\..\\bin\\win32\\");
#	endif
	A3DUTF8Char acUTF8FileName[MAX_PATH*4];
	A3DUTF8Char acUTF8InDir[MAX_PATH*4];
	A3DUTF8Char acUTF8OutDir[MAX_PATH*4];
	A3DUTF8Char* acUTF8FileList = NULL;
#else
#	ifdef X32
	const A3DUTF8Char* pcLibPath = "../../../../bin/linux32";
#	else
	const A3DUTF8Char* pcLibPath = "../../../../bin/linux64";
#	endif
	A3DUTF8Char* acUTF8FileName = ppcArgv[1];
	A3DUTF8Char* acUTF8InDir = ppcArgv[2];
	A3DUTF8Char* acUTF8OutDir = ppcArgv[3];
	A3DUTF8Char* acUTF8FileList = ppcArgv[4];
#endif

	A3DInt32 iRet = A3D_SUCCESS;

	A3DSDKHOOPSExchangeLoader sHoopsExchangeLoader(pcLibPath);
	if (sHoopsExchangeLoader.m_eSDKStatus!=A3D_SUCCESS)
		return sHoopsExchangeLoader.m_eSDKStatus;

#ifdef _MSC_VER
	A3DMiscUnicodeToUTF8((A3DUTF8Char*) ppcArgv[1], acUTF8FileName);
	A3DMiscUnicodeToUTF8((A3DUTF8Char*) ppcArgv[2], acUTF8InDir);
	A3DMiscUnicodeToUTF8((A3DUTF8Char*) ppcArgv[3], acUTF8OutDir);
	if(ppcArgv[4])
	{
		acUTF8FileList = new A3DUTF8Char[MAX_PATH*4];
		A3DMiscUnicodeToUTF8((A3DUTF8Char*) ppcArgv[4], acUTF8FileList);
	}
#endif

	std::string strMainFileName = ExtractFileName(acUTF8FileName);
	std::string strInMainFileName = acUTF8FileName;

	// init map NATIVE-PRC
	const int MAXFILES = 100;
	A3DUTF8Char** ppMappedNativePaths = (A3DUTF8Char**) A3DCheckMalloc(MAXFILES * sizeof(A3DUTF8Char*));
	A3DUTF8Char** ppMappedPRCPaths = (A3DUTF8Char**) A3DCheckMalloc(MAXFILES * sizeof(A3DUTF8Char*));
	unsigned int idxmap = 0;

	////////////////////////////////////////////////////////////////////////////
	// load the model and get the list of files
	////////////////////////////////////////////////////////////////////////////

	// --- EXTRACT file names for sons
	std::set<std::string> sAsmFilesPath; 
	std::set<std::string> sPartFilesPath;
	if(acUTF8FileList)
	{
		iRet = GetAllFileDependenciesFromFilelist(acUTF8FileList, sAsmFilesPath, sPartFilesPath);
		if(iRet != A3D_SUCCESS)
			return iRet;
	}
	else
	{
		iRet = GetAllFileDependencies(strInMainFileName, sHoopsExchangeLoader, sAsmFilesPath, sPartFilesPath);
		if(iRet != A3D_SUCCESS && iRet != A3D_LOAD_MISSING_COMPONENTS && iRet != A3D_LOAD_MULTI_MODELS_CADFILE)
			return iRet;
	}

	////////////////////////////////////////////////////////////////////////////
	// 1- build a PRC for each component in the assembly, 
	// and update the map NATIVE-PRC
	////////////////////////////////////////////////////////////////////////////

	// 1-a Roots
	if(sAsmFilesPath.find(acUTF8FileName) == sAsmFilesPath.end())	// add root file if it's not already registered in sAsmFilesPath
	{
		TreatFile(sHoopsExchangeLoader,ppMappedNativePaths,ppMappedPRCPaths,idxmap , 
			true, acUTF8FileName, acUTF8InDir, acUTF8OutDir);
	}

	//1-b Assemblies
	std::set<std::string>::iterator itAsmPathCur = sAsmFilesPath.begin();
	std::set<std::string>::iterator itAsmPathEnd = sAsmFilesPath.end();
	for(; itAsmPathCur != itAsmPathEnd; itAsmPathCur++)
	{
		TreatFile(sHoopsExchangeLoader,ppMappedNativePaths,ppMappedPRCPaths,idxmap , 
			true, (char*) (*itAsmPathCur).c_str(), acUTF8InDir, acUTF8OutDir);
	}

	//1-c  Part
	std::set<std::string>::iterator itPartPathCur = sPartFilesPath.begin();
	std::set<std::string>::iterator itPartPathEnd = sPartFilesPath.end();
	for(; itPartPathCur != itPartPathEnd; itPartPathCur++)
	{
		TreatFile(sHoopsExchangeLoader,ppMappedNativePaths,ppMappedPRCPaths,idxmap , 
			false, (char*) (*itPartPathCur).c_str(), acUTF8InDir, acUTF8OutDir);
	}

	////////////////////////////////////////////////////////////////////////////
	// 2- now simulate an assembly reconstruction starting from the root file with all PRC chunks
	////////////////////////////////////////////////////////////////////////////
	std::string strOutMainFileName = acUTF8OutDir;
	strOutMainFileName += "\\__";
	strOutMainFileName += strMainFileName;
	strOutMainFileName += ".prc";

	A3DAsmModelFile* pOutModelFile = NULL;
	A3DRWParamsLoadData sRPartParam;
	A3D_INITIALIZE_DATA(A3DRWParamsLoadData, sRPartParam);
	sRPartParam.m_sGeneral.m_bReadSolids = true;
	sRPartParam.m_sGeneral.m_bReadSurfaces = true;
	sRPartParam.m_sGeneral.m_bReadWireframes = true;
	sRPartParam.m_sGeneral.m_eReadGeomTessMode = kA3DReadGeomAndTess;
	sRPartParam.m_sGeneral.m_bReadHiddenObjects = true;
	//sRPartParam.m_sMultiEntries.m_bLoadDefault = true;

	CHECK_RET(A3DAsmModelFileLoadFromPRCFiles(
		strOutMainFileName.c_str(),
		idxmap,
		(const A3DUTF8Char**)ppMappedPRCPaths,
		(const A3DUTF8Char**)ppMappedNativePaths,
		&sRPartParam,
		&pOutModelFile));

	// --- Export the rebuilt assembly to test the result
	std::string strOut = acUTF8OutDir;
	strOut += "\\__";
	strOut += strMainFileName;
	strOut += "AllLoaded.prc";
	A3DExport sFinalExport(strOut.c_str());
	sHoopsExchangeLoader.m_psModelFile = pOutModelFile;
	CHECK_RET(sHoopsExchangeLoader.Export(sFinalExport));

	for(unsigned ui = 0; ui < idxmap; ++ui)
	{
		A3DCheckFree(ppMappedPRCPaths[ui]);
	}
	A3DCheckFree(ppMappedPRCPaths);

	delete acUTF8FileList;
	acUTF8FileList = NULL;

	return A3D_SUCCESS;
}