/*
 * 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 2
 * 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, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

/** \file
 * \ingroup collada
 */

#ifndef __ANIMATIONIMPORTER_H__
#define __ANIMATIONIMPORTER_H__

#include <map>
#include <vector>

#include "COLLADAFWAnimation.h"
#include "COLLADAFWAnimationCurve.h"
#include "COLLADAFWAnimationList.h"
#include "COLLADAFWCamera.h"
#include "COLLADAFWEffect.h"
#include "COLLADAFWInstanceGeometry.h"
#include "COLLADAFWLight.h"
#include "COLLADAFWMaterial.h"
#include "COLLADAFWNode.h"
#include "COLLADAFWUniqueId.h"

#include "BKE_context.h"

#include "DNA_anim_types.h"

#include "DNA_camera_types.h"
#include "DNA_light_types.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"

//#include "ArmatureImporter.h"
#include "TransformReader.h"

#include "collada_internal.h"

class ArmatureImporter;

class AnimationImporterBase {
 public:
  // virtual void change_eul_to_quat(Object *ob, bAction *act) = 0;
};

class AnimationImporter : private TransformReader, public AnimationImporterBase {
 private:
  bContext *mContext;
  ArmatureImporter *armature_importer;
  Scene *scene;

  std::map<COLLADAFW::UniqueId, std::vector<FCurve *>> curve_map;
  std::map<COLLADAFW::UniqueId, TransformReader::Animation> uid_animated_map;
  // std::map<bActionGroup*, std::vector<FCurve*> > fcurves_actionGroup_map;
  std::map<COLLADAFW::UniqueId, const COLLADAFW::AnimationList *> animlist_map;
  std::vector<FCurve *> unused_curves;
  std::map<COLLADAFW::UniqueId, Object *> joint_objects;

  FCurve *create_fcurve(int array_index, const char *rna_path);

  void add_bezt(FCurve *fcu,
                float frame,
                float value,
                eBezTriple_Interpolation ipo = BEZT_IPO_LIN);

  // create one or several fcurves depending on the number of parameters being animated
  void animation_to_fcurves(COLLADAFW::AnimationCurve *curve);

  void fcurve_deg_to_rad(FCurve *cu);
  void fcurve_scale(FCurve *cu, int scale);

  void fcurve_is_used(FCurve *fcu);

  void add_fcurves_to_object(Main *bmain,
                             Object *ob,
                             std::vector<FCurve *> &curves,
                             char *rna_path,
                             int array_index,
                             Animation *animated);

  int typeFlag;

  std::string import_from_version;

  enum lightAnim {
    //      INANIMATE = 0,
    LIGHT_COLOR = 2,
    LIGHT_FOA = 4,
    LIGHT_FOE = 8,
  };

  enum cameraAnim {
    //      INANIMATE = 0,
    CAMERA_XFOV = 2,
    CAMERA_XMAG = 4,
    CAMERA_YFOV = 8,
    CAMERA_YMAG = 16,
    CAMERA_ZFAR = 32,
    CAMERA_ZNEAR = 64,
  };

  enum matAnim {
    MATERIAL_SHININESS = 2,
    MATERIAL_SPEC_COLOR = 4,
    MATERIAL_DIFF_COLOR = 1 << 3,
    MATERIAL_TRANSPARENCY = 1 << 4,
    MATERIAL_IOR = 1 << 5,
  };

  enum AnimationType {
    BC_INANIMATE = 0,
    BC_NODE_TRANSFORM = 1,
  };

  struct AnimMix {
    int transform;
    int light;
    int camera;
    int material;
    int texture;
  };

 public:
  AnimationImporter(bContext *C, UnitConverter *conv, ArmatureImporter *arm, Scene *scene)
      : TransformReader(conv), mContext(C), armature_importer(arm), scene(scene)
  {
  }

  ~AnimationImporter();

  void set_import_from_version(std::string import_from_version);
  bool write_animation(const COLLADAFW::Animation *anim);

  // called on post-process stage after writeVisualScenes
  bool write_animation_list(const COLLADAFW::AnimationList *animlist);

  void read_node_transform(COLLADAFW::Node *node, Object *ob);
#if 0
  virtual void change_eul_to_quat(Object *ob, bAction *act);
#endif

  void translate_Animations(COLLADAFW::Node *Node,
                            std::map<COLLADAFW::UniqueId, COLLADAFW::Node *> &root_map,
                            std::multimap<COLLADAFW::UniqueId, Object *> &object_map,
                            std::map<COLLADAFW::UniqueId, const COLLADAFW::Object *> FW_object_map,
                            std::map<COLLADAFW::UniqueId, Material *> uid_material_map);

  AnimMix *get_animation_type(
      const COLLADAFW::Node *node,
      std::map<COLLADAFW::UniqueId, const COLLADAFW::Object *> FW_object_map);

  void apply_matrix_curves(Object *ob,
                           std::vector<FCurve *> &animcurves,
                           COLLADAFW::Node *root,
                           COLLADAFW::Node *node,
                           COLLADAFW::Transformation *tm);

  void add_bone_animation_sampled(Object *ob,
                                  std::vector<FCurve *> &animcurves,
                                  COLLADAFW::Node *root,
                                  COLLADAFW::Node *node,
                                  COLLADAFW::Transformation *tm);

  void Assign_transform_animations(COLLADAFW::Transformation *transform,
                                   const COLLADAFW::AnimationList::AnimationBinding *binding,
                                   std::vector<FCurve *> *curves,
                                   bool is_joint,
                                   char *joint_path);

  void Assign_color_animations(const COLLADAFW::UniqueId &listid,
                               ListBase *AnimCurves,
                               const char *anim_type);
  void Assign_float_animations(const COLLADAFW::UniqueId &listid,
                               ListBase *AnimCurves,
                               const char *anim_type);
  void Assign_lens_animations(const COLLADAFW::UniqueId &listid,
                              ListBase *AnimCurves,
                              const double aspect,
                              Camera *cam,
                              const char *anim_type,
                              int fov_type);

  int setAnimType(const COLLADAFW::Animatable *prop, int type, int addition);

  void modify_fcurve(std::vector<FCurve *> *curves,
                     const char *rna_path,
                     int array_index,
                     int scale = 1);
  void unused_fcurve(std::vector<FCurve *> *curves);
  // prerequisites:
  // animlist_map - map animlist id -> animlist
  // curve_map - map anim id -> curve(s)
  Object *translate_animation_OLD(COLLADAFW::Node *node,
                                  std::map<COLLADAFW::UniqueId, Object *> &object_map,
                                  std::map<COLLADAFW::UniqueId, COLLADAFW::Node *> &root_map,
                                  COLLADAFW::Transformation::TransformationType tm_type,
                                  Object *par_job = NULL);

  void find_frames(std::vector<float> *frames, std::vector<FCurve *> *curves);
  void find_frames_old(std::vector<float> *frames,
                       COLLADAFW::Node *node,
                       COLLADAFW::Transformation::TransformationType tm_type);
  // internal, better make it private
  // warning: evaluates only rotation
  // prerequisites: animlist_map, curve_map
  void evaluate_transform_at_frame(float mat[4][4], COLLADAFW::Node *node, float fra);

  // return true to indicate that mat contains a sane value
  bool evaluate_animation(COLLADAFW::Transformation *tm,
                          float mat[4][4],
                          float fra,
                          const char *node_id);

  // gives a world-space mat of joint at rest position
  void get_joint_rest_mat(float mat[4][4], COLLADAFW::Node *root, COLLADAFW::Node *node);

  // gives a world-space mat, end's mat not included
  bool calc_joint_parent_mat_rest(float mat[4][4],
                                  float par[4][4],
                                  COLLADAFW::Node *node,
                                  COLLADAFW::Node *end);

  float convert_to_focal_length(float in_xfov, int fov_type, float aspect, float sensorx);

#ifdef ARMATURE_TEST
  Object *get_joint_object(COLLADAFW::Node *root, COLLADAFW::Node *node, Object *par_job);
#endif

#if 0
  // recursively evaluates joint tree until end is found, mat then is world-space matrix of end
  // mat must be identity on enter, node must be root
  bool evaluate_joint_world_transform_at_frame(
      float mat[4][4], float par[4][4], COLLADAFW::Node *node, COLLADAFW::Node *end, float fra);
#endif

  void add_bone_fcurve(Object *ob, COLLADAFW::Node *node, FCurve *fcu);

  void extra_data_importer(std::string elementName);
};

#endif