/*
 * Copyright (c) 2011-2013, Yahoo! Inc.  All rights reserved.
 * Copyrights licensed under the New BSD License.
 * See the accompanying LICENSE file for terms.
 */

/*jslint anon:true, nomen:true*/
/*global YUI*/

YUI.add('mojito-view-renderer', function (Y) {

    'use strict';

    var cache = {};

    /*
     * Mojito's view renderer abstraction. Will plugin in the specified view
     * plugin to do the rendering, depending on the 'type' specified.
     * @class ViewRenderer
     * @namespace Y.mojito
     * @constructor
     * @param {String} type view engine addon type to use
     * @param {Object} options View engines configuration.
     */
    function Renderer(type, options) {
        this._type = type || 'hb';
        this._options = options;
        this._renderer = cache[type];
    }


    Renderer.prototype = {

        /**
         * Attaches view engine yui module to render a view.
         * This is usually needed when running in the
         * client side and loading mojits on demand.
         * @method _createEngine
         * @protected
         * @async
         * @param {function} callback
         */
        _createEngine: function (callback) {
            var my = this,
                viewEngines = Y.mojito.addons.viewEngines,
                fn = function () {
                    callback(null, new (viewEngines[my._type])(my._options));
                };

            // some perf optimization to avoid calling Y.use when
            // the engine is already attached. this also help users
            // that are trying to create their own engines without
            // the "mojito-" prefix.
            if (viewEngines[my._type]) {
                fn();
            } else {
                // attaching the view engine yui module
                Y.use('mojito-' + this._type, function () {
                    if (!viewEngines[my._type]) {
                        callback(new Error('Invalid view engine: ' + my._type));
                        return;
                    }
                    fn();
                });
            }
        },

        /*
         * Renders a view
         * @method render
         * @param {Object} data data to push into the view.
         * @param {string} mojitType name of the mojit type.
         * @param {Object} tmpl some type of template identifier for the view
         *     engine.
         * @param {Object} adapter The output adapter.
         * @param {Object} meta Optional metadata to use.
         * @param {boolean} more Whether there will be more data to render
         *     later. (streaming)
         */
        render: function (data, mojitType, tmpl, adapter, meta, more) {
            var my = this;
            // HookSystem::StartBlock
            Y.mojito.hooks.hook('Render', adapter.hook, data, mojitType, tmpl, adapter, meta, more);
            // HookSystem::EndBlock
            /*
                TODO: this method should also do:
                    a) load template when needed
                    b) load compiled template when possible
                    c) any io logic related to the view
            */
            if (!this._renderer) {
                this._createEngine(function (err, engine) {
                    if (err) {
                        adapter.error(err);
                        return;
                    }
                    my._renderer = engine;
                    cache[my._type] = engine; // caching renderer instance
                    my._renderer.render(data, mojitType, tmpl, adapter, meta, more);
                });
            } else {
                this._renderer.render(data, mojitType, tmpl, adapter, meta, more);
            }
        }
    };

    Y.namespace('mojito').ViewRenderer = Renderer;

}, '0.1.0', {requires: [
    'mojito',
    'mojito-hooks'
]});