package net.tccn.base;

import lombok.Getter;
import net.tccn.base.arango.Doc;
import net.tccn.dbq.Field;
import net.tccn.dbq.fbean.FilterType;
import net.tccn.dbq.jdbc.api.DbAccount;
import net.tccn.dbq.jdbc.api.DbKit;
import net.tccn.meta.*;
import net.tccn.plat.DbPlat;
import net.tccn.plat.SysPlat;
import net.tccn.user.User;
import org.redkale.convert.json.JsonConvert;
import org.redkale.util.Comment;
import org.redkale.util.TypeToken;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import static java.util.Arrays.asList;

/**
 *
 * Created by liangxianyou at 2019/1/7 13:31.
 */
public final class MetaKit {
    //基础数据缓存
    @Getter
    private static List<MetaTable> metaTables;
    @Getter
    private static List<MetaLink> metaLinks;
    @Getter
    private static List<MetaService> metaServices;
    @Getter
    private static List<DbAccount> dbPlats;
    @Getter
    private static List<SysPlat> sysPlats;
    @Getter
    private static List<User> users;

    protected static String dcate;
    private static final JsonConvert convert = JsonConvert.root();
    // -----------------------------------
    protected static void init() {
        reload(MetaTable.class);
        reload(MetaLink.class);
        reload(MetaService.class);
        reload(DbAccount.class);
        reload(SysPlat.class);
        reload(User.class);
    }

    public static <T extends Doc> void reload(Class<T> clazz) {
        reload(clazz, null);
    }
    public static <T extends Doc> void reload(T t) {
        reload(t.getClass(), t.getKey());
    }
    public static <T extends Doc> void reload(Class<T> clazz, String key) {

        try {
            File file = new File(String.format("tmp/%s.json", clazz.getSimpleName()));
            if ("file".equals(dcate)) {
                if (MetaTable.class == clazz) {
                    Type type = new TypeToken<List<MetaTable>>() {}.getType();
                    metaTables = convert.convertFrom(type, new FileInputStream(file));
                }
                else if (MetaLink.class == clazz) {
                    Type type = new TypeToken<List<MetaLink>>() {}.getType();
                    metaLinks = convert.convertFrom(type, new FileInputStream(file));
                }
                else if (MetaService.class == clazz) {
                    Type type = new TypeToken<List<MetaService>>() {}.getType();
                    metaServices = convert.convertFrom(type, new FileInputStream(file));
                }
                else if (DbAccount.class == clazz) {
                    Type type = new TypeToken<List<DbAccount>>() {}.getType();
                    dbPlats = convert.convertFrom(type, new FileInputStream(file));
                }
                else if (DbPlat.class == clazz) {
                    Type type = new TypeToken<List<DbAccount>>() {}.getType();
                    dbPlats = convert.convertFrom(type, new FileInputStream(file));
                }
                else if (SysPlat.class == clazz) {
                    Type type = new TypeToken<List<SysPlat>>() {}.getType();
                    sysPlats = convert.convertFrom(type, new FileInputStream(file));
                }
                else if (User.class == clazz) {
                    Type type = new TypeToken<List<User>>() {}.getType();
                    users = convert.convertFrom(type, new FileInputStream(file));
                }
            } else {
                if (MetaTable.class == clazz)           metaTables = MetaTable.dao.find();
                else if (MetaLink.class == clazz)       metaLinks = MetaLink.dao.find();
                else if (MetaService.class == clazz)    metaServices = MetaService.dao.find();
                else if (DbAccount.class == clazz)      dbPlats = DbAccount.dao.find();
                else if (DbPlat.class == clazz)      dbPlats = DbAccount.dao.find();
                else if (SysPlat.class == clazz)      sysPlats = SysPlat.dao.find();
                else if (User.class == clazz)      users = User.dao.find();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void cacheSave() {
        cacheSave(MetaLink.class);
        cacheSave(MetaService.class);
        cacheSave(DbAccount.class);
        cacheSave(DbPlat.class);
        cacheSave(SysPlat.class);
        cacheSave(User.class);
    }

    private static void cacheSave(Class clazz) {
        List list = null;
        if (MetaTable.class == clazz)  list = metaTables;
        else if (MetaLink.class == clazz)    list = metaLinks;
        else if (MetaService.class == clazz)     list = metaServices;
        else if (DbAccount.class == clazz)   list = dbPlats;
        else if (DbPlat.class == clazz)  list = dbPlats;
        else if (SysPlat.class == clazz)    list = sysPlats;
        else if (User.class == clazz)    list = users;

        if (list == null || list.size() == 0) return;

        File file = new File(String.format("tmp/%s.json", list.get(0).getClass().getSimpleName()));
        file.getParentFile().mkdirs();
        try {
            FileKit.strToFile(MetaKit.convert.convertTo(list), file);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // -----------------------------------
    public void cleanData() {


    }

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

    public static MetaTable getMetaTable(String name, String token) {
        Optional<MetaTable> any = getMetaTables().stream().filter(x -> {
            return x.getName().equals(name) && x.getSysPlatId().equals(getPlatId(token));
        }).findAny();

        return any.get();
    }

    public static MetaService getMetaService(String name, String token) {
        Optional<MetaService> service = metaServices.stream()
                .filter(x -> x.getName().equals(name) && x.getSysPlatId().equals(getPlatId(token)))
                .findAny();
        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 Map cfg(String name, String token) {
        MetaService metaService = getMetaService(name, token);
        Kv<String, MetaTable> metaTables = getMetaTables(metaService, false);

        List<Map<String, String>> shows = metaService.getShows();
        List<FromItem> edits = metaService.getEdits();
        List<Map<String, String>> details = metaService.getDetails();
        List<Filter> filters = metaService.getFilters();
        String comment = metaService.getComment();

        //List<Field> items = new ArrayList<>();
        /*Kv<String, Kv<String, Kv>> _items2 = Kv.of();
        metaTables.forEach((k, v) -> {
            Kv<String, Kv> _items = Kv.of();
            v.getItems().forEach(x -> {
                Kv kv = Kv.of();
                kv.set("col", x.getName());
                kv.set("label", x.getLabel());
                kv.set("InExt", x.getInExt());
                kv.set("inType", x.getInType());
                kv.set("expr", x.showField());
                _items.set(x.getName(), kv);
            });

            _items2.set(k, _items);
        });*/

        //shows
        /*List _shows = new ArrayList();
        shows.forEach(x -> {
            MetaTable metaTable = metaTables.get(x.split("[.]")[0]); // 表别名
            metaTable.getItems().stream()
                    .filter(y -> x.split("[.]")[1].equals(y.getName()))
                    .findFirst().ifPresent(y -> _shows.add(Kv.of("col", x).set("order", true)));
        });*/
        /*List<Kv> _shows = shows.stream().map(x -> {
            Kv kv = Kv.of();
            kv.putAll(x);

            if ("FUNC".equalsIgnoreCase(x.get("inType")) || "QTASK".equalsIgnoreCase(x.get("inType")) || "DICT".equalsIgnoreCase(x.get("inType"))) {
                kv.set("fmt", x.get("inType") + "|" + x.get("inExt"));
            } else if ("HIDDEN".equalsIgnoreCase(x.get("inType"))) {
                kv.set("fmt", "HIDDEN");
            } else {
                kv.set("fmt", "");
            }
            kv.remove("inType");
            kv.remove("inExt");
            return kv;
        }).collect(Collectors.toList());*/


        //filters
        List<Map> _filters = new ArrayList<>();
        filters.forEach(x -> {
            String col = String.valueOf(x.getName());
            MetaTable metaTable = metaTables.get(col.split("[.]")[0]); // 表别名

            Kv filter = Kv.of();
            metaTable.getItems().stream()
                    .filter(y -> col.split("[.]")[1].equals(y.getName()))
                    .findFirst()
                    .ifPresent(y -> {
                        filter.set("name", x.getName());
                        filter.set("label", x.getLabel() != null ? x.getLabel() : y.getLabel());
                        List<Kv> types = new ArrayList<>();
                        List<String> list = (List) x.getFilterType();
                        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);
                        if (!types.isEmpty()) {//设置默认查询项
                            filter.set("type", types.get(0).get("name"));
                        }
                        filter.set("checked", x.isChecked());
                    });
            _filters.add(filter);
        });

        //edits
        //List _edits = new ArrayList();//edits;
        /*edits.forEach(x -> {
            Kv kv = Kv.of();
            kv.set("col", x);

            String col = x.get("col") + "";
            //readonly,hidden
            if ("id".equalsIgnoreCase(col)) {
                kv.set("upAttr", "hidden");
                kv.set("addAttr", "none");
            }
            if ("reportWay".equalsIgnoreCase(col)) {
                kv.set("upAttr", "readonly");
                kv.set("addAttr", "none");
            }
            if ("insertTime".equalsIgnoreCase(col)) {
                kv.set("upAttr", "readonly");
                kv.set("addAttr", "none");
            }

            if ("ip".equalsIgnoreCase(col)) {
                kv.set("ck", "ip");
            }

            _edits.add(kv);
        });*/

        //details
        /*List _details = new ArrayList();//details;
        details.forEach(x -> {
            Kv kv = Kv.of();
            kv.set("col", x);

            _details.add(kv);
        });*/

        //pk：业务主表的主键
        StringBuffer _pks = new StringBuffer();
        MetaTable mainTable = metaTables.get(metaService.getTable());
        mainTable.getItems().stream().filter(x -> x.getPk() != null && x.getPk()).forEach(x -> {
            _pks.append(String.format("%s.%s,", metaService.getTable(), x.getName()));
        });
        if (_pks.length() > 0) {
            _pks.deleteCharAt(_pks.length() -1);
        }
        if (_pks.length() == 0) { // 默认主键
            List<Field> items = metaTables.get(metaService.getTable()).getItems();
            //存在id字段，取id
            items.stream().filter(x -> x.getName().equalsIgnoreCase("id")).findAny().ifPresent(x -> {
                _pks.append(String.format("%s.%s", metaService.getTable(), x.getName()));
            });
        }

        return Kv.of()
                .set("pk", _pks.toString())
                .set("title", comment)
                //.set("items", _items2)
                .set("shows", shows)
                .set("filters", _filters)
                .set("edits", edits)
                .set("details", details);
    }

    @Comment("获取导出excel表头配置k-v")
    public static Kv cfgExport(String name, String token) {
        MetaService metaService = getMetaService(name, token);
        List<Map<String,String>> exports = metaService.getExports();

        Kv kv = Kv.of(); // {col:label}
        exports.forEach(x -> {
            kv.put(x.get("col"), x.get("label"));
        });
        return kv;
    }

    //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;
    };

    //showUpdate
    /*public static BiFunction<String, List<String>, MetaService> showUpdate = (name, shows) -> {

        MetaService metaService = getMetaService(name, "");

        MetaService _metaService = MetaService.dao.findByKey(metaService.getKey());
        _metaService.setShows(shows);
        _metaService.update();

        metaService.setShows(shows);//更新缓存
        return metaService;
    };*/


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

    public static List<MetaLink> getMetaLinks(String t, List<String> shows, List<String> filters) {


        Predicate<String> contain = s -> {
            for (String item : shows) {
                if (s.equals(item.split("[.]")[0])) {
                    return true;
                }
            }
            for (String item : filters) {
                if (s.equals(item.split("[.]")[0])) {
                    return true;
                }
            }
            return false;
        };

        //得到直接关联
        //1、直接关联 表： t.equals(x.getTables()[0]) || t.equals(x.getTables()[1]
        //2、关联且有过滤：
        //3、关联有展示：
        List<MetaLink> links = metaLinks.stream()
                .filter(x -> {
                    return (t.equals(x.getTables()[0]) || t.equals(x.getTables()[1]))
                            && (contain.test(x.getTables()[0]) || contain.test(x.getTables()[1]));
                })
                .collect(Collectors.toList());
        return links;
    }

    public static Kv buildeDetail(MetaService metaService) {
        //tables
        Kv<String, MetaTable> tables = getMetaTables(metaService, true);
        return Kv.of("tables", tables)
                .set("links", Kv.of());
    }

    public static Kv<String, MetaTable> getMetaTables(MetaService metaService, Boolean all) {
        Kv<String, MetaTable> tables = Kv.of();

        String table = metaService.getTable();//
        tables.set(table, getMetaTableByAlias(table));

        //收集所有的col
        Set<String> allAlias;

        if (!all) {
            allAlias = Liangs.concat(
                    metaService.getFilters().stream().map(f -> {
                        String col = (String) f.getName();
                        String alias = col.split("[.]")[0];
                        return alias;
                    }),
                    metaService.getExports().stream().map(x -> x.get("col").split("[.]")[0]),
                    metaService.getShows().stream().map(x -> x.get("col").split("[.]")[0])/*,  todo: xxx
                    metaService.getEdits().stream().map(x -> x.split("[.]")[0])*/
            ).collect(Collectors.toSet());

        } else {
            allAlias = new HashSet<>();
            metaLinks.stream().forEach(x -> {
                if (table.equals(x.getTables()[0])) {
                    allAlias.add(x.getTables()[1]);
                } else if (table.equals(x.getTables()[1])) {
                    allAlias.add(x.getTables()[0]);
                }
            });
        }

        allAlias.forEach(x -> tables.set(x, getMetaTableByAlias(x)));
        return tables;
    }

    /*public static DbKit getDbKit(String dbPlatId) {
        Optional<DbAccount> dbAccount = dbPlats.stream().filter(x -> x.getKey().equals(dbPlatId)).findAny();

        return new DbKit(dbAccount.get());
    }*/
    public static DbKit getDbKit(String dbPlatId, String catalog) {
        Optional<DbAccount> dbAccount = dbPlats.stream().filter(x -> x.getKey().equals(dbPlatId)).findAny();
        return new DbKit(dbAccount.get(), catalog);
    }

    public static DbAccount getDbPlat(String dbPlatId) {
        Optional<DbAccount> dbAccount = dbPlats.stream().filter(x -> x.getKey().equals(dbPlatId)).findFirst();

        return dbAccount.get();
    }

    @Comment("通过平台token  得到平台id")
    public static String getPlatId(String platToken) { //
        Optional<SysPlat> plat = sysPlats.stream().filter(x -> x.getToken().equals(platToken)).findAny();
        return plat.get().getKey();
    }

    public static String lastAlias;
    public static String nextAlias() {
        if (lastAlias == null) {
            String aql = TplKit.use(true).getTpl("metaTable.lastAlias");
            lastAlias = MetaTable.dao.findFirst(aql, String.class);
        }
        return lastAlias = next(lastAlias, "");
    }

    //使用['a',...,'z'] 创建Table 别名
    private static String next(String x, String end) {
        if (x == null || "".equals(x)) {
            return "a" + end;
        }
        char c = x.charAt(x.length() - 1);
        String sub = x.substring(0, x.length() - 1);
        if (c < 'z') {
            return sub + (++c) + end;
        } else if (c == 'z') {
            return next(sub, "a" + end);
        }
        return null;
    }

    public static List<String> tableExist(String[] tableArr, String token) {
        List<String> _tableArr = asList(tableArr);
        List<String> hv = metaTables.stream()
                .filter(x -> _tableArr.contains(x.getName()) && x.getSysPlatId().equals(getPlatId(token)))
                .map(MetaTable::getName)
                .collect(Collectors.toList());
        return hv;
    }

    // ---------------------- repository -------------------
    public static <T extends Doc> void save(T ... ts) {
        if (ts == null || ts.length == 0) return;

        for (T t : ts) {
            if ("file".equals(dcate)) {
                if (t.getKey() == null) { //数据新增异常提示
                    throw new UnsupportedOperationException("数据文件形式启动服务，不支持配置新增！");
                }

                cacheSave(t.getClass());
                return;
            }

            if (t.getKey() == null) {
                t.save();
            } else {

                if (t instanceof MetaLink) {
                    //避免删除属性无效
                    if (((MetaLink) t).getLink() != null && ((MetaLink) t).getLink().size() > 0) {
                        t.find(String.format("UPDATE '%s' WITH { link:null  } IN MetaLink", t.getKey()), Map.class);
                    }
                }

                t.update();
            }
        }

        reload(ts[0].getClass());
    }

    public static <T extends Doc> T findFirst(T t) {
        Objects.nonNull(t);

        List<T> list = asList();
        Map doc = t.toDoc();
        if (t instanceof User) {
            list = (List<T>) users;
        }

        Optional any = list.stream().filter(x -> {
            Map map = x.toDoc();
            Set<String> keySet = doc.keySet();
            for (String k : keySet) {
                if (doc.get(k) != null && (doc.get(k) instanceof String && doc.get(k).equals(map.get(k)))) {
                    return true;
                }
            }
            return false;
        }).findAny();

        return (T) any.orElse(null);
    }
}