import { mask_config } from '@core/api/config';
import { Module } from '@core/feature/modules/exports';
import { renderer_renderAsync } from '@core/renderer/exports';
import { listeners_on, listeners_off } from '@core/util/listeners';

UTest({
	$before () {
		// use default module loader
		mask_config('modules', 'default');
		Module.cfg('moduleResolution', 'node');
	},
	$after () {
        Module.cfg('moduleResolution', 'classic');
        listeners_off('error');
	},

	async 'should load default file in node_modules' () {
		let dom = await renderer_renderAsync(`
            import Foo from '/test/tmpl/npm/foo.mask';

            Foo;
        `);
        
        return UTest.domtest(dom, `
            find ('h4') > text ('EmptyPackage');
        `);
	},
	async 'should fail loading' () {
        var errors = [];
        
		listeners_on('error', assert.await((error) => errors.push(error)));

import { mask_config } from '@core/api/config'
import { renderer_render, renderer_renderAsync } from '@core/renderer/exports'
import '@core/feature/methods/exports'
import { Module } from '@core/feature/modules/exports'

UTest({
	$teardown () {
		mask_config('getScript', null);
		Module.clearCache();
	},
	'should get instance from define args' () {
		class Foo {
			load () { }
		};

		mask_config('getScript', async path => {
			return new Foo();
		});


		var template = `
			import * as IFoo from 'Foo.js';

			define FooCompo (foo: IFoo) {
				function onRenderStart () {
					this.emitOut('fooSignal', foo);	
				}
			}

			FooCompo;
		`;

import { mask_config } from '@core/api/config';
import { renderer_renderAsync, renderer_render } from '@core/renderer/exports';
import { Compo } from '@compo/exports';
import { customTag_define } from '@core/custom/exports';
import '@core/feature/modules/exports'

// use default module loader
mask_config('modules', 'default');

UTest({
	async 'should test sync module loading' () {
		var Files = {
			'MyComponents.mask': `
				module path='A.mask' {
					h1 > 'A'
				}
				module path='B.mask' {
					h1 > 'B'
				}
				module path='C.mask' {
					h1 > 'C'
				}
			`,
			'MyLetter.mask': `
				import * as Template from './B';
				Template;
			`
		};

		var _queue = [];
		mask_config('getFile', (path) => {

    'default': function () {
        __cfg.getScript = __cfg.getFile = __cfg.getStyle = null;
    },
    'include': function () {
        __cfg.getScript = getter('js');
        __cfg.getStyle  = getter('css');
        __cfg.getFile   = getter('load');

        var lib = include;
        function getter(name) {
            return function(path){
                return class_Dfr.run(function(resolve, reject){
                    lib.instance('/')[name](path + '::Module').done(function(resp){
                        if ('css' === name) {
                            return resolve();
                        }
                        if ('js' === name) {
                            return resolve(resp.Module);
                        }
                        resolve(resp[name].Module);
                    });
                });
            };
        }
    }
};

if (typeof include !== 'undefined' && is_Function(include && include.js)) {
    mask_config('modules', 'include');
}

		var clean = txt => txt.replace(/\s/g, '');

		eq_(clean(str), clean(tmpl));
	},
	'should preprocess script' () {
		var tmpl = `
			JustAContainer {
				slot change () {
					this.$.text('B');
				}
				button x-tap = change > 'A'
			}			
		`;
		
		mask_config('preprocessor.script', function(body){
			return body.replace('B', 'C');
        });
        
        let dom = renderer_render(tmpl);
        mask_config('preprocessor.script', null);        
        return UTest.domtest(dom, `
            find (button) {
                text A;
                do click;
                text C;
            }
        `);
	}
});

import { mask_config } from '@core/api/config';
import { Module } from '@core/feature/modules/exports';
import { renderer_renderAsync } from '@core/renderer/exports';

UTest({
	$teardown () {
		mask_config('getFile', null);
		mask_config('getScript', null);
	},

	async 'should load script' () {
		var Foo = {
			get name () { return 'FooTest' }
		};

		Module
			.cfg('prefixes.services', '/src/services/{0}.js')
			.cfg('ext.script', 'js')
			;
		mask_config('getScript', assert.await(async path => {
			has_(path, '/src/services/FooService.js');			
			return Foo;
		}));
		let dom = await renderer_renderAsync(`
            import * as Foo from '@services/FooService';
            h3 > '~[Foo.name]'
        `);
			
        return UTest.domtest(dom, `
            find('h3') > text FooTest;
        `);

import { mask_config } from '@core/api/config';
import { renderer_renderAsync } from '@core/renderer/exports';
import { Module } from '@core/feature/modules/exports';

UTest({
	$teardown () {
		mask_config('getFile', null);
		mask_config('getScript', null);
	},

	async 'should load mask' () {
		mask_config('getFile', assert.await(async path => {
			has_(path, 'controls/Foo.mask');
			var template = 'define Foo { h3 > "FooTest" }';
			return template;
		}));
		let dom = await renderer_renderAsync(`
            import Foo from controls is mask;
            Foo;
        `);
			
        return UTest.domtest(dom, `
            find('h3') > text FooTest;
        `);
	},
	async 'should load script' () {
		Module.cfg('ext.script', 'es6');
		mask_config('getScript', assert.await(async path => {
			has_(path, 'services/Foo.es6');

			var service = {

import { mask_config } from '@core/api/config';
import { Module } from '@core/feature/modules/exports';
import { renderer_renderAsync } from '@core/renderer/exports';

UTest({
	$teardown () {
		mask_config('getScript', null);
		mask_config('getFile', null);
		Module.clearCache();
	},
	async 'should get instance from define args' () {
		class Foo {
			checkIt () { return 'checkThis' }
		};

		mask_config('getScript', async path => {
			return new Foo()
		});

		var template = `
			import * as Foo from 'Foo.js';
			section > Foo > span > '~[this.checkIt()]'
		`;
		var dom = await renderer_renderAsync(template);

		return UTest.domtest(dom, `
			find ('span') > text ('checkThis');
		`)
	},
	async 'should get mask component in js' () {
		

				width: 5,
				style: 'dotted'
			},
			styles: {
				'.foo': {
					'border-top-width': '5px',
					'border-top-style' : 'dotted'
				}
			},
			count: 1,
			isInterpolated: true
		});
	},
	async 'check preprocessor' () {
		mask_config('preprocessor.style', function(body){
			return body.replace('red', 'green');
		});
		var template = `
			div {
				style scoped {
					:host {
						background: red;
					}
				}
			}
		`;
		let div = await renderer_renderAsync(template);
			
        var str = $('body').children('style').last().text();
        hasNot_(str, 'red');
        has_   (str, 'green');