echarts.js

define(function (require) {

    var config = require('./config');
    var GlobalModel = require('./model/Global');
    var zrUtil = require('zrender/core/util');
    var Chart = require('./chart/Chart');
    var Component = require('./component/Component');
    var ExtensionAPI = require('./ExtensionAPI');
    var CoordinateSystemManager = require('./CoordinateSystem');

    var zrender = require('zrender');

    var processors = [];

    /**
     * @module echarts~ECharts
     */
    var ECharts = function (dom, theme) {

        this._zr = zrender.init(dom);

        theme = zrUtil.clone(theme || {});
        zrUtil.merge(theme, config);

        this._theme = theme;

        this._chartsList = [];
        this._chartsMap = {};

        this._componentsList = [];
        this._componentsMap = {};

        this._extensionAPI = new ExtensionAPI(this);

        this._coordinateSystem = new CoordinateSystemManager();
    };

    ECharts.prototype = {

        getZr: function () {
            return this._zr;
        },

        setOption: function (rawOption, merge) {
            rawOption = zrUtil.clone(rawOption);
            zrUtil.merge(rawOption, this._theme);

            var ecModel = new GlobalModel(rawOption);

            // Add series index
            ecModel.eachSeries(function (series, seriesIndex) {
                series.seriesIndex = seriesIndex;
            });

            this._model = ecModel;

            this._prepareComponents(ecModel);

            this._prepareCharts(ecModel);

            this.updateImmediately();
        },

        getCoordinateSystem: function (type, idx) {
            return this._coordinateSystem.get(type, idx);
        },

        update: function () {

        },

        updateImmediately: function () {
            this._model.restore();

            this._processData(this._model);

            this._coordinateSystem.update(this._model);

            this._doRender(this._model);
        },

        resize: function () {
            this._coordinateSystem.resize(this._model, this._extensionAPI);
        },

        _prepareCharts: function (ecModel) {
            var chartUsedMap = {};
            zrUtil.each(ecModel.get('series'), function (series, idx) {
                var id = series.type + '_' + (series.name || idx);
                chartUsedMap[id] = true;

                var chart = this._chartsMap[id];
                if (! chart) {
                    chart = Chart.create(series);
                    if (chart) {
                        chart.init(this._extensionAPI);
                        this._chartsMap[id] = chart;
                        this._chartsList.push(chart);
                    }
                    else {
                        // Error
                    }
                }

                chart.__id__ = id;
            }, this);

            for (var i = 0; i < this._chartsList.length;) {
                var chart = this._chartsList[i];
                if (! chartUsedMap[chart.__id__]) {
                    chart.dispose();
                    this._chartsList.splice(i, 1);
                    delete this._chartsMap[chart.__id__];
                }
                else {
                    i++;
                }
            };
        },

        _prepareComponents: function (ecModel) {
            Component.eachAvailableComponent(function (componentType) {
                var componentsMap = this._componentsMap;
                var componentsList = this._componentsList;

                var componentOption = ecModel.get(componentType);
                var component = componentsMap[componentType];
                if (componentOption) {
                    if (! component) {
                        // Create and add component
                        component = Component.create(componentType, componentOption);
                        component.init(this._extensionAPI);
                        componentsMap[componentType] = component;
                        componentsList.push(component);
                    }
                }
                else {
                    if (component) {
                        // Remove and dispose component
                        component.dispose();
                        delete componentsMap[componentType];
                        componentsList.splice(zrUtil.indexOf(componentsList, component));
                    }
                }
            }, this);
        },

        _processData: function (ecModel) {
            zrUtil.each(processors, function (processor) {
                processor(ecModel);
            });
        },

        _doRender: function (optionModel, stateModel) {
            var api = this._extensionAPI;
            // Render all components
            zrUtil.each(this._components, function (component) {
                component.render(optionModel, stateModel, api);
            }, this);
            // Render all charts
            optionModel.eachSeries(function (seriesModel, idx) {
                var id = seriesModel.get('type') + '_' + (seriesModel.get('name') || idx);
                var chart = this._chartsMap[id];
                var group = chart.render(seriesModel, optionModel, api);
                this.zr.addElement(group);
            }, this);
            // TODO
            // Remove group of unused chart
        },

        dispose: function () {
            zrUtil.each(this._components, function (component) {
                component.dispose();
            });
            zrUtil.each(this._charts, function (chart) {
                chart.dispose();
            });

            this.zr.dispose();
        }
    };


    /**
     * @module echarts
     */
    var echarts = {

        init: function (dom, theme) {
            return new ECharts(dom, theme);
        },

        registreProcessor: function (Processor) {

        },

        registerCoordinateSystem: function (type, CoordinateSystem) {

        }
    };


    echarts.registreProcessor(require('./processor/AxisDefault'));

    echarts.registreProcessor(require('./processor/SeriesFilter'));

    return echarts;
});