package com.fr.decision.fun;

import com.fr.stable.fun.mark.ComposeWebCoalition;

/**
 * @author Roger
 * @version 10.0
 * @date 2021/1/15
 * 给多个web主组件添加子组件
 */
public interface ComposeWebResourceProvider extends ComposeWebCoalition {

    String MARK_STRING = "ComposeWebResourceProvider";

    int CURRENT_LEVEL = 1;
}

package com.fr.stable.fun.mark;


/**
 * @author Roger
 * @version 10.0
 * @date 2021/1/15
 * 多主组件注册
 */
public interface ComposeWebCoalition extends Mutable {

    WebCoalition[] webCoalitions();
}

package com.fr.stable.fun.mark;

import com.fr.web.struct.Atom;

/**
 * 带有web资源的扩展接口
 */
public interface WebCoalition extends Mutable {

    /**
     * 需要附加到的主组件
     * @return 主组件
     */
    Atom attach();

    /**
     * 客户端所需的组件
     *
     * @return 组件
     */
    @Deprecated
    Atom client();

    /**
     * 客户端所需的组件集合
     *
     * @return 组件集合
     */
    Atom[] clients();

}

<extra-decision>
        <ComposeWebResourceProvider class="your class name"/>
</extra-decision>

package com.fr.web.struct;

import com.fr.module.extension.PrepareAdaptor;
import com.fr.plugin.context.PluginContext;
import com.fr.plugin.injectable.PluginInjectionFilter;
import com.fr.stable.ArrayUtils;
import com.fr.stable.fun.mark.ComposeWebCoalition;
import com.fr.stable.fun.mark.WebCoalition;
import com.fr.web.struct.extra.ModificatorInjectUtil;

/**
 * Created by juhaoyu on 2018/9/4.
 */
public class AtomActivator extends PrepareAdaptor {
    
    @Override
    public void prepare() {
    
        addMutable(PluginInjectionFilter.KEY, new PluginInjectionFilter<WebCoalition>(WebCoalition.class) {
            
            @Override
            public void on(WebCoalition webCoalition, PluginContext context) {
                register(webCoalition, context);
            }
        
            @Override
            public void off(WebCoalition webCoalition, PluginContext context) {
                remove(webCoalition, context);
            }
        });

        addMutable(PluginInjectionFilter.KEY, new PluginInjectionFilter<ComposeWebCoalition>(ComposeWebCoalition.class) {

            @Override
            public void on(ComposeWebCoalition composeWebCoalition, PluginContext context) {
                for (WebCoalition webCoalition : composeWebCoalition.webCoalitions()) {
                    register(webCoalition, context);
                }
            }

            @Override
            public void off(ComposeWebCoalition composeWebCoalition, PluginContext context) {
                for (WebCoalition webCoalition : composeWebCoalition.webCoalitions()) {
                    remove(webCoalition, context);
                }
            }

        });
    }

    private void register(WebCoalition webCoalition, PluginContext context) {
        if (webCoalition.client() != null) {
            Atom wrappedAtom = ModificatorInjectUtil.wrapAtom(webCoalition.client(), context.getID());
            Registry.register(webCoalition.attach().getClass(), wrappedAtom);
        }
        if (ArrayUtils.isNotEmpty(webCoalition.clients())) {
            for (Atom client : webCoalition.clients()) {
                Atom wrappedAtom = ModificatorInjectUtil.wrapAtom(client, context.getID());
                Registry.register(webCoalition.attach().getClass(), wrappedAtom);
            }
        }
    }

    private void remove(WebCoalition webCoalition, PluginContext context) {
        if (webCoalition.client() != null) {
            Atom wrappedAtom = ModificatorInjectUtil.wrapAtom(webCoalition.client(), context.getID());
            Registry.remove(webCoalition.attach().getClass(), wrappedAtom);
        }
        if (ArrayUtils.isNotEmpty(webCoalition.clients())) {
            for (Atom client : webCoalition.clients()) {
                Atom wrappedAtom = ModificatorInjectUtil.wrapAtom(client, context.getID());
                Registry.remove(webCoalition.attach().getClass(), wrappedAtom);
            }
        }
    }
}

package com.fr.web.struct;

import com.fr.common.annotations.Open;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 扩展子组件的管理器
 */
@Open
public class Registry {

    private static Map<Class<? extends Atom>, LinkedHashSet<Atom>>
            children = new ConcurrentHashMap<Class<? extends Atom>, LinkedHashSet<Atom>>();

    /**
     * 注册某个组件所需要的子组件
     * @param clazz 父组件
     * @param atom 子组件
     */
    public static void register(Class<? extends Atom> clazz, Atom... atom) {
        LinkedHashSet<Atom> set = children.get(clazz);
        if (set == null) {
            set = new LinkedHashSet<Atom>();
            children.put(clazz, set);
        }
        Collections.addAll(set, atom);
    }

    public static void remove(Class<? extends Atom> clazz, Atom... atom) {
        LinkedHashSet<Atom> set = children.get(clazz);
        if (set == null) {
            return;
        }
        set.removeAll(Arrays.asList(atom));
    }


    /**
     * 获取一个组件的所有额外的子组件
     * @param clazz 父组件
     * @return 所有的子组件组成的数组
     */
    public static Atom[] getChildren(Class<? extends Atom> clazz) {
        LinkedHashSet<Atom> set = children.get(clazz);
        if (set == null) {
            return new Atom[0];
        }
        set.remove(null);
        List<Atom> list = new ArrayList<Atom>();
        for (Atom atom : set) {
            Filter filter = atom.filter();
            if (filter == null || filter.accept()) {
                list.add(atom);
            }
        }
        return list.toArray(new Atom[0]);
    }
}