import { IBaseProps, IGroupParams, IPointLight } from './type/types';

/**
 * 生成基本参数 旋转 位移 缩放等属性
 */
const genBaseStruct = (obj: THREE.Object3D): IBaseProps => {
  const { type, name, quaternion: q, position: p, rotation: r, scale: s, up: u, userData, visible, matrix } = obj;
  const quaternion: IBaseProps['quaternion'] = [q.x, q.y, q.z, q.w];
  const position: IBaseProps['position'] = [p.x, p.y, p.z];
  const rotation: IBaseProps['rotation'] = [r.x, r.y, r.z, r.order];
  const scale: IBaseProps['scale'] = [s.x, s.y, s.z];
  const up: IBaseProps['up'] = [u.x, u.y, u.z];

  return {
    type,
    name,
    quaternion,
    position,
    rotation,
    scale,
    up,
    matrix,
    userData,
    visible,
    children: genObject3DChildren(obj.children),
    animations: genAnimations(obj.animations),
  };
};

/**
 * 生成动画结构
 */
export const genAnimations = (animations: THREE.AnimationClip[]) => {
  return animations.map((animation) => {
    animation['tracks'].forEach((t) => {
      //删除这个方法就可以传递过去了
      //@ts-ignore
      delete t['createInterpolant'];
      t['type'] = t['ValueTypeName']; //vector quaternion
    });
    return animation;
  });
};

/**
 * 生成物体参数
 */
const genMeshStruct = (mesh: THREE.Mesh) => {
  const { geometry, material } = mesh;

  return {
    geometry,
    material,
    ...genBaseStruct(mesh),
  };
};

const genPointLightStruct = (pointLight: THREE.PointLight): IPointLight => {
  return {
    power: pointLight.power,
    color: pointLight.color,
    decay: pointLight.decay,
    castShadow: pointLight.castShadow,
    distance: pointLight.distance,
    frustumCulled: pointLight.frustumCulled,
    intensity: pointLight.intensity,
    layers: pointLight.layers,
    ...genBaseStruct(pointLight),
  };
};

const genObject3DStruct = (object: THREE.Object3D) => {
  return {
    ...genBaseStruct(object),
  };
};

/**
 * 生成子元素结构
 */
const genObject3DChildren = (children: THREE.Object3D[]) => {
  const childStruct: IGroupParams['children'] = [];
  for (const child of children) {
    const { type } = child;
    if (type === 'Mesh') {
      childStruct.push(genMeshStruct(child as THREE.Mesh));
    } else if (type === 'Group') {
      childStruct.push(genGroupStruct(child as THREE.Group));
    } else if (type === 'PointLight') {
      childStruct.push(genPointLightStruct(child as THREE.PointLight));
    } else if (type === 'Object3D') {
      childStruct.push(genObject3DStruct(child));
    }
  }
  return childStruct;
};

/**
 * 生成物体组结构
 */
export const genGroupStruct = (group: THREE.Group) => {
  const struct: IGroupParams = { ...genBaseStruct(group) };
  return struct;
};