#ifndef DALI_DEMO_PBR_OBJ_LOADER_H
#define DALI_DEMO_PBR_OBJ_LOADER_H

/*
 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

// EXTERNAL INCLUDES
#include <dali/public-api/rendering/geometry.h>
#include <limits>

using namespace Dali;

namespace PbrDemo
{

class ObjLoader
{
public:

  struct TriIndex
  {
    int pointIndex[3];
    int normalIndex[3];
    int textureIndex[3];
  };

  struct BoundingVolume
  {
    void Init()
    {
      pointMin = Vector3( std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max() );
      pointMax = Vector3( std::numeric_limits<float>::min(), std::numeric_limits<float>::min(), std::numeric_limits<float>::min() );
    }

    void ConsiderNewPointInVolume( const Vector3& position )
    {
      pointMin.x = std::min( position.x, pointMin.x );
      pointMin.y = std::min( position.y, pointMin.y );
      pointMin.z = std::min( position.z, pointMin.z );

      pointMax.x = std::max( position.x, pointMax.x );
      pointMax.y = std::max( position.y, pointMax.y );
      pointMax.z = std::max( position.z, pointMax.z );
    }

    Vector3 pointMin;
    Vector3 pointMax;
  };

  //Defines bit masks to declare which properties are needed by anyone requesting a geometry.
  enum ObjectProperties
  {
    TEXTURE_COORDINATES = 1 << 0,
    TANGENTS = 1 << 1,
    BINORMALS = 1 << 2
  };

  ObjLoader();
  virtual ~ObjLoader();

  bool      IsSceneLoaded();
  bool      IsMaterialLoaded();

  bool      LoadObject( char* objBuffer, std::streampos fileSize );

  void      LoadMaterial( char* objBuffer, std::streampos fileSize, std::string& diffuseTextureUrl,
                          std::string& normalTextureUrl, std::string& glossTextureUrl );

  Geometry  CreateGeometry( int objectProperties, bool useSoftNormals );

  Vector3   GetCenter();
  Vector3   GetSize();

  void      ClearArrays();

  bool      IsTexturePresent();
  bool      IsDiffuseMapPresent();
  bool      IsNormalMapPresent();
  bool      IsSpecularMapPresent();

private:

  Dali::Vector<Vector3>  mPoints;
  Dali::Vector<Vector2>  mTextureUv;
  Dali::Vector<Vector2>  mTextureUv2;
  Dali::Vector<Vector3>  mNormals;
  Dali::Vector<Vector3>  mTangents;
  Dali::Vector<Vector3>  mBiTangents;
  Dali::Vector<TriIndex> mTriangles;

  BoundingVolume mSceneAABB;

  bool mSceneLoaded;
  bool mMaterialLoaded;
  bool mHasTextureUv;

  //Material file properties.
  bool mHasDiffuseMap;
  bool mHasNormalMap;
  bool mHasSpecularMap;

  /**
   * @brief Calculates normals for each point on a per-face basis.
   *
   * There are multiple normals per point, each corresponding to the normal of a face connecting to the point.
   *
   * @param[in] vertices The vertices of the object.
   * @param[in, out] triangles The triangles that form the faces. The normals of each triangle will be updated.
   * @param[in, out] normals The normals to be calculated.
   */
  void CalculateHardFaceNormals( const Dali::Vector<Vector3>& vertices,
                                 Dali::Vector<TriIndex>& triangles,
                                 Dali::Vector<Vector3>& normals );

  /**
   * @brief Calculates smoothed normals for each point.
   *
   * There is one normal per point, an average of the connecting faces.
   *
   * @param[in] vertices The vertices of the object.
   * @param[in, out] triangles The triangles that form the faces. The normals of each triangle will be updated.
   * @param[in, out] normals The normals to be calculated.
   */
  void CalculateSoftFaceNormals( const Dali::Vector<Vector3>& vertices,
                                 Dali::Vector<TriIndex>& triangles,
                                 Dali::Vector<Vector3>& normals );

  /**
   * @brief Calculates tangents and bitangents for each point of the object.
   *
   * These are calculated using the object's points, texture coordinates and normals, so these must be initialised first.
   */
  void CalculateTangentFrame();

  void CenterAndScale( bool center, Dali::Vector<Vector3>& points );

  /**
   * @brief Using the data loaded from the file, create arrays of data to be used in creating the geometry.
   *
   * @param[out] positions The positions of the vertices of the object.
   * @param[out] normals The normals of the vertices of the object.
   * @param[out] tangents The tangents of the vertices of the object.
   * @param[out] textures The texture coordinates of the vertices of the object.
   * @param[out] indices Indices of corresponding values to match triangles to their respective data.
   * @param[in] useSoftNormals Indicates whether we should average the normals at each point to smooth the surface or not.
   */
  void CreateGeometryArray( Dali::Vector<Vector3>& positions,
                            Dali::Vector<Vector3>& normals,
                            Dali::Vector<Vector3>& tangents,
                            Dali::Vector<Vector2>& textures,
                            Dali::Vector<unsigned short>& indices,
                            bool useSoftNormals );

};

} // namespace PbrDemo

#endif // DALI_DEMO_PBR_OBJ_LOADER_H