/* globals Power2, Sine */
/*eslint no-console: ["error", { allow: ["log", "info", "error"] }]*/

/**
 * Callback for the flippable onStart function.
 *
 * @callback onStartCallback
 * @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).
 */

/**
 * Callback for the flippable onUpdate function.
 *
 * @callback onUpdateCallback
 * @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).
 */

/**
 * Callback for the flippable onComplete function.
 *
 * @callback onCompleteCallback
 * @param {Flippable} flippable - A reference to the flippable (also this refers to the flippable).
 */

/**
 * Class that represents a PixiJS Flippable.
 *
 * @example
 * const front = PIXI.Sprite.from('./assets/front.jpg')
 * const back = PIXI.Sprite.from('./assets/back.jpg')
 * app.scene.addChild(front)
 *
 * // Create the flippable
 * const flippable = new Flippable(front, back, app.renderer)
 *
 * front.interactive = true
 * front.on('click', event => flippable.toggle())
 *
 * @class
 * @extends PIXI.projection.Camera3d
 * @see {@link https://github.com/pixijs/pixi-projection|PixiJS Projection}
 * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/flippable.html|DocTest}
 */
export default class Flippable extends PIXI.projection.Camera3d {
    /**
     * Creates an instance of a Flippable.
     *
     * @constructor
     * @param {PIXI.DisplayObject} front - The object to show initially. Should have been added to the scene.
     * @param {PIXI.DisplayObject} back - The object to show on the backside. Should have not been added to the scene.
     * @param {PIXI.Renderer|PIXI.CanvasRenderer} renderer - The renderer of the application.
     * @param {object} [opts] - An options object which can contain the following properties.
     * @param {number} [opts.duration=1] - The duration of the flip animation in seconds.
     * @param {GSAP.Ease} [opts.ease=Power2.easeOut] - The ease of the flip animation.
     * @param {boolean} [opts.shadow=false] - Should be a shadow been display during the animation?
     * @param {numer} [opts.eulerX=0] - The shift of the x-axis during the animation.
     * @param {numer} [opts.eulerY=0] - The shift of the y-axis during the animation.
     * @param {GSAP.Ease} [opts.eulerEase=Power1.easeOut] - The ease of the shift.
     * @param {boolean} [opts.useBackTransforms=false] - When set to true, the flip animation also animates to the transform parameters of the back-object.
     * @param {GSAP.Ease} [opts.transformEase=Power2.easeOut] - The ease of the transform.
     * @param {numer} [opts.focus=800] - The value of the focus of the 3D camera (see pixi-projection).
     * @param {numer} [opts.near=10] - The near value of the 3D camera (see pixi-projection).
     * @param {numer} [opts.far=10000] - The far value of the 3D camera (see pixi-projection).
     * @param {boolean} [opts.orthographic=false] - Should the flip animation be an orthographic animation?
     * @param {function} [opts.onStart=null] - A callback executed on start of the flip animation.
     * @param {function} [opts.onUpdate=null] - A callback executed on each step of the flip animation.
     * @param {function} [opts.onComplete=null] - A callback executed when the flip animation is finished.
     */
    constructor(front, back, renderer, opts = {}) {
        super()

        this.opts = Object.assign(
            {},
            {
                front,
                back,
                renderer,
                duration: 1,
                ease: Power2.easeOut,
                shadow: false,
                eulerX: 0,
                eulerY: 0,
                eulerEase: Power1.easeOut,
                useBackTransforms: false,
                transformEase: Power2.easeOut,
                focus: 800,
                near: 10,
                far: 10000,
                orthographic: false
            },
            opts
        )

        // planes
        //--------------------
        this.setPlanes(this.opts.focus, this.opts.near, this.opts.far, this.opts.orthographic)

        // flipped
        //--------------------
        this._flipped = false

        // objects
        //--------------------
        this.objects = {}

        // setup
        //--------------------
        this.setup()
    }

    /**
     * Creates children and instantiates everything.
     *
     * @private
     * @return {Flippable} A reference to the flippable for chaining.
     */
    setup() {
        const scale = 0.5

        // filters
        //--------------------
        const blurFilter = new PIXI.filters.BlurFilter()
        blurFilter.blur = 0.2
        this.objects.blurFilter = blurFilter

        // outer
        //--------------------
        const outer = new PIXI.projection.Container3d()
        outer.scale3d.set(scale)
        this.addChild(outer)
        this.objects.outer = outer

        // shadow
        //--------------------
        const shadow = new PIXI.projection.Sprite3d(PIXI.Texture.from('../../assets/images/shadow.png'))
        shadow.renderable = false
        shadow.anchor.set(0.5)
        shadow.scale3d.set(0.98)
        shadow.alpha = 0.7
        shadow.filters = [blurFilter]
        shadow.visible = this.opts.shadow
        outer.addChild(shadow)
        this.objects.shadow = shadow

        // inner
        //--------------------
        const inner = new PIXI.projection.Container3d()
        inner.euler.y = Math.PI
        outer.addChild(inner)
        this.objects.inner = inner

        // front
        //--------------------
        const front = new PIXI.projection.Sprite3d(PIXI.Texture.EMPTY)
        front.scale.set(-1 / scale, 1 / scale)
        front.renderable = true
        front.anchor.set(0.5)
        inner.addChild(front)
        this.objects.front = front

        // back
        //--------------------
        const back = new PIXI.projection.Sprite3d(PIXI.Texture.EMPTY)
        back.scale.set(1 / scale, 1 / scale)
        back.renderable = false
        back.anchor.set(0.5)
        inner.addChild(back)
        this.objects.back = back

        return this
    }

    /**
     * Gets or sets the flipped state.
     *
     * @member {boolean}
     */
    get flipped() {
        return this._flipped
    }
    set flipped(toBack) {
        this._flipped = toBack

        // references
        //--------------------
        const front = this.objects.front
        const back = this.objects.back
        const inner = this.objects.inner
        const shadow = this.objects.shadow
        const blurFilter = this.objects.blurFilter

        const half = this.opts.duration / 2
        const ease = this.opts.eulerEase

        const fromObject = toBack ? this.opts.front : this.opts.back
        const toObject = toBack ? this.opts.back : this.opts.front

        // set textures for virtual front and virtual back
        //--------------------
        front.texture = this.generateTexture(this.opts.front)
        back.texture = this.generateTexture(this.opts.back)

        // switch objects and set params for virtual objects
        //--------------------
        const fromCenter = this.anchorToCenter(fromObject)
        const toCenter = this.anchorToCenter(toObject)

        // from values
        //--------------------
        this.x = fromCenter.x
        this.y = fromCenter.y
        front.width = fromObject.width * 2
        front.height = fromObject.height * 2
        back.width = fromObject.width * 2
        back.height = fromObject.height * 2
        this.rotation = fromObject.rotation
        this.skew.x = fromObject.skew.x
        this.skew.y = fromObject.skew.y

        // calculate to values
        //--------------------
        const to = {
            x: this.opts.useBackTransforms ? toCenter.x : fromCenter.x,
            y: this.opts.useBackTransforms ? toCenter.y : fromCenter.y,
            anchorX: this.opts.useBackTransforms ? toObject.x : fromObject.x,
            anchorY: this.opts.useBackTransforms ? toObject.y : fromObject.y,
            width: this.opts.useBackTransforms ? toObject.width * 2 : fromObject.width * 2,
            height: this.opts.useBackTransforms ? toObject.height * 2 : fromObject.height * 2,
            rotation: this.opts.useBackTransforms ? toObject.rotation : fromObject.rotation,
            skewX: this.opts.useBackTransforms ? toObject.skew.x : fromObject.skew.x,
            skewY: this.opts.useBackTransforms ? toObject.skew.y : fromObject.skew.y
        }

        // set toObject end values
        //--------------------
        toObject.x = to.anchorX
        toObject.y = to.anchorY
        toObject.width = to.width / 2
        toObject.height = to.height / 2
        toObject.rotation = to.rotation
        toObject.skew.x = to.skewX
        toObject.skew.y = to.skewY

        // flip
        //--------------------
        TweenLite.to(inner.euler, this.opts.duration, {
            y: toBack ? 0 : Math.PI,
            ease: this.opts.ease,
            onStart: () => {
                this.switchDisplayObject(fromObject, this)
                shadow.renderable = true
                if (this.opts.onStart) {
                    this.opts.onStart(this, this)
                }
            },
            onUpdate: () => {
                this.layout()
                if (this.opts.onUpdate) {
                    this.opts.onUpdate(this, this)
                }
            },
            onComplete: () => {
                this.switchDisplayObject(this, toObject)
                shadow.renderable = false
                if (this.opts.onComplete) {
                    this.opts.onComplete(this, this)
                }
            }
        })

        // x & y
        //--------------------
        TweenLite.to(this, this.opts.duration, {
            x: to.x,
            y: to.y,
            ease: this.opts.transformEase
        })

        // width & height
        //--------------------
        TweenLite.to([front, back], this.opts.duration, {
            width: to.width,
            height: to.height,
            ease: this.opts.transformEase
        })

        // rotation
        //--------------------
        TweenLite.to(this, this.opts.duration, {
            directionalRotation: {
                rotation: `${to.rotation}_short`,
                useRadians: true
            },
            ease: this.opts.transformEase
        })

        // skewX & skewY
        //--------------------
        TweenLite.to(this.skew, this.opts.duration, {
            x: to.skewX,
            y: to.skewY,
            ease: this.opts.transformEase
        })

        // camera
        //--------------------
        new TimelineMax()
            .to(this.euler, half, {
                x: this.opts.eulerX,
                y: this.opts.eulerY,
                ease
            })
            .to(this.euler, half, { x: 0, y: 0, ease })

        // shadow
        //--------------------
        new TimelineMax().to(shadow, half, { alpha: 0.3, ease }).to(shadow, half, { alpha: 0.7, ease })

        // blurfilter
        //--------------------
        new TimelineMax().to(blurFilter, half, { blur: 6, ease }).to(blurFilter, half, { blur: 0.2, ease })
    }

    /**
     * Should be called to refresh the layout of the camera.
     *
     * @return {Flippable} A reference to the flippable for chaining.
     */
    layout() {
        const front = this.objects.front
        const back = this.objects.back
        const shadow = this.objects.shadow
        const inner = this.objects.inner

        inner.position3d.z = -Math.sin(inner.euler.y) * front.texture.baseTexture.width * 2

        //this.objects.shadow.euler = this.objects.inner.euler
        shadow.euler.x = -inner.euler.x
        shadow.euler.y = -inner.euler.y

        if (this.frontSideInFront) {
            front.renderable = true
            back.renderable = false
            shadow.width = front.width
            shadow.height = front.height
        } else {
            front.renderable = false
            back.renderable = true
            shadow.width = back.width
            shadow.height = back.height
        }

        return this
    }

    /**
     * Toggles the flippable. Switches the sides.
     *
     * @private
     * @return {Flippable} A reference to the flippable for chaining.
     */
    toggle() {
        this.flipped = !this.flipped

        return this
    }

    /**
     * Gets the alignment state. true if the front side is in front, false otherwise.
     *
     * @member {boolean}
     */
    get frontSideInFront() {
        return !this.objects.inner.isFrontFace()
    }

    /**
     * Calculates the center point of an PIXI.DisplayObject.
     *
     * @private
     * @param {PIXI.DisplayObject} displayObject - The DisplayObject from which to calculate the center.
     * @return {object} Return an object with x and y.
     */
    anchorToCenter(displayObject) {
        const bounds = displayObject.getBounds()
        return {
            x: bounds.x + bounds.width / 2,
            y: bounds.y + bounds.height / 2
        }
    }

    /**
     * Creates children and instantiates everything.
     *
     * @private
     * @param {PIXI.DisplayObject} displayObject - The DisplayObject from which to generate the texture.
     * @return {PIXI.Texture} The generated PIXI.Texture.
     */
    generateTexture(displayObject) {
        // renderTexture
        //--------------------
        const renderTexture = PIXI.RenderTexture.create(displayObject.width, displayObject.height)

        // save position
        const transform = [
            displayObject.x,
            displayObject.y,
            displayObject.scale.x,
            displayObject.scale.y,
            displayObject.rotation,
            displayObject.skew.x,
            displayObject.skew.y,
            displayObject.pivot.x,
            displayObject.pivot.y
        ]

        displayObject.position.set(0, 0)
        displayObject.skew.set(0, 0)
        displayObject.rotation = 0

        // render
        //--------------------
        this.opts.renderer.render(displayObject, renderTexture)

        // restore position
        displayObject.setTransform(...transform)

        return renderTexture
    }

    /**
     * Removed the first DisplayObject and adds the second one at the exactly same position.
     *
     * @private
     * @param {PIXI.DisplayObject} first - The old DisplayObject.
     * @param {PIXI.DisplayObject} second - The new DisplayObject.
     * @return {Flippable} A reference to the flippable for chaining.
     */
    switchDisplayObject(first, second) {
        if (first && second && first.parent) {
            const parent = first.parent
            const index = parent.getChildIndex(first)
            parent.addChildAt(second, index)
            parent.removeChild(first)
        }

        return this
    }
}