import Theme from './theme.js'
import Tooltip from './tooltip.js'

/**
 * Callback for the slider action onStart.
 *
 * @callback onStartCallback
 * @param {object} event - The event object.
 * @param {Slider} slider - A reference to the slider (also this refers to the slider).
 */

/**
 * Callback for the slider action onUpdate.
 *
 * @callback onUpdateCallback
 * @param {object} event - The event object.
 * @param {Slider} slider - A reference to the slider (also this refers to the slider).
 */

/**
 * Callback for the slider action onComplete.
 *
 * @callback onCompleteCallback
 * @param {object} event - The event object.
 * @param {Slider} slider - A reference to the slider (also this refers to the slider).
 */

/**
 * Class that represents a PixiJS Slider.
 *
 * @example
 * // Create the app
 * const app = new PIXIApp({
 *     view: canvas,
 *     width: 900,
 *     height: 250
 * }).setup().run()
 *
 * // Create the slider
 * const slider = new Slider({
 *     x: 10,
 *     y: 20
 * })
 *
 * // Add the slider to a DisplayObject
 * app.scene.addChild(slider)
 *
 * @class
 * @extends PIXI.Container
 * @see {@link http://pixijs.download/dev/docs/PIXI.Container.html|PIXI.Container}
 * @see {@link https://www.iwm-tuebingen.de/iwmbrowser/lib/pixi/slider.html|DocTest}
 */
export default class Slider extends PIXI.Container {
    /**
     * Creates an instance of a Slider.
     *
     * @constructor
     * @param {object} [opts] - An options object to specify to style and behaviour of the slider.
     * @param {number} [opts.id=auto generated] - The id of the slider.
     * @param {number} [opts.x=0] - The x position of the slider. Can be also set after creation with slider.x = 0.
     * @param {number} [opts.y=0] - The y position of the slider. Can be also set after creation with slider.y = 0.
     * @param {string|Theme} [opts.theme=dark] - The theme to use for this slider. Possible values are dark, light, red
     *     or a Theme object.
     * @param {number} [opts.width=250] - The width of the slider.
     * @param {number} [opts.height=2] - The height of the slider.
     * @param {PIXI.DisplayObject} [opts.container=window.app|object] - The container where the slider events should be attached to.
     * @param {number} [opts.fill=Theme.fill] - The color of the slider background as a hex value.
     * @param {number} [opts.fillAlpha=Theme.fillAlpha] - The alpha value of the background.
     * @param {number} [opts.stroke=Theme.stroke] - The color of the border as a hex value.
     * @param {number} [opts.strokeWidth=Theme.strokeWidth] - The width of the border in pixel.
     * @param {number} [opts.strokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
     * @param {number} [opts.controlFill=Theme.stroke] - The color of the slider control background as a hex value.
     * @param {number} [opts.controlFillAlpha=Theme.strokeAlpha] - The alpha value of the background.
     * @param {number} [opts.controlStroke=Theme.stroke] - The color of the border as a hex value.
     * @param {number} [opts.controlStrokeWidth=Theme.strokeWidth * 0.8] - The width of the border in pixel.
     * @param {number} [opts.controlStrokeAlpha=Theme.strokeAlpha] - The alpha value of the border.
     * @param {number} [opts.controlRadius=16] - The radius of the slider control.
     * @param {boolean} [opts.disabled=false] - Is the slider disabled? When disabled, the slider has a lower alpha value
     *     and cannot be clicked (interactive is set to false).
     * @param {onStartCallback} [opts.onStart] - Executed when the slider control starts to move.
     * @param {onUpdateCallback} [opts.onUpdate] - Executed when the slider control is moved.
     * @param {onCompleteCallback} [opts.onComplete] - Executed when the slider control was dropped.
     * @param {string|object} [opts.tooltip] - A string for the label of the tooltip or an object to configure the tooltip
     *     to display.
     * @param {boolean} [opts.visible=true] - Is the slider initially visible (property visible)?
     */
    constructor(opts = {}) {
        super()

        const theme = Theme.fromString(opts.theme)
        this.theme = theme

        this.opts = Object.assign(
            {},
            {
                id: PIXI.utils.uid(),
                x: 0,
                y: 0,
                width: 250,
                height: 2,
                container: null,
                fill: theme.fill,
                fillAlpha: theme.fillAlpha,
                stroke: theme.stroke,
                strokeWidth: theme.strokeWidth,
                strokeAlpha: theme.strokeAlpha,
                controlFill: theme.fill,
                controlFillAlpha: 0.5,
                controlStroke: theme.primaryColor,
                controlStrokeWidth: 2,
                controlStrokeAlpha: theme.strokeAlpha,
                controlRadius: 16,
                orientation: 'horizontal',
                min: 0,
                max: 100,
                value: 0,
                disabled: false,
                onStart: null,
                onUpdate: null,
                onComplete: null,
                tooltip: null,
                visible: true
            },
            opts
        )

        this.opts.container = this.opts.container || this

        // Validation
        //-----------------
        if (this.opts.height > this.opts.width) {
            this.opts.height = this.opts.width
        }

        if (this.opts.value < this.opts.min) {
            this.opts.value = this.opts.min
        }

        if (this.opts.value > this.opts.max) {
            this.opts.value = this.opts.max
        }

        // Properties
        //-----------------
        this.id = this.opts.id
        this.radius = this.opts.height / 2

        this._value = this.opts.value
        this._disabled = null

        this.sliderObj = null
        this.control = null
        this.tooltip = null

        this.visible = this.opts.visible

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

        // layout
        //-----------------
        this.layout()
    }

    /**
     * Creates children and instantiates everything.
     *
     * @private
     * @return {Slider} A reference to the slider for chaining.
     */
    setup() {
        // Container events
        //-----------------
        const container = this.opts.container

        this.on('pointermove', e => {
            if (this.control.dragging) {
                const moveX = this.control.event.data.getLocalPosition(
                    this.control.parent
                ).x
                this._value = this.pixelToValue(
                    moveX - this.control.delta - this.opts.controlRadius
                )
                let x = this.valueToPixel(this._value) + this.opts.controlRadius
                this.control.x = x

                if (this.opts.onUpdate) {
                    this.opts.onUpdate.call(this, e, this)
                }
            }
        })

        if (container instanceof Element) {
            container.addEventListener('pointerup', e => this.onEnd(e), false)
            container.addEventListener(
                'pointercancel',
                e => this.onEnd(e),
                false
            )
            container.addEventListener(
                'pointerleave',
                e => this.onEnd(e),
                false
            )
            container.addEventListener('pointerout', e => this.onEnd(e), false)
            container.addEventListener('mouseup', e => this.onEnd(e), false)
            container.addEventListener('mousecancel', e => this.onEnd(e), false)
            container.addEventListener('mouseleave', e => this.onEnd(e), false)
            container.addEventListener('mouseout', e => this.onEnd(e), false)
        } else {
            container.interactive = true
            container.on('pointerup', e => this.onEnd(e))
            container.on('pointercancel', e => this.onEnd(e))
            container.on('pointerleave', e => this.onEnd(e))
            container.on('pointerout', e => this.onEnd(e))
        }

        // Slider
        //-----------------
        let sliderObj = new PIXI.Graphics()
        this.sliderObj = sliderObj
        this.addChild(sliderObj)

        // Control
        //-----------------
        let control = new PIXI.Graphics()
        control.x = this.opts.controlRadius + this.valueToPixel(this.opts.value)
        control.y = this.opts.controlRadius

        // pointerdown on the control for dragndrop
        control.on('pointerdown', e => {
            control.event = e
            control.delta = e.data.getLocalPosition(this.control).x
            control.dragging = true

            if (this.opts.onStart) {
                this.opts.onStart.call(this, e, this)
            }
        })

        this.control = control

        this.addChild(this.control)

        // interaction
        //-----------------
        this.sliderObj.on('pointerover', e => {
            TweenLite.to(this.control, this.theme.fast, { alpha: 0.83 })
        })

        this.sliderObj.on('pointerout', e => {
            TweenLite.to(this.control, this.theme.fast, { alpha: 1 })
        })

        this.sliderObj.on('pointerdown', e => {
            this.sliderObj.pointerdowned = true
            TweenLite.to(this.control, this.theme.fast, { alpha: 0.7 })
        })

        // Click on the slider bar
        this.sliderObj.on('pointerup', e => {
            if (this.sliderObj.pointerdowned) {
                this.sliderObj.pointerdowned = false
                const position = e.data.getLocalPosition(this.control.parent)
                this.value = this.pixelToValue(
                    position.x - this.opts.controlRadius
                )
                TweenLite.to(this.control, this.theme.fast, { alpha: 0.83 })
            }
        })

        // disabled
        //-----------------
        this.disabled = this.opts.disabled

        // tooltip
        //-----------------
        if (this.opts.tooltip) {
            if (typeof this.opts.tooltip === 'string') {
                this.tooltip = new Tooltip({
                    object: this,
                    content: this.opts.tooltip
                })
            } else {
                this.opts.tooltip.object = this
                this.tooltip = new Tooltip(this.opts.tooltip)
            }
        }

        return this
    }

    /**
     * Should be called to refresh the layout of the slider. Can be used after resizing.
     *
     * @return {Slider} A reference to the slider for chaining.
     */
    layout() {
        // set position
        //-----------------
        this.position.set(this.opts.x, this.opts.y)

        // draw
        //-----------------
        this.draw()

        return this
    }

    /**
     * Draws the slider to the canvas.
     *
     * @private
     * @return {Slider} A reference to the slider for chaining.
     */
    draw() {
        const r = this.radius
        const cr = this.opts.controlRadius
        const w = this.opts.width
        const h = this.opts.height
        const x = cr + r
        const y = cr + r - h

        this.sliderObj.clear()
        this.sliderObj.beginFill(0xffffff, 0)
        this.sliderObj.drawRect(0, 0, x + w + cr, cr * 2)
        this.sliderObj.lineStyle(
            this.opts.strokeWidth,
            this.opts.stroke,
            this.opts.strokeAlpha
        )
        this.sliderObj.beginFill(this.opts.fill, this.opts.fillAlpha)
        this.sliderObj.moveTo(x, y)
        this.sliderObj.lineTo(x + w, y)
        this.sliderObj.arcTo(x + w + r, y, x + w + r, y + r, r)
        this.sliderObj.lineTo(x + w + r, y + r + 1) // BUGFIX: If not specified, there is a small area without a stroke.
        this.sliderObj.arcTo(x + w + r, y + h, x + w, y + h, r)
        this.sliderObj.lineTo(x, y + h)
        this.sliderObj.arcTo(x - r, y + h, x - r, y + r, r)
        this.sliderObj.arcTo(x - r, y, x, y, r)
        this.sliderObj.endFill()

        // Draw control
        this.control.clear()
        this.control.lineStyle(
            this.opts.controlStrokeWidth,
            this.opts.controlStroke,
            this.opts.controlStrokeAlpha
        )
        this.control.beginFill(
            this.opts.controlFill,
            this.opts.controlFillAlpha
        )
        this.control.drawCircle(0, 0, cr - 1)
        this.control.beginFill(
            this.opts.controlStroke,
            this.opts.controlStrokeAlpha
        )
        this.control.drawCircle(0, 0, cr / 6)
        this.control.endFill()

        return this
    }

    /**
     * Executed, when the slider control movement ended.
     *
     * @private
     * @return {Slider} A reference to the slider for chaining.
     */
    onEnd(e) {
        if (this.control.dragging) {
            this.control.event = null
            this.control.dragging = false
            if (this.opts.onComplete) {
                this.opts.onComplete.call(this, e, this)
            }
        }

        return this
    }

    /**
     * Calculates the value for a given pixel.
     *
     * @private
     * @param {number} value
     * @returns  {number} The calucalted pixel.
     */
    valueToPixel(value) {
        if (value < this.opts.min) {
            value = this.opts.min
        } else if (value > this.opts.max) {
            value = this.opts.max
        }
        return (
            (this.opts.width * (value - this.opts.min)) /
            (this.opts.max - this.opts.min)
        )
    }

    /**
     * Calculates the pixel for a given value.
     *
     * @private
     * @param {number} pixel
     * @returns {number} The calucalted value.
     */
    pixelToValue(pixel) {
        if (pixel < 0) {
            pixel = 0
        } else if (pixel > this.opts.width) {
            pixel = this.opts.width
        }
        return (
            this.opts.min +
            ((this.opts.max - this.opts.min) * pixel) / this.opts.width
        )
    }

    /**
     * Gets or sets the value.
     *
     * @member {number}
     */
    get value() {
        return Math.round(this._value)
    }
    set value(value) {
        if (value < this.opts.min) {
            value = this.opts.min
        } else if (value > this.opts.max) {
            value = this.opts.max
        }
        this._value = value

        const x = this.valueToPixel(value) + this.opts.controlRadius

        TweenLite.to(this.control, this.theme.fast, { x })
    }

    /**
     * Gets or sets the disabled state. When disabled, the slider cannot be clicked.
     *
     * @member {boolean}
     */
    get disabled() {
        return this._disabled
    }
    set disabled(value) {
        this._disabled = value

        if (this._disabled) {
            this.interactive = false
            this.sliderObj.interactive = false
            this.control.interactive = false
            this.control.buttonMode = false
            this.alpha = 0.5
        } else {
            this.interactive = true
            this.sliderObj.interactive = true
            this.control.interactive = true
            this.control.buttonMode = true
            this.alpha = 1
        }
    }

    /**
     * Shows the slider (sets his alpha values to 1).
     *
     * @return {Slider} A reference to the slider for chaining.
     */
    show() {
        this.opts.strokeAlpha = 1
        this.opts.fillAlpha = 1
        this.opts.controlStrokeAlpha = 1
        this.opts.controlFillAlpha = 1

        this.layout()

        return this
    }

    /**
     * Hides the slider (sets his alpha values to 1).
     *
     * @return {Slider} A reference to the slider for chaining.
     */
    hide() {
        this.opts.strokeAlpha = 0
        this.opts.fillAlpha = 0
        this.opts.controlStrokeAlpha = 0
        this.opts.controlFillAlpha = 0

        this.layout()

        return this
    }
}