import { Float3 } from './Math'

export type BaseLightConfig = {
  /**
   * Sets the initial color of a light.
   *
   * @param color Color of the light specified in the linear sRGB color-space.
   *              The default is white {1,1,1}.
   */
  colorKelvin?: number
  /**
   * Sets the initial intensity of a light.
   * @param intensity This parameter depends on the Light.Type:
   *                  - For directional lights, it specifies the illuminance in *lux*
   *                  (or *lumen/m^2*).
   *                  - For point lights and spot lights, it specifies the luminous power
   *                  in *lumen*.
   *
   * For example, the sun's illuminance is about 100,000 lux.
   *
   * This method overrides any prior calls to intensity or intensityCandela.
   *
   */
  intensity?: number
  /**
   * Sets the initial direction of a light in world space.
   *
   * @param direction Light's direction in world space. Should be a unit vector.
   *                  The default is {0,-1,0}.
   *
   * @note
   * The Light's direction is ignored for Type.POINT lights.
   */
  direction?: Float3
  /**
   * Sets the initial position of the light in world space.
   * The default is at the origin.
   *
   * @note
   * The Light's position is ignored for directional lights (Type.DIRECTIONAL or Type.SUN)
   */
  position?: Float3
  /**
   * Whether this Light casts shadows (disabled by default)
   */
  castShadows?: boolean
}

export type SpotLightExtraConfig = {
  /**
   *   - POINT,          //!< Point light, emits light from a position, in all directions.
   *   - FOCUSED_SPOT,   //!< Physically correct spot light.
   *   - SPOT,           //!< Spot light with coupling of outer cone and illumination disabled.
   */
  type: 'spot' | 'point' | 'focused_point'

  /**
   * Set the falloff distance for point lights and spot lights.
   * Falloff distance in world units.
   *
   * At the falloff distance, the light has no more effect on objects.
   *
   * The falloff distance essentially defines a *sphere of influence* around the light, and
   * therefore has an impact on performance. Larger falloffs might reduce performance
   * significantly, especially when many lights are used.
   *
   * Try to avoid having a large number of light's spheres of influence overlap.
   *
   * @default 1 meter
   *
   * @note
   * The Light's falloff is ignored for directional lights (Type.DIRECTIONAL or Type.SUN)
   */
  falloffRadius?: number

  /**
   * Defines a spot light'st angular falloff attenuation.
   *
   * A spot light is defined by a position, a direction and two cones, \p inner and \p outer.
   * These two cones are used to define the angular falloff attenuation of the spot light
   * and are defined by the angle from the center axis to where the falloff begins (i.e.
   * cones are defined by their half-angle).
   *
   * Both inner and outer are silently clamped to a minimum value of 0.5 degrees
   * (~0.00873 radians) to avoid floating-point precision issues during rendering.
   *
   * @param inner inner cone angle in *radians* between 0.00873 and \p outer
   * @param outer outer cone angle in *radians* between 0.00873 inner and @f$ \pi/2 @f$
   *
   * @note
   * The spot light cone is ignored for directional and point lights.
   *
   * @see Type.SPOT, Type.FOCUSED_SPOT
   */
  spotLightCone?: [innerRadians: number, outerRadians: number]
}

/**
 * Light types
 * ===========
 *
 * Lights come in three flavors:
 * - directional lights
 * - point lights
 * - spot lights
 *
 *
 * Directional lights
 * ------------------
 *
 * Directional lights have a direction, but don't have a position. All light rays are
 * parallel and come from infinitely far away and from everywhere. Typically a directional light
 * is used to simulate the sun.
 *
 * Directional lights and spot lights are able to cast shadows.
 *
 * To create a directional light use Type.DIRECTIONAL or Type.SUN, both are similar, but the later
 * also draws a sun's disk in the sky and its reflection on glossy objects.
 *
 * @warning Currently, only a single directional light is supported. If several directional lights
 * are added to the scene, the dominant one will be used.
 *
 * @see Builder.direction(), Builder.sunAngularRadius()
 *
 * Point lights
 * ------------
 *
 * Unlike directional lights, point lights have a position but emit light in all directions.
 * The intensity of the light diminishes with the inverse square of the distance to the light.
 * Builder.falloff() controls distance beyond which the light has no more influence.
 *
 * A scene can have multiple point lights.
 *
 * @see Builder.position(), Builder.falloff()
 *
 * Spot lights
 * -----------
 *
 * Spot lights are similar to point lights but the light it emits is limited to a cone defined by
 * Builder.spotLightCone() and the light's direction.
 *
 * A spot light is therefore defined by a position, a direction and inner and outer cones. The
 * spot light's influence is limited to inside the outer cone. The inner cone defines the light's
 * falloff attenuation.
 *
 * A physically correct spot light is a little difficult to use because changing the outer angle
 * of the cone changes the illumination levels, as the same amount of light is spread over a
 * changing volume. The coupling of illumination and the outer cone means that an artist cannot
 * tweak the influence cone of a spot light without also changing the perceived illumination.
 * It therefore makes sense to provide artists with a parameter to disable this coupling. This
 * is the difference between Type.FOCUSED_SPOT and Type.SPOT.
 *
 * @see Builder.position(), Builder.direction(), Builder.falloff(), Builder.spotLightCone()
 *
 * Performance considerations
 * ==========================
 *
 * Generally, adding lights to the scene hurts performance, however filament is designed to be
 * able to handle hundreds of lights in a scene under certain conditions. Here are some tips
 * to keep performances high.
 *
 * 1. Prefer spot lights to point lights and use the smallest outer cone angle possible.
 *
 * 2. Use the smallest possible falloff distance for point and spot lights.
 *    Performance is very sensitive to overlapping lights. The falloff distance essentially
 *    defines a sphere of influence for the light, so try to position point and spot lights
 *    such that they don't overlap too much.
 *
 *    On the other hand, a scene can contain hundreds of non overlapping lights without
 *    incurring a significant overhead.
 *
 */
export type LightConfig = BaseLightConfig &
  (
    | {
        /**
         *   - SUN,            //!< Directional light that also draws a sun's disk in the sky.
         *   - DIRECTIONAL,    //!< Directional light, emits light in a given direction.
         *   - POINT,          //!< Point light, emits light from a position, in all directions.
         *   - FOCUSED_SPOT,   //!< Physically correct spot light.
         *   - SPOT,           //!< Spot light with coupling of outer cone and illumination disabled.
         */
        type: 'directional' | 'sun'
      }
    | SpotLightExtraConfig
  )

export type LightType = LightConfig['type']