/**
 * The 'd3-sunburst' component visualizes tree nodes as donut sectors,
 * with the root circle in the center. The angle and area of each sector corresponds
 * to its {@link Ext.d3.hierarchy.Hierarchy#nodeValue value}. By default
 * the same value is returned for each node, meaning that siblings will span equal
 * angles and occupy equal area.
 *
 *     @example
 *     Ext.create('Ext.panel.Panel', {
 *         renderTo: Ext.getBody(),
 *         title: 'Sunburst Chart',
 *         height: 750,
 *         width: 750,
 *         layout: 'fit',
 *         items: [
 *             {
 *                 xtype: 'd3-sunburst',
 *                 padding: 20,
 *                 tooltip: {
 *                     renderer: function (component, tooltip, node) {
 *                         tooltip.setHtml(node.data.get('text'));
 *                     }
 *                 },
 *                 store: {
 *                     type: 'tree',
 *                     data: [
 *                         {
 *                             text: "Oscorp",
 *                             children: [
 *                                 {text: 'Norman Osborn'},
 *                                 {text: 'Harry Osborn'},
 *                                 {text: 'Arthur Stacy'}
 *                             ]
 *                         },
 *                         {
 *                             text: "SHIELD",
 *                             children: [
 *                                 {text: 'Nick Fury'},
 *                                 {text: 'Maria Hill'},
 *                                 {text: 'Tony Stark'}
 *                             ]
 *                         },
 *                         {
 *                             text: "Illuminati",
 *                             children: [
 *                                 {text: 'Namor'},
 *                                 {text: 'Tony Stark'},
 *                                 {text: 'Reed Richards'},
 *                                 {text: 'Black Bolt'},
 *                                 {text: 'Stephen Strange'},
 *                                 {text: 'Charles Xavier'}
 *                             ]
 *                         }
 *                     ]
 *                 }
 *             }
 *         ]
 *     });
 *
 */
Ext.define('Ext.d3.hierarchy.partition.Sunburst', {
    extend: 'Ext.d3.hierarchy.partition.Partition',
    xtype: 'd3-sunburst',
 
    config: {
        componentCls: 'sunburst',
 
        /**
         * The padding of a node's text inside its container.
         * @cfg {Array} textPadding
         */
        textPadding: [5, '0.35em'],
 
        /**
         * The radius of the dot in the center of the sunburst that represents the parent node
         * of the currently visible node hierarchy and allows to zoom one level up by clicking
         * or tapping it.
         * @cfg {Number} [zoomParentDotRadius=30]
         */
        zoomParentDotRadius: 30,
 
        transitions: {
            zoom: {
                duration: 1000,
                ease: 'cubicInOut'
            }
        }
    },
 
    setupScene: function (scene) {
        this.callParent([scene]);
        this.setupScales();
        this.setupArcGenerator();
    },
 
    scaleDefaults: {
        x: {
            domain: [0, 1],
            range: [0, 2 * Math.PI]
        },
        y: {
            domain: [0, 1]
        }
    },
 
    setupScales: function () {
        var defaults = this.scaleDefaults;
        // Node's x0 & x1 properties will represent the angle.
        // Node's y0 & y1 properties will represent the area
        // divided by π (since circle area = πr², we can treat
        // the area as if it's been already divided by π and
        // remove it from the right side of the equation as well,
        // the relationship is still preserved, and we can simply
        // take a square root of the area to get the radius).
        this.xScale = d3.scaleLinear()
            .domain(defaults.x.domain.slice())
            .range(defaults.x.range.slice());
 
        this.yScale = d3.scaleSqrt()
            .domain(defaults.y.domain.slice());
    },
 
    /**
     * [Arc generator](https://github.com/mbostock/d3/wiki/SVG-Shapes#arc)
     * for sunburst slices.
     * @private
     * @property {Function} arc
     */
    arc: null,
 
    defaultCls: {
        center: Ext.baseCSSPrefix + 'd3-center'
    },
 
    setupArcGenerator: function () {
        var me = this,
            x = me.xScale,
            y = me.yScale;
 
        // Takes a node of a partition layout and returns an arc (in SVG path syntax)
        // that represents it.
        me.arc = d3.arc()
            .startAngle(function (node) {
                return Math.max(0, Math.min(2 * Math.PI, x(node.x0)));
            })
            .endAngle(function (node) {
                return Math.max(0, Math.min(2 * Math.PI, x(node.x1)));
            })
            .innerRadius(function (node) {
                return Math.max(0, y(node.y0));
            })
            .outerRadius(function (node) {
                return Math.max(0, y(node.y1));
            });
    },
 
    /**
     * @protected
     * Override parent method to neither set the layout size,
     * nor perform layout on scene resize.
     * The default layout size of 1x1 is used at all times.
     * Only the output range of scales changes.
     */
    onSceneResize: function (scene, rect) {
        var me = this,
            nodesGroup = me.nodesGroup,
            centerX = .5 * rect.width,
            centerY = .5 * rect.height,
            radius = Math.min(centerX, centerY);
 
        nodesGroup.attr('transform', 'translate(' + centerX + ',' + centerY + ')');
 
        me.setRadius(radius);
    },
 
    radius: null,
    minRadius: 1,
 
    setRadius: function (radius) {
        var me = this;
 
        radius = Math.max(me.minRadius, radius);
        me.radius = radius;
        me.yScale.range([0, radius]);
 
        me.renderScene();
    },
 
    /**
     * Zooms in the `node`, so that the sunburst only shows the node itself and its children.
     * To zoom in instantly, even when the {@link #transitions} `zoom` config is not `false`,
     * set the second argument to `true`.
     * @param {Ext.data.TreeModel} record 
     * @param {Boolean} [instantly] 
     */
    zoomInNode: function (record, instantly) {
        var me = this,
            scene = me.getScene(),
            parentRadius = me.getZoomParentDotRadius(),
            radius = me.radius,
            xScale = me.xScale,
            yScale = me.yScale,
            arc = me.arc,
            transition, node, nodes;
 
        if (me.hasFirstLayout && me.hasFirstRender && me.size && record && record.isNode) {
            node = me.nodeFromRecord(record);
        }
        if (!node) {
            return;
        }
 
        transition = me.createTransition(instantly ? 'none' : 'zoom', scene);
 
        nodes = transition.tween('scale', function () {
                // Default xScale and yScale domain is [0, 1].
                // Default xScale range is [0, 2π].
                // By reducing the xScale's domain to the span of selected slice,
                // we make it occupy the whole pie angle.
                // Similarly, by reducing the yScale's domain to an interval
                // past slice's radius, we make that slice and its children
                // occupy the whole pie radius.
                // By making the yScale's range start with a non-zero value,
                // we make a hole in the current subtree that now occupies
                // the whole pie. Inside that hole the parent node (that now
                // falls out of yScale's range) is going to be visible
                // and available for selection to go one level up.
                var xDomain = d3.interpolate(xScale.domain(), [node.x0, node.x1]),
                    yDomain = d3.interpolate(yScale.domain(), [node.y0, 1]),
                    yRange = d3.interpolate(yScale.range(), [node.y0 ? parentRadius : 0, radius]);
 
                return function (t) {
                    xScale.domain(xDomain(t));
                    yScale.domain(yDomain(t)).range(yRange(t));
                };
            })
            .selectAll('.' + me.defaultCls.node);
 
        nodes.selectAll('path')
            .attrTween('d', function (node) {
                return function (t) {
                    // Layout stays exactly the same, but scales
                    // change slightly on every frame.
                    return arc(node);
                };
            });
 
        nodes.selectAll('text')
            .call(me.positionTextFn.bind(me))
            .call(me.textVisibilityFn.bind(me));
 
        if (instantly) {
            me.xScale.domain([node.x0, node.x1]);
            me.yScale.domain([node.y0, 1]).range([node.y0 ? parentRadius : 0, radius]);
        }
    },
 
    onNodeSelect: function (node, el) {
        var me = this,
            transitionCfg = me.getTransitions().select,
            to = transitionCfg.targetScale,
            from = transitionCfg.sourceScale,
            transition = me.createTransition('select');
 
        me.callParent(arguments);
 
        // Bring selected element to front to avoid the stroke being clipped by adjacent elements.
        // Remove the fill, so that CSS can be used to specify the color of the selection.
        el.raise().select('path').style('fill', null);
 
        if (transition.duration()) {
            el
                .transition(transition)
                .attr('transform', 'scale(' + to +  ',' + to + ')')
                .transition(transition)
                .attr('transform', 'scale(' + from +  ',' + from + ')');
        }
    },
 
    onNodeDeselect: function (node, el) {
        var me = this,
            colorAxis = me.getColorAxis();
 
        me.callParent(arguments);
 
        // Restore the original color.
        // (see 'onNodeSelect' comments).
        el
            .select('path')
            .style('fill', function (node) {
                return colorAxis.getColor(node);
            });
    },
 
    /**
     * @private
     * Checks if a bounding box (e.g. of a text) fits inside a slice.
     * The bounding box is assumed to be centered in the middle of the slice
     * angularly, with the width of the box in the direction of the radius,
     * and left edge 'px' pixels from inner radius (r1).
     * @param {Object} bbox 
     * @param {Number} bbox.width 
     * @param {Number} bbox.height 
     * @param {Number} a1 Start angle in the [0, 2 * Math.PI] interval.
     * @param {Number} a2 End angle in the [0, 2 * Math.PI] interval.
     * @param {Number} r1 Inner radius.
     * @param {Number} r2 Outer radius.
     * @param {Number} px X-padding.
     * @param {Number} py Y-padding.
     * @returns {Boolean} 
     */
    isBBoxInSlice: function (bbox, a1, a2, r1, r2, px, py) {
        var a = Math.abs(a2 - a1),
            width = Math.abs(r2 - r1) - px * 2,
            height = a < Math.PI
                ? 2 * (r1 + px) * Math.tan(0.5 * a) - py * 2
                : 0.5 * r2, // for very big angles text is never too tall,
                            // so there must be some other limit
            isWider = bbox.width > width,
            isTaller = bbox.height > height;
 
        return !(isWider || isTaller);
    },
 
    /**
     * @private
     */
    textVisibilityFn: function (selection) {
        var me = this,
            x = me.xScale,
            y = me.yScale,
            invisibleCls = me.defaultCls.invisible,
            textPadding = me.getTextPadding(),
            px = parseFloat(textPadding[0]),
            py = parseFloat(textPadding[1]),
            isTransition = selection instanceof d3.transition;
 
        function isInvisible(el, node) {
            //<debug>
            if (me.isDestroyed) {
                Ext.log.warn("Component is destroyed, shouldn't have executed this.");
            }
            //</debug>
            var bbox = el._bbox || el.getBBox(), // SVG 'text' element
                a1 = x(node.x0),
                a2 = x(node.x1),
                r1 = y(node.y0),
                r2 = y(node.y1),
                isBBoxInSlice = me.isBBoxInSlice(bbox, a1, a2, r1, r2, px, py),
                xDomain = x.domain(),
                yDomain = y.domain(),
                isOutOfX = xDomain[0] > node.x0 || xDomain[1] < node.x1,
                isOutOfY = yDomain[0] > node.y0 || yDomain[1] < node.y1;
 
            return !isBBoxInSlice || isOutOfX || isOutOfY;
        }
 
        if (isTransition) {
            selection.tween('class.invisible', function (node) {
                var el = this;
                return function () {
                    d3.select(el).classed(invisibleCls, isInvisible(el, node));
                };
            });
        } else {
            selection.classed(invisibleCls, function (node) {
                return isInvisible(this, node);
            });
        }
    },
 
    /**
     * @private
     * @param {d3.selection} selection 'text' elements.
     */
    positionTextFn: function (selection) {
        var me = this,
            x = me.xScale,
            y = me.yScale,
            halfPi = Math.PI / 2,
            degreesPerRadian = 180 / Math.PI,
            isTween = selection instanceof d3.transition,
            method = isTween ? 'attrTween' : 'attr',
            xFn, transformFn;
 
        function getX(node) {
            return y(node.y0);
        }
        function getTransform(node) {
            return node === me.root ? ''
                : ('rotate(' + (x((node.x0 + node.x1) / 2) - halfPi) * degreesPerRadian + ')');
        }
 
        if (isTween) {
            // Interpolator factory evaluated for every element on transition start.
            xFn = function (node) {
                // Interpolator, invoked for every frame of transition and is given time t in [0, 1].
                return function () {
                    // We don't use the time here, as the running transition will be changing
                    // the domain of the scale used by the `getX` function, so each frame the result
                    // will be different even if `node.y` doesn't change. See the `zoomInNode`
                    // method for more details.
                    return getX(node);
                };
            };
            transformFn = function (node) {
                return function () {
                    return getTransform(node);
                };
            };
        } else {
            xFn = function (node) {
                return getX(node);
            };
            transformFn = function (node) {
                return getTransform(node);
            };
        }
 
        selection
            [method]('x', xFn)
            [method]('transform', transformFn);
    },
 
    addNodes: function (selection) {
        var me = this,
            textPadding = me.getTextPadding();
 
        selection
            .append('path')
            .attr('d', me.arc);
 
        selection
            .append('text')
            .attr('class', me.defaultCls.label)
            .each(function (node) {
                if (node !== me.root) {
                    this.setAttribute('dx', textPadding[0]);
                    this.setAttribute('dy', textPadding[1]);
                }
            });
    },
 
    measureLabels: function (selection) {
        var isTransition = selection instanceof d3.transition;
 
        if (!isTransition) {
            selection.each(function () {
                // Cache the bounding box on the element itself each time data updates
                // to use later during a transition.
                this._bbox = this.getBBox();
            });
        }
    },
 
    updateNodes: function (update, enter) {
        var me = this,
            colorAxis = me.getColorAxis(),
            nodeText = me.getNodeText(),
            selectionCfg = me.getSelection(),
            selection = update.merge(enter);
 
        selection
            .select('path')
            .attr('d', me.arc)
            .style('fill', function (node) {
                // Don't set the color of selected element to allow for CSS styling.
                return node.data === selectionCfg ? null : colorAxis.getColor(node);
            });
 
        selection
            .select('text')
            .text(function (node) {
                return nodeText(me, node);
            })
            .call(me.measureLabels.bind(me))
            .call(me.positionTextFn.bind(me))
            .call(me.textVisibilityFn.bind(me));
 
        me.nodesGroup.select('.' + me.defaultCls.selected).raise();
    },
 
    updateColorAxis: function (colorAxis) {
        var me = this;
 
        if (!me.isConfiguring) {
            me.getRenderedNodes()
                .select('path')
                .style('fill', function (node) {
                    return colorAxis.getColor(node);
                });
        }
    }
 
});