/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////
#include "COLLADAFWUniqueId.h"
#include "COLLADAFWAnimationList.h"
#include "COLLADAFWVisualScene.h"
#include "ColladaImporterBase.h"

namespace TD_COLLADA_IMPORT
{
	ImporterBase::ImporterBase( DocumentImporter* documentImporter)
		:	m_DocumentImporter(documentImporter)
	{
	}

	ImporterBase::~ImporterBase()
	{
	}

  void ImporterBase::addUniqueIdFWImagePair(const COLLADAFW::UniqueId& uniqueId, const COLLADAFW::Image& Image)
  {
    m_DocumentImporter->getUniqueIdFWImageMap().insert(std::pair<COLLADAFW::UniqueId, COLLADAFW::Image>(uniqueId, Image));
  }

  void ImporterBase::addUniqueIdFWEffectPair(const COLLADAFW::UniqueId& uniqueId, const COLLADAFW::Effect& effect)
  {
    m_DocumentImporter->getUniqueIdFWEffectMap().insert(std::pair<COLLADAFW::UniqueId, COLLADAFW::Effect>(uniqueId, effect));
  }

  void ImporterBase::addUniqueIdFWMaterialPair(const COLLADAFW::UniqueId& uniqueId, const COLLADAFW::Material& material)
  {
    m_DocumentImporter->getUniqueIdFWMaterialMap().insert(std::pair<COLLADAFW::UniqueId, COLLADAFW::Material>(uniqueId, material));
  }

  void ImporterBase::addUniqueIdFWNodePair(const COLLADAFW::UniqueId& uniqueId, const COLLADAFW::Node* node)
  {
    m_DocumentImporter->getUniqueIdFWNodeMap()[uniqueId] = node;
  }

  void ImporterBase::addVisualScene(const COLLADAFW::VisualScene* visualScene)
  {
    DocumentImporter::UniqueIdVisualSceneMap& map = m_DocumentImporter->getUniqueIdVisualSceneMap();
    map[visualScene->getUniqueId()] = visualScene;
  }

  void ImporterBase::addLibraryNodes(const COLLADAFW::LibraryNodes* libraryNodes)
  {
    m_DocumentImporter->getLibraryNodesList().push_back(libraryNodes);
  }

  void ImporterBase::addUniqueIdObjectIdPair(const COLLADAFW::UniqueId& uniqueId, OdDbObjectId objectId)
  {
    m_DocumentImporter->getUniqueIdOdDbObjectIdMap().insert(std::make_pair(uniqueId, objectId));
  }

  void ImporterBase::addUniqueIdFWControllerPair(const COLLADAFW::UniqueId& uniqueId, const COLLADAFW::Controller& controller)
  {
    m_DocumentImporter->getUniqueIdFWControllerMap().insert(std::pair<COLLADAFW::UniqueId, COLLADAFW::Controller>(uniqueId, controller));
  }

  const COLLADAFW::Node* ImporterBase::getFWNodeByUniqueId(const COLLADAFW::UniqueId& uniqueId)
  {
    const DocumentImporter::UniqueIdFWNodeMap& uniqueIdFWNodeMap = m_DocumentImporter->getUniqueIdFWNodeMap();
    DocumentImporter::UniqueIdFWNodeMap::const_iterator it = uniqueIdFWNodeMap.find(uniqueId);
    if (it == uniqueIdFWNodeMap.end())
      return 0;
    else
      return it->second;
  }
  
  OdDbObjectId ImporterBase::getOdDbObjectIdByUniqueId(const COLLADAFW::UniqueId& uniqueId)
  {
    const DocumentImporter::UniqueIdOdDbObjectIdMap& uniqueIdObjectMap = m_DocumentImporter->getUniqueIdOdDbObjectIdMap();
    DocumentImporter::UniqueIdOdDbObjectIdMap::const_iterator it = uniqueIdObjectMap.find(uniqueId);
    if (it == uniqueIdObjectMap.end())
      return 0;
    else
      return it->second;
  }

  void ImporterBase::getOdDbObjectIdArrByUniqueId(const COLLADAFW::UniqueId& uniqueId, OdDbObjectIdArray& arrObjIds)
  {
    const DocumentImporter::UniqueIdOdDbObjectIdMap & uniqueIdObjectMap = m_DocumentImporter->getUniqueIdOdDbObjectIdMap();
    auto range = uniqueIdObjectMap.equal_range(uniqueId);
    for (auto it = range.first; it != range.second; ++it)
      arrObjIds.append(it->second);
  }

  COLLADAFW::MaterialId ImporterBase::getMaterialIdByUniqueId(const COLLADAFW::UniqueId& uniqueId)
  {
    const DocumentImporter::UniqueIdMaterialIdMap& uniqueIdMaterialMap = m_DocumentImporter->getUniqueIdMaterialIdMap();
    DocumentImporter::UniqueIdMaterialIdMap::const_iterator it = uniqueIdMaterialMap.find(uniqueId);
    if (it == uniqueIdMaterialMap.end())
      return INVALID_MAT_ID;
    else
      return it->second;
  }

  void ImporterBase::addUniqueIdSubUniqueIdPair(const COLLADAFW::UniqueId& uniqueId, const COLLADAFW::UniqueId& subUniqueId)
  {
    m_DocumentImporter->getUniqueIdSubUniqueIdMultiMap().insert(std::make_pair(uniqueId, subUniqueId));
  }

  void ImporterBase::addUniqueIdOdDbObjectIdPair(const COLLADAFW::UniqueId& uniqueId, OdDbObjectId objectId)
  {
    m_DocumentImporter->getUniqueIdOdDbObjectIdMap().insert(std::make_pair(uniqueId, objectId));
  }

  void ImporterBase::addUniqueIdMaterialIdPair(const COLLADAFW::UniqueId& uniqueId, COLLADAFW::MaterialId materialId)
  {
    m_DocumentImporter->getUniqueIdMaterialIdMap()[uniqueId] = materialId;
  }

  const COLLADAFW::Image* ImporterBase::getFWImageByUniqueId( const COLLADAFW::UniqueId& uniqueId )
  {
    const DocumentImporter::UniqueIdFWImageMap& uniqueIdFWImageMap = m_DocumentImporter->getUniqueIdFWImageMap();
    DocumentImporter::UniqueIdFWImageMap::const_iterator it = uniqueIdFWImageMap.find(uniqueId);
    if ( it == uniqueIdFWImageMap.end() )
      return 0;
    else
      return &it->second;
  }
  
  const COLLADAFW::Controller* ImporterBase::getFWControllerByUniqueId(const COLLADAFW::UniqueId& uniqueId)
  {
    const DocumentImporter::UniqueIdFWControllerMap& uniqueIdFWControllerMap = m_DocumentImporter->getUniqueIdFWControllerMap();
    DocumentImporter::UniqueIdFWControllerMap::const_iterator it = uniqueIdFWControllerMap.find(uniqueId);
    if (it == uniqueIdFWControllerMap.end())
      return 0;
    else
      return &it->second;
  }

  const DocumentImporter::FileInfo& ImporterBase::getFileInfo() const 
  { 
    return m_DocumentImporter->getFileInfo(); 
  }





  const DocumentImporter::UniqueIdFWMaterialMap& ImporterBase::getUniqueIdFWMaterialMap()
  {
    return m_DocumentImporter->getUniqueIdFWMaterialMap();
  }

  const DocumentImporter::EntityMaterialBindingsArray& ImporterBase::getEntityMaterialBindings()
  {
    return m_DocumentImporter->getEntityMaterialBindingsArray();
  }

  void ImporterBase::getSubUniqueIdsByUniqueId(const COLLADAFW::UniqueId& uniqueId, SubUniqueIdIter& first, SubUniqueIdIter& last)
  {
    const DocumentImporter::UniqueIdSubUniqueIdMultiMap& uniqueIdSubUniqueIdMultiMap = m_DocumentImporter->getUniqueIdSubUniqueIdMultiMap();
    std::pair<SubUniqueIdIter, SubUniqueIdIter> itRange = uniqueIdSubUniqueIdMultiMap.equal_range(uniqueId);
    first = itRange.first;
    last = itRange.second;
  }

  const COLLADAFW::Material* ImporterBase::getFWMaterialByUniqueId(const COLLADAFW::UniqueId& uniqueId)
  {
    const DocumentImporter::UniqueIdFWMaterialMap& uniqueIdFWMaterialMap = m_DocumentImporter->getUniqueIdFWMaterialMap();
    DocumentImporter::UniqueIdFWMaterialMap::const_iterator it = uniqueIdFWMaterialMap.find(uniqueId);
    if (it == uniqueIdFWMaterialMap.end())
      return 0;
    else
      return &it->second;
  }

  const COLLADAFW::Effect* ImporterBase::getFWEffectByUniqueId(const COLLADAFW::UniqueId& uniqueId)
  {
    const DocumentImporter::UniqueIdFWEffectMap& uniqueIdFWEffectMap = m_DocumentImporter->getUniqueIdFWEffectMap();
    DocumentImporter::UniqueIdFWEffectMap::const_iterator it = uniqueIdFWEffectMap.find(uniqueId);
    if (it == uniqueIdFWEffectMap.end())
      return 0;
    else
      return &it->second;
  }

  void ImporterBase::addToModelSpaceMap(const COLLADAFW::UniqueId& uniqueId, OdDbObjectId btEntId, OdDbObjectId msEntId, const InternalNode& intNode)
  {
    DocumentImporter::UniqueIdMSObjectMap& msMap = m_DocumentImporter->getUniqueIdMSObjectMap();
    auto mapIt = msMap.find(uniqueId);
    if (mapIt == msMap.end())
      mapIt = msMap.emplace(uniqueId, std::map<OdDbObjectId, std::pair<OdDbObjectId, InternalNode>>()).first;

    mapIt->second[btEntId] = std::make_pair(msEntId, intNode);
  }

  bool ImporterBase::getModelSpaceEntData(const COLLADAFW::UniqueId& uniqueId, OdDbObjectId btEntId, OdDbObjectId& objectId, InternalNode& intNode)
  {
    const DocumentImporter::UniqueIdMSObjectMap& msMap = m_DocumentImporter->getUniqueIdMSObjectMap();
    auto mapIt = msMap.find(uniqueId);
    if (mapIt == msMap.end())
      return false;

    auto it = mapIt->second.find(btEntId);
    if (it == mapIt->second.end())
      return false;

    objectId = it->second.first;
    intNode = it->second.second;

    return true;
  }

  void ImporterBase::addNodeData(const COLLADAFW::UniqueId& nodeUniqueId, const InternalNode& intNode)
  {
    DocumentImporter::NodeIdOdDbObjectIdArrMap& nodeIdOdDbObjectIdArrMap = m_DocumentImporter->getNodeIdOdDbObjectIdArrMap();
    
    auto it = nodeIdOdDbObjectIdArrMap.find(nodeUniqueId);
    if (it != nodeIdOdDbObjectIdArrMap.end())
      return;

    nodeIdOdDbObjectIdArrMap.insert(std::make_pair(nodeUniqueId, std::make_pair(intNode, OdDbObjectIdArray())));
  }

  void ImporterBase::addOdDbObjectToNode(const COLLADAFW::UniqueId& nodeUniqueId, const OdGeMatrix3d& matr, OdDbObjectId objectId)
  {
    DocumentImporter::NodeIdOdDbObjectIdArrMap& nodeIdOdDbObjectIdArrMap = m_DocumentImporter->getNodeIdOdDbObjectIdArrMap();

    auto it = nodeIdOdDbObjectIdArrMap.find(nodeUniqueId);
    if (it == nodeIdOdDbObjectIdArrMap.end())
      return;

    if (!objectId.isNull())
      it->second.second.append(objectId);
  }

  bool ImporterBase::getNodeData(const COLLADAFW::UniqueId& nodeUniqueId, InternalNode& intNode, OdDbObjectIdArray& objArr)
  {
    DocumentImporter::NodeIdOdDbObjectIdArrMap& nodeIdOdDbObjectIdArrMap = m_DocumentImporter->getNodeIdOdDbObjectIdArrMap();

    auto it = nodeIdOdDbObjectIdArrMap.find(nodeUniqueId);
    if (it == nodeIdOdDbObjectIdArrMap.end())
      return false;

    intNode = it->second.first;
    objArr = it->second.second;

    return true;
  }

  void ImporterBase::updateMaterialData(const OdDbObjectId& oldObjectId, const OdDbObjectId& newObjectId)
  {
    DocumentImporter::EntityMaterialBindingsArray& materialBindings = m_DocumentImporter->getEntityMaterialBindingsArray();
    auto it = std::find(materialBindings.begin(), materialBindings.end(), DocumentImporter::EntityMaterialBindingPair(oldObjectId, COLLADAFW::MaterialBinding(0, COLLADAFW::UniqueId())));
    if (it == materialBindings.end())
      return;

    materialBindings.push_back(DocumentImporter::EntityMaterialBindingPair(newObjectId, it->materialBinding));
  }

  void ImporterBase::appendMaterialBindingsPair(const DocumentImporter::EntityMaterialBindingPair& materialBindingPair)
  {
    DocumentImporter::EntityMaterialBindingsArray& materialBindings = m_DocumentImporter->getEntityMaterialBindingsArray();
    materialBindings.push_back(materialBindingPair);
  }

  const bool ImporterBase::isImportTextures()
  {
    return m_DocumentImporter->m_bImportTextures;
  }

  const bool ImporterBase::isImportLines()
  {
    return m_DocumentImporter->m_bImportLines;
  }
}