ModelLoader::ModelLoader(D3D11::Device const& device, D3D11::Context const& context, std::string filename)
  : m_Directory(filename.substr(0, filename.find_last_of('/'))) {

  Assimp::Importer importer;

  const aiScene* pScene = importer.ReadFile(filename, aiProcess_FlipWindingOrder | aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_CalcTangentSpace | aiProcess_GenNormals | aiProcess_GenSmoothNormals);

  if (pScene == NULL)
    throw std::runtime_error("Dont't load file: "+ filename);


  std::vector<Vertex>   vertices;
  std::vector<uint32_t> indices;

  auto g_CountVertices = 0u;
  auto g_CountIndices  = 0u;

  for (auto index = 0; index < pScene->mNumMeshes; index++) {
    g_CountVertices += pScene->mMeshes[index]->mNumVertices;
    g_CountIndices  += pScene->mMeshes[index]->mNumFaces * 3;
  }

  m_Meshes.reserve(pScene->mNumMeshes);
  m_Materials.reserve(pScene->mNumMaterials);
  vertices.reserve(g_CountVertices);
  indices.reserve(g_CountIndices);


  auto filenameDiffuse  = m_Directory + "/sponza/dummy.dds";
  auto filenameNormal   = m_Directory + "/sponza/dummy_ddn.dds";
  auto filenameSpecular = m_Directory + "/sponza/dummy_specular.dds";

  auto diffuseDefaultSRV  = LoadTexture(device, context, filenameDiffuse);
  auto normalDefaultSRV   = LoadTexture(device, context, filenameNormal);
  auto specularDefaultSRV = LoadTexture(device, context, filenameSpecular);

  for (auto indexMaterial = 0u; indexMaterial < pScene->mNumMaterials; indexMaterial++) {

    aiString strDiffuse;
    aiString strSpecular;
    aiString strNormal;
  
    pScene->mMaterials[indexMaterial]->GetTexture(aiTextureType_DIFFUSE, 0, &strDiffuse);
    pScene->mMaterials[indexMaterial]->GetTexture(aiTextureType_SPECULAR, 0, &strSpecular);
    pScene->mMaterials[indexMaterial]->GetTexture(aiTextureType_NORMALS, 0, &strNormal);
  

    bool flagLoadDiffuse  = false;
    bool flagLoadNormal  = false;
    bool flagLoadSpecular = false;
    
    if (pScene->mMaterials[indexMaterial]->GetTextureCount(aiTextureType_DIFFUSE) > 0) {
      filenameDiffuse = m_Directory + strDiffuse.C_Str();
      flagLoadDiffuse = true;
    }

    if (pScene->mMaterials[indexMaterial]->GetTextureCount(aiTextureType_SPECULAR) > 0) {
      filenameSpecular = m_Directory + strSpecular.C_Str();
      flagLoadSpecular = true;  
    }
    
    if (pScene->mMaterials[indexMaterial]->GetTextureCount(aiTextureType_NORMALS) > 0) {
      filenameNormal = m_Directory  + strNormal.C_Str();
      flagLoadNormal = true;
    }

    
    m_Materials.push_back(Material{
      flagLoadDiffuse  ? LoadTexture(device, context, filenameDiffuse)  : diffuseDefaultSRV ,
      flagLoadSpecular ? LoadTexture(device, context, filenameSpecular) : specularDefaultSRV,
      flagLoadNormal   ? LoadTexture(device, context, filenameNormal)   : normalDefaultSRV});
    
  }

  g_CountVertices = 0u;
  g_CountIndices  = 0u;

  for (auto indexMesh = 0u; indexMesh < pScene->mNumMeshes; indexMesh++) {
  
    auto base = static_cast<uint32_t>(vertices.size());
    for (auto indexElement = 0u; indexElement < pScene->mMeshes[indexMesh]->mNumVertices; indexElement++) {
      Vertex vertex;
      vertex.position = { 
        pScene->mMeshes[indexMesh]->mVertices[indexElement].x,
        pScene->mMeshes[indexMesh]->mVertices[indexElement].y,
        pScene->mMeshes[indexMesh]->mVertices[indexElement].z };
      vertex.normal = {
        pScene->mMeshes[indexMesh]->mNormals[indexElement].x,
        pScene->mMeshes[indexMesh]->mNormals[indexElement].y,
        pScene->mMeshes[indexMesh]->mNormals[indexElement].z };
      vertex.tangent = {
        pScene->mMeshes[indexMesh]->mTangents[indexElement].x,
        pScene->mMeshes[indexMesh]->mTangents[indexElement].y,
        pScene->mMeshes[indexMesh]->mTangents[indexElement].z,
      };
      vertex.texcoord = { pScene->mMeshes[indexMesh]->mTextureCoords[0][indexElement].x, pScene->mMeshes[indexMesh]->mTextureCoords[0][indexElement].y };
      
    
      
      vertices.push_back(vertex);
      g_CountVertices++;
    }
    
    for (auto indexElement = 0u; indexElement < pScene->mMeshes[indexMesh]->mNumFaces; indexElement++) {  
      aiFace face = pScene->mMeshes[indexMesh]->mFaces[indexElement];    
      indices.push_back(face.mIndices[0]);
      indices.push_back(face.mIndices[1]);
      indices.push_back(face.mIndices[2]);
      g_CountIndices += 3;
      
    }

  
    m_Meshes.push_back(Mesh{ m_Materials[pScene->mMeshes[indexMesh]->mMaterialIndex],
                           3 * pScene->mMeshes[indexMesh]->mNumFaces,
                           g_CountIndices - 3 * pScene->mMeshes[indexMesh]->mNumFaces, base});
  }

  m_VertexBuffer = device.CreateVertexBuffer(vertices.data(), vertices.size() * sizeof(Vertex), D3D11_USAGE_IMMUTABLE);
  m_IndexBuffer  = device.CreateIndexBuffer(indices.data(), indices.size() * sizeof(uint32_t),  D3D11_USAGE_IMMUTABLE);
  

}