/*-
 * ~~~~~~licensing~~~~~~
 * entaxy-management-plugin
 * ==========
 * Copyright (C) 2020 - 2023 EmDev LLC
 * ==========
 * You may not use this file except in accordance with the License Terms of the Copyright
 * Holder located at: https://entaxy.ru/eula . All copyrights, all intellectual property
 * rights to the Software and any copies are the property of the Copyright Holder. Unless
 * it is explicitly allowed the Copyright Holder, the User is prohibited from using the
 * Software for commercial purposes to provide services to third parties.
 * 
 * The Copyright Holder hereby declares that the Software is provided on an "AS IS".
 * Under no circumstances does the Copyright Holder guarantee or promise that the
 * Software provided by him will be suitable or not suitable for the specific purposes
 * of the User, that the Software will meet all commercial and personal subjective
 * expectations of the User, that the Software will work properly, without technical
 * errors, quickly and uninterruptedly.
 * 
 * Under no circumstances shall the Copyright Holder or its Affiliates is not liable
 * to the User for any direct or indirect losses of the User, his expenses or actual
 * damage, including, downtime; loss of bussines; lost profit; lost earnings; loss
 * or damage to data, property, etc.
 * ~~~~~~/licensing~~~~~~
 */
/**
 * The main entry point for the Simple module
 */
var Entaxy = (function (Entaxy) {

    /**
    * The name of this plugin
    */
    Entaxy.pluginName = 'entaxy-plugin';

    /**
    * This plugin's logger instance
    */
    Entaxy.log = Logger.get('entaxy-plugin');

    /**
    * The top level path of this plugin on the server
    */
    Entaxy.contextPath = "/entaxy-plugin/";

    Entaxy.log.info("loading entaxy plugin")
    Entaxy._module = angular.module(Entaxy.pluginName, [
        'angularResizable',
        'jsonFormatter'
    ])
    .component('entaxy', {
        template:
           `<div class="tree-nav-layout">
                <div class="sidebar-pf sidebar-pf-left" resizable r-directions="['right']">
                  <entaxy-tree-header></entaxy-tree-header>
                  <entaxy-tree></entaxy-tree>
                </div>
                <div class="tree-nav-main">
                  <jmx-header></jmx-header>
                  <entaxy-navigation></entaxy-navigation>
                  <div class="contents" ng-view></div>
                </div>
           </div>
          `
          })
    .run(configurePlugin);

    function configurePlugin(mainNavService, workspace, helpRegistry, preferencesRegistry, localStorage, preLogoutTasks, documentBase, $templateCache, $rootScope, jolokia) {
        var entaxyJmxDomain = localStorage['entaxyJmxDomain'] || "ru.entaxy.esb";
        mainNavService.addItem({
            title: 'Entaxy ION',
            basePath: '/entaxy',
            template: '<entaxy></entaxy>',
            isValid: function () { return workspace.treeContainsDomainAndProperties(entaxyJmxDomain); }
        });

        workspace.addNamedTreePostProcessor('addIconClass', (tree) => {
            if (tree) {
                let domain = tree.get(entaxyJmxDomain);

                if (domain) {
                    angular.forEach(domain.children, (node) => {
                        node.class = 'entaxy-node-icon';

                        angular.forEach(['platform', 'runtime'], (folderName) => {
                            let folder = domain.findDescendant(child => child.title === folderName);
                            if (folder) {
                                folder.class = createClassName(folderName);
                            }
                        });

                        angular.forEach(['adapter', 'factories', 'connections', 'resource', 'services', 'connectors'], (folderName) => {
                            addClassRecursive(
                                domain.findDescendant(child => child.title === folderName),
                                createClassName(folderName)
                            );
                        });

                        addClassToParentAndItsChildrenUsingRuntimeType(domain.findDescendant(child => child.title === 'profiles'));
                    });
                }
            }
        });

        function addClassRecursive(folder, className) {
            if (folder) {
                folder.class = className;
                angular.forEach(folder.children, (child) => {
                    if (child.children && child.children.length > 0) {
                        addClassRecursive(child, className);
                    } else {
                        child.class = className;
                    }
                });
            }
        }

        function addClassToParentAndItsChildrenUsingRuntimeType(folder) {
            if (folder) {
                if (folder.objectName) {
                    let attributes = jolokia.getAttribute(folder.objectName);
                    if (attributes.RuntimeType) {
                        folder.class = runtimeTypeToClassName[attributes.RuntimeType];

                        if (attributes.Direction) {
                            folder.class += ' ' + attributes.Direction;
                        }
                    } else {
                        folder.class = createClassName(folder.title);
                    }
                } else {
                    folder.class = createClassName(folder.title);
                }

                folder.children.forEach((child) => {
                    addClassToParentAndItsChildrenUsingRuntimeType(child);
                });
            }
        }

        const runtimeTypeToClassName = {
            'entaxy.runtime.profile': 'entaxy-profiles-icon',
            'entaxy.runtime.connector': 'entaxy-connectors-icon',
            'entaxy.runtime.default-route': 'entaxy-routes-icon',
            'entaxy.runtime.connection': 'entaxy-connections-icon'
        }

        function createClassName(folderName) {
            return 'entaxy-' + folderName + '-icon';
        }

        function mBeansTreeLocalization(children) {
        	if (children && children.length >0) {
        		for (var i=0; i<children.length; i++) {
        			let c = children[i];
        			if (L10N.hasOwnProperty(c.title)) {
        				c.title = L10N[c.title];
        			}
        			if (c.children && c.children.length > 0) {
        				mBeansTreeLocalization(c.children);
        			}
        		}
        	}
        }

//      global event for entaxy extras
        $rootScope.$emit('entaxyWorkspacePreparing', workspace);

        workspace.addNamedTreePostProcessor('localize', (tree) => {
        	if (tree) {
        		let domain = tree.get(entaxyJmxDomain);
        		if (domain) {
        		    console.log('domain ');
        			console.log(domain.children);
        			mBeansTreeLocalization(domain.children);
        		}
        	}
        });

        workspace.addNamedTreePostProcessor('useDisplayName', (tree) => {
        	if (tree) {
        		let domain = tree.get(entaxyJmxDomain);
        		if (domain) {
        			useDisplayName(domain.children);
        		}
        	}
        });

        function useDisplayName(children) {
            children.forEach(child => {
                if (child.objectName) {
                    let attributes = jolokia.getAttribute(child.objectName);
                    if (attributes.RuntimeType) {
                        if (attributes.RuntimeType === 'entaxy.runtime.connector') {
                            if (attributes.DisplayName) {
                                child.title = attributes.DisplayName;
                            }
                        }
                    }
                }
                useDisplayName(child.children);
            });
        }

        // clean up local storage upon logout
/*        preLogoutTasks.addTask('CleanupArtemisCredentials', function () {
            Artemis.log.debug("Clean up Artemis credentials in local storage");
            localStorage.removeItem('artemisUserName');
            localStorage.removeItem('artemisPassword');
        }); */
    }
    configurePlugin.$inject = ['mainNavService', 'workspace', 'helpRegistry', 'preferencesRegistry', 'localStorage', 'preLogoutTasks', 'documentBase', '$templateCache', '$rootScope', 'jolokia'];

    return Entaxy;

})(Entaxy || {});

// tell the Hawtio plugin loader about our plugin so it can be
// bootstrapped with the rest of AngularJS
hawtioPluginLoader.addModule(Entaxy.pluginName);

const L10N = {
	platform: 'Платформа',
	adapter: 'Адаптеры',
	factories: 'Фабрики',
	runtime:'Состояние',
	connections:'Коннекции',
	profiles:'Профили',
	connectors:'Коннекторы',
	routes:'Маршруты',
	resource: 'Ресурсы',
	services: 'Сервисы'
};
