/*
    Copyright (C) 2016 Apple Inc. All Rights Reserved.
    See LICENSE.txt for this sample’s licensing information
    
    Abstract:
    A component that attaches to an entity. This component creates a particle effect for a geometry node. It also creates and manages a flickering light for a geometry node.
*/

import SpriteKit
import SceneKit
import GameplayKit

class ParticleComponent: RocketComponent {
    // MARK: Properties

    /// A convenience property to access the entity's geometry component.
    var geometryComponent: GeometryComponent? {
        return entity?.component(ofType: GeometryComponent.self)
    }
    
    /// A convenience property for the entity's geometry component.
    var thrustComponent: GeometryComponent? {
        return entity?.component(ofType: GeometryComponent.self)
    }
    
    /// Keeps track of whether the entity's box has a particle effect or not.
    var boxHasParticleEffect = false
    
    /// Creates and manages the box's particle effect.
    let particleEmitter: SCNParticleSystem
    
    /// The light attached to the box that illuminates its surroundings.
    let boxLight = SCNLight()

    /**
        The brightness of the box's light. Changes the light's brightness when 
        changed.
    */
    var lightBrightness: CGFloat = 1 {
        didSet {
            boxLight.color = SKColor(white: lightBrightness, alpha: 1)
        }
    }
    
    /// Generates random numbers. Used to make the light flicker randomly.
    let randomSource = GKRandomSource()
    
    /**
        Returns a light brightness slightly closer to the target light
        brightness than the current brightness. This is used to produce a 
        smooth, yet still random flickering effect, making it feel realistic.
    
        This is a property because it's idempotent.
    */
    var nextLightBrightness: CGFloat {
        /*
            If the light's brightness is below target, return an increased 
            brightness. Otherwise, return a decreased brightness.
        */
        let delta: CGFloat = lightBrightness < targetLightBrightness ? 0.025 : -0.025
        return lightBrightness + delta
    }
    
    /// The brightness that the light is attempting to match.
    var targetLightBrightness: CGFloat = 0.5
    
    // MARK: Initialization

    init(particleName: String) {
        // Create the particle emitter.
        particleEmitter = SCNParticleSystem(named: particleName, inDirectory: "/")!
        
        super.init()
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    // MARK: Methods
    
    override func update(deltaTime _: TimeInterval) {
        /*
            Ensure that the particle system and light will properly attach when 
            the geometry node is added, even if it is not available when the
            component is constructed. 
        */
        updateGeometryComponent()
        
        // Generate a new target brightness for the light every frame.
        targetLightBrightness = nextTargetLightBrightness()
        
        // Update the light's brightness every frame, causing the light to flicker.
        lightBrightness = nextLightBrightness
    }
    
    /**
        Attaches the particle emitter and light to the box if the entity has a geometry component and has not had them attached previously.
    */
    func updateGeometryComponent() {
        /*
            If the geometry component has been created, but the particle effect 
            has not been attached to the box yet, then add the particle system 
            and light to the box node.
        */
        if let geometryComponent = geometryComponent, !boxHasParticleEffect {
            geometryComponent.node.addParticleSystem(particleEmitter)
            geometryComponent.node.light = boxLight
        } 
        
        /*
            Update the flag indicating if the particle effect has been attached 
            to the box, so the next call to `updateGeometryComponent(_:)` has
            accurate information about the state of the geometry component.
        */
        boxHasParticleEffect = geometryComponent != nil
    }
    
    // MARK: Light Flickering Algorithm
    
    /**
        Randomly adjusts the light's target brightness, the brightness that
        the light is attempting to match.
    
        This is a method because it is not idempotent, since it uses a random
        source to produce different results each time it is called. 
    */
    func nextTargetLightBrightness() -> CGFloat {
        // Randomly decide to increase or decrease the light's target brightness.
        let increaseLightTargetBrightness = randomSource.nextBool()
        let delta: CGFloat = increaseLightTargetBrightness ? 0.2 : -0.2
        
        // Calculate the adjusted value.
        let newTargetLightBrightness = targetLightBrightness + delta
        
        // Keep the light's target brightness between 0 and 1.
        let clampedLightBrightness = (newTargetLightBrightness...newTargetLightBrightness).clamped(to: (0...1)).lowerBound
        
        return clampedLightBrightness
    }
}
