package net.tccn.meta;

import net.tccn.base.Kv;
import net.tccn.dbq.DbPlat;
import net.tccn.dbq.Field;
import net.tccn.dbq.fbean.FilterType;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 *
 * Created by liangxianyou at 2019/1/7 13:31.
 */
public class MetaKit {
    //基础数据缓存
    private static List<MetaTable> metaTables;
    private static List<MetaLink> metaLinks;
    private static List<MetaService> metaServices;

    private static List<DbPlat> dbPlats;

    static {
        metaTables = MetaTable.dao.find();
        metaLinks = MetaLink.dao.find();
        metaServices = MetaService.dao.find();

        dbPlats = DbPlat.dao.find();
    }

    //----- get/set ----
    public static List<MetaTable> getMetaTables() {
        return metaTables;
    }

    public static void setMetaTables(List<MetaTable> metaTables) {
        MetaKit.metaTables = metaTables;
    }

    public static List<MetaLink> getMetaLinks() {
        return metaLinks;
    }

    public static void setMetaLinks(List<MetaLink> metaLinks) {
        MetaKit.metaLinks = metaLinks;
    }

    public static List<MetaService> getMetaServices() {
        return metaServices;
    }

    public static List<DbPlat> getDbPlats() {
        return dbPlats;
    }

    public static void setDbPlats(List<DbPlat> dbPlats) {
        MetaKit.dbPlats = dbPlats;
    }

    //-----------------------------------
    public static void setMetaServices(List<MetaService> metaServices) {
        MetaKit.metaServices = metaServices;
    }

    /**
     * 通过 别名 查询 MetaTable
     * @param alias
     * @return
     */
    private static MetaTable metaTableByAlias(String alias) {
        Optional<MetaTable> table = metaTables.stream().filter(x -> x.getAlias().equals(alias)).findAny();
        return table.orElse(null);
    }

    /**
     * 通过 MetaLink[] 得到 MetaTable{}
     * @param links
     * @return {alias:table}
     */
    private static Map<String, MetaTable> metaTables(List<MetaLink> links) {
        Map map = new HashMap();
        List<String> tables = links.stream().map(MetaLink::getTables).flatMap(Arrays::stream).distinct().collect(Collectors.toList());//tables
        metaTables.stream().filter(x -> tables.contains(x.getAlias())).forEach(x -> {
            map.put(x.getAlias(), x);
        });
        return map;
    }

    /**
     * 通过 link._key 得到 MetaLink[]
     * @param links
     * @return
     */
    private static List<MetaLink> metaLinks(List<String> links) {
        if (links == null) {
            return new ArrayList<>();
        }
        return metaLinks.stream().filter(x -> links.contains(x.getKey())).collect(Collectors.toList());
    }

    /**
     * 构建完整的  MetaService
     * @param name
     * @return
     */
    public static MetaService metaService(String name) {
        Optional<MetaService> service = metaServices.stream().filter(x -> x.getName().equals(name)).findAny();
        //处理业务逻辑
        service.ifPresent(x -> {
            x.setMetaTable(metaTableByAlias(x.getTable()));
            x.setMetaLinks(metaLinks(x.getLinks()));
            x.setTables(metaTables(x.getMetaLinks()));
        });
        return service.orElse(null);
    }

    //字段特征排序
    public static BiFunction<MetaTable, String[], MetaTable> sortItem = (t, arr) -> {
        List<Field> items = t.getItems();

        //x 是跨越值
        a:for (int i = 0, x = 0; i < arr.length; i++) {
            int inx = i - x;

            if (!items.get(inx).equals(arr[i])) {
                Field tmp = items.get(inx);
                for (int j = inx + 1; j < items.size(); j++) {
                    if (items.get(j).equals(arr[i])) {
                        items.set(inx, items.get(j));
                        items.set(j, tmp);
                        continue a;
                    }
                }

                //运行到这里，说明在  list 中找不到排序标识对应的数据， 让排序角标差值+1
                x ++;
            }
        }
        t.setItems(items);
        return t;
    };

    public static Function<String, Field> getField = (n) -> {
        String[] arr = n.split("[.]");
        MetaTable metaTable = metaTableByAlias(arr[0]);
        return metaTable.getItems().stream().filter(x -> x.getName().equals(arr[1])).findAny().orElse(null);
    };

    //listcfg
    public static Function<MetaService, Kv> builderCfg = (m) -> {
        List<String> shows = m.getShows();
        List<Map> filters = m.getFilters();

        List<Map> _filters = new ArrayList<>();
        List<Map> _cols = new ArrayList<>();

        //todo: 优化，批量操作
        //build shows
        shows.forEach(x -> {
            Field field = getField.apply(x);
            if (field != null) {
                Kv col = Kv.of();
                col.set("col", x.split("[.]]")[0] + field.showField());//a.createtime=dt
                col.set("label", field.getLabel());
                col.set("order", 1);//dev 是否支持排序
                _cols.add(col);
            }
        });

        //build filters
        filters.forEach(x -> {
            Kv filter = Kv.of();
            Field filed = getField.apply(x.get("name") + "");

            if (filed != null) {
                filter.set("name", x.get("name"));
                filter.set("label", filed.getLabel());
            }

            filter.set("inType", filed.getInType());
            filter.set("inExt", filed.getInExt());

            List<Kv> types = new ArrayList<>();
            List<String> list = (List) x.get("filterType");
            list.forEach(t -> {
                FilterType type = FilterType.getFilterType(t);
                if (type != null) {
                    types.add(Kv.of("name", t).set("remark", type.getRemark()));
                }
            });

            filter.set("filterType", types);
            Object checked = x.getOrDefault("checked", false);
            filter.set("checked", checked instanceof Boolean ? checked : false);
            _filters.add(filter);
        });

        /*shows.forEach(x -> {
            _shows.add(Kv.of("name", x).set("label", getFieldLabel(x)));
        });*/

        Kv cfg = Kv.of();
        cfg.set("title", m.getName())//业务名称
                //.set("url", getUrl())
                .set("cols", _cols)//展示的数据列
                //.set("conditionLabel", "")
                .set("filters", _filters);//查询过滤条件

        return cfg;
    };

    //itemUpdate
    public static BiFunction<MetaTable, List<Field>, MetaTable> itemUpdate = (t, fields) -> {
        List<Field> items = t.getItems();
        for (int i = 0; i < fields.size(); i++) {
            for (int j = 0; j < items.size(); j++) {
                if (items.get(j).equals(fields.get(i).getName())) {
                    items.set(j, fields.get(i));
                }
            }
        }
        return t;
    };


    public static MetaTable getMetaTableByKey(String key) {
        return metaTables.stream().filter(x -> x.getKey().equals(key)).findAny().orElse(null);
    };
}