/**
 * @abstract
 * @class Ext.chart.series.Cartesian
 * @extends Ext.chart.series.Series
 *
 * Common base class for series implementations that plot values using cartesian coordinates.
 *
 * @constructor
 */
Ext.define('Ext.chart.series.Cartesian', {
    extend: 'Ext.chart.series.Series',
    config: {
        /**
         * @cfg {String} xField
         * The field used to access the x axis value from the items from the data source.
         */
        xField: null,
 
        /**
         * @cfg {String|String[]} yField
         * The field(s) used to access the y-axis value(s) of the items from the data source.
         */
        yField: null,
 
        /**
         * @cfg {Ext.chart.axis.Axis|Number|String}
         * xAxis The chart axis the series is bound to in the 'X' direction.
         * Normally, this would be set automatically by the series.
         * For charts with multiple x-axes, this defines which x-axis is used by the series.
         * It refers to either axis' ID or the (zero-based) index of the axis
         * in the chart's {@link Ext.chart.AbstractChart#axes axes} config.
         */
        xAxis: null,
 
        /**
         * @cfg {Ext.chart.axis.Axis|Number|String}
         * yAxis The chart axis the series is bound to in the 'Y' direction.
         * Normally, this would be set automatically by the series.
         * For charts with multiple y-axes, this defines which y-axis is used by the series.
         * It refers to either axis' ID or the (zero-based) index of the axis
         * in the chart's {@link Ext.chart.AbstractChart#axes axes} config.
         */
        yAxis: null
    },
 
    directions: ['X', 'Y'],
 
    /**
     * @private
     *
     * Tells which store record fields should be used for a specific axis direction. E.g. for
     *
     *     fieldCategory<direction>: ['<fieldConfig1>', '<fieldConfig2>', ...]
     *
     * the field names from the following configs will be used:
     *
     *     series.<fieldConfig1>Field, series.<fieldConfig2>Field, ...
     *
     * See {@link Ext.chart.series.StackedCartesian#getFields}.
     *
     */
    fieldCategoryX: ['X'],
    fieldCategoryY: ['Y'],
 
    applyXAxis: function (newAxis, oldAxis) {
        return this.getChart().getAxis(newAxis) || oldAxis;
    },
 
    applyYAxis: function (newAxis, oldAxis) {
        return this.getChart().getAxis(newAxis) || oldAxis;
    },
 
    updateXAxis: function (axis) {
        axis.processData(this);
    },
 
    updateYAxis: function (axis) {
        axis.processData(this);
    },
 
    coordinateX: function () {
        return this.coordinate('X', 0, 2);
    },
 
    coordinateY: function () {
        return this.coordinate('Y', 1, 2);
    },
 
    getItemForPoint: function (x, y) {
        var me = this,
            sprite = me.getSprites()[0],
            store = me.getStore(),
            point;
 
        if (sprite && !me.getHidden()) {
            point = sprite.getNearestDataPoint(x, y);
        }
 
        return point ? {
            series: me,
            sprite: sprite,
            category: me.getItemInstancing() ? 'items' : 'markers',
            index: point.index,
            record: store.getData().items[point.index],
            field: me.getYField(),
            distance: point.distance
        } : null;
    },
 
    createSprite: function () {
        var me = this,
            sprite = me.callParent(),
            chart = me.getChart(),
            xAxis = me.getXAxis();
 
        sprite.setAttributes({
            flipXY: chart.getFlipXY(),
            xAxis: xAxis
        });
        if (sprite.setAggregator && xAxis && xAxis.getAggregator) {
            if (xAxis.getAggregator) {
                sprite.setAggregator({strategy: xAxis.getAggregator()});
            } else {
                sprite.setAggregator({});
            }
        }
        return sprite;
    },
 
    getSprites: function () {
        var me = this,
            chart = this.getChart(),
            sprites = me.sprites;
 
        if (!chart) {
            return Ext.emptyArray;
        }
 
        if (!sprites.length) {
            me.createSprite();
        }
 
        return sprites;
    },
 
    getXRange: function () {
        return [this.dataRange[0], this.dataRange[2]];
    },
 
    getYRange: function () {
        return [this.dataRange[1], this.dataRange[3]];
    }
});