package com.product.admin.service;

import com.product.admin.config.CmnConst;
import com.product.admin.service.idel.IPublicService;
import com.product.common.lang.StringUtils;
import com.product.core.cache.DataPoolCacheImpl;
import com.product.core.dao.BaseDao;
import com.product.core.entity.DataTableEntity;
import com.product.core.entity.FieldSetEntity;
import com.product.core.exception.BaseException;
import com.product.core.permission.PermissionService;
import com.product.core.service.support.AbstractBaseService;
import com.product.core.service.support.QueryFilterService;
import com.product.core.spring.context.SpringMVCContextHolder;
import com.product.core.transfer.Transactional;
import com.product.module.sys.entity.SystemUser;
import com.product.util.BaseUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @Author cheng
 * @Description
 * @Date 2021/6/2 14:41
 * @Version 1.0
 */
@Service("publicService")
public class PublicService extends AbstractBaseService implements IPublicService {

    @Autowired
    QueryFilterService queryFilterService;

    @Autowired
    PermissionService permissionService;

    @Autowired
    CodeService codeService;

    @Autowired
    BaseDao baseDao;

    public FieldSetEntity getTableByUuid(String uuid) throws BaseException {
        if (StringUtils.isEmpty(uuid)) {
            return null;
        }
        DataPoolCacheImpl dataPoolCache = DataPoolCacheImpl.getInstance();
        if (dataPoolCache != null) {
            DataTableEntity cacheData = dataPoolCache.getCacheData("所有表信息(uuid)", new String[]{uuid});
            if (!BaseUtil.dataTableIsEmpty(cacheData)) {
                return cacheData.getFieldSetEntity(0);
            }
        }
        return null;
    }

    public FieldSetEntity getTableByTableName(String tableName) throws BaseException {
        if (StringUtils.isEmpty(tableName)) {
            return null;
        }
        DataPoolCacheImpl dataPoolCache = DataPoolCacheImpl.getInstance();
        if (dataPoolCache != null) {
            DataTableEntity cacheData = dataPoolCache.getCacheData("所有表信息", new String[]{tableName});
            if (!BaseUtil.dataTableIsEmpty(cacheData)) {
                return cacheData.getFieldSetEntity(0);
            }
        }
        return null;
    }

    /**
     * 获取临时编码
     *
     * @param table      表名
     * @param field      字段名
     * @param parentCode 上级编码，如果没有上级编码，则为""，不能为null
     * @return
     * @throws BaseException
     */
    public void createdCode(FieldSetEntity fse, String table, String field, String parentCode) throws BaseException {
        codeService.createCode(fse, table, field, parentCode);
    }

    public String getTableByFunction(String function_uuid) {
        FieldSetEntity fseFunctionInfo = baseDao.getFieldSetEntity(CmnConst.PRODUCT_SYS_FUNCTIONS, function_uuid, false);
        if (fseFunctionInfo != null) {
            return fseFunctionInfo.getString(CmnConst.TABLE_UUID);
        }
        return null;
    }

    /**
     * @param table_name     表名
     * @param relevanceTable 是否关联表（外键关联必须在field表中配置field_relation_table）
     * @return
     * @throws BaseException
     */
    public String getFields(String table_name, boolean relevanceTable) throws BaseException {
        DataPoolCacheImpl instance = DataPoolCacheImpl.getInstance();
        DataTableEntity table = instance.getCacheData("所有表信息", new String[]{table_name});
        Map<String, String> tableDdesc = new LinkedHashMap<>();
        DataTableEntity data = null;
        Map<String, Object> m = new HashMap<>();
        if (!BaseUtil.dataTableIsEmpty(table) && table.getFieldSetEntity(0) != null) {
            FieldSetEntity fs = table.getFieldSetEntity(0);
            tableDdesc.put(table_name, fs.getString(CmnConst.TABLE_DESCRIPTION));
            data = instance.getCacheData("所有字段信息并按表分组", new String[]{fs.getUUID()});
            m.put(table_name, BaseUtil.dataTableEntityToJson(data));
        }

        if (relevanceTable) {
            //找出关联表字段
            Object[][] subTableName =baseDao.getSubTableName(table_name);
            if (subTableName != null && subTableName[0] != null) {
                for (int i = 0; i < subTableName[0].length; i++) {
                    m.put((String) subTableName[1][i], BaseUtil.dataTableEntityToJson(instance.getCacheData("所有字段信息并按表分组", new String[]{(String) subTableName[0][i]})));
                    DataTableEntity d = instance.getCacheData("所有表信息", new String[]{(String) subTableName[1][i]});
                    if (d != null && d.getRows() > 0) {
                        tableDdesc.put(d.getString(0, CmnConst.TABLE_NAME), d.getString(0, CmnConst.TABLE_DESCRIPTION));
                    }
                }
            }
        }
        m.put("~table_desc~", tableDdesc);
        return BaseUtil.success(data, m);
    }

    /**
     * 通用列表查询
     * 可传入 filter 参数可用 key: ~select_params~ 多个用逗号分割
     * 可传入 orderby
     * fse 中必须要表名 分页参数
     * 默认加载参照
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    public DataTableEntity listTable(FieldSetEntity fse) throws BaseException {
        //高级搜索过滤
        String queryFilter = queryFilterService.getQueryFilter(fse);
        if (!StringUtils.isEmpty(fse.getString("filter"))) {
            String filter = fse.getString("filter");
            if (!StringUtils.isEmpty(queryFilter)) {
                queryFilter += " and ";
            }
            queryFilter += " (" + filter + " ) ";
        }
        return getDataTableEntity(fse, true, queryFilter);
    }

    /**
     * 通用列表查询
     * 可传入 filter
     * 动态参数可用 key: ~select_params~ 多个用逗号分割
     * 可传入 orderby
     * fse 中必须要表名 如果没有分页参数 则查询第一页 最大条数 Integer.MAX_VALUE
     *
     * @param fse
     * @param isLoadPromptData  是否加载参照
     * @param permissionType    数据权限类型 1 公司 2 人员 3公司&&人员   可为空（不过滤）
     * @param permissionCompany 公司过滤字段 可为空 默认 org_level_uuid 只有填入 permissionType 生效
     * @param permissionStaff   人员过滤字段 可为空 为空时则不过滤 只有填入 permissionType 生效
     * @return
     * @throws BaseException
     */
    public DataTableEntity listTable(FieldSetEntity fse, boolean isLoadPromptData, Integer permissionType, String permissionCompany, String permissionStaff) throws BaseException {
        return getDataTableEntity(fse, isLoadPromptData, getListFilter(fse, permissionType, permissionCompany, permissionStaff));
    }

    /**
     * 列表过滤
     *
     * @param fse
     * @param permissionType  数据权限类型 1 公司 2 人员 3公司&&人员
     * @param permissionField 数据权限过滤字段  permissionType
     * @return
     * @throws BaseException
     */
    public String getListFilter(FieldSetEntity fse, Integer permissionType, String... permissionField) throws BaseException {
        //高级搜索过滤
        String queryFilter = queryFilterService.getQueryFilter(fse);
        if (!StringUtils.isEmpty(fse.getString("filter"))) {
            String filter = fse.getString("filter");
            if (!StringUtils.isEmpty(queryFilter)) {
                queryFilter += " and ";
            }
            queryFilter += " (" + filter + " ) ";
        }
        if (permissionField.length <= 0 || permissionField[0] == null) {
            if (permissionField.length <= 0) permissionField = new String[2];
            permissionField[0] = CmnConst.ORG_LEVEL_UUID;
        }
        String dataFilter = "";
        if (permissionType != null) {
            if (1 == permissionType) {
                //公司过滤
                dataFilter = permissionService.getDataFilter(permissionField.length == 0 ? null : permissionField[0]);
                //lx
            } else if (2 == permissionType && permissionField.length > 1 && permissionField[1] != null) {
                //人员过滤
                dataFilter = permissionService.getDataFilter(fse.getTableName(), permissionField[1]);
            } else if (3 == permissionType && permissionField.length > 1) {
                //公司人员过滤
                dataFilter = permissionService.getDataFilter(fse.getTableName(), permissionField[1], permissionField[0]);
            } else {
                return queryFilter;
            }
        }
        if (StringUtils.isEmpty(queryFilter)) {
            queryFilter = dataFilter;
        } else {
            queryFilter += "and ( " + dataFilter + ") ";
        }
        return queryFilter;
    }

    private DataTableEntity getDataTableEntity(FieldSetEntity fse, boolean isLoadPromptData, String queryFilter) {
        Object[] param = !StringUtils.isEmpty(fse.getString("~select_params~")) ? fse.getString("~select_params~").split(",") : new Object[]{};
        Object[] fields = !StringUtils.isEmpty(fse.getString("~select_fields~")) ? fse.getString("~select_fields~").split(",") : null;
        Integer pageSize = fse.getInteger(CmnConst.PAGESIZE);
        if (pageSize == null) {
            pageSize = Integer.MAX_VALUE;
        }
        Integer cpage = fse.getInteger(CmnConst.CPAGE);
        if (cpage == null) {
            cpage = 1;
        }
        DataTableEntity dt = baseDao.listTable(fse.getTableName(), queryFilter, param, fields, fse.getString("orderby"), pageSize, cpage);
        if (!DataTableEntity.isEmpty(dt) && isLoadPromptData) {
            baseDao.loadPromptData(dt);
        }
        return dt;
    }

    /**
     * 通用列表查询
     * 可传入 filter 参数可用 key: ~select_params~ 多个用逗号分割
     * 可传入 orderby
     * fse 中必须要表名 分页参数
     *
     * @param fse
     * @param isLoadPromptData 是否加载参照
     * @return
     * @throws BaseException
     */
    public DataTableEntity listTable(FieldSetEntity fse, boolean isLoadPromptData) throws BaseException {
        //高级搜索过滤
        String queryFilter = queryFilterService.getQueryFilter(fse);
        if (!StringUtils.isEmpty(fse.getString("filter"))) {
            String filter = fse.getString("filter");
            if (!StringUtils.isEmpty(queryFilter)) {
                queryFilter += " and ";
            }
            queryFilter += " (" + filter + " ) ";
        }
        Object[] param = !StringUtils.isEmpty(fse.getString("~select_params~")) ? fse.getString("~select_params~").split(",") : new Object[]{};
        Integer pageSize = fse.getInteger(CmnConst.PAGESIZE);
        if (pageSize == null) {
            pageSize = Integer.MAX_VALUE;
        }
        Integer cpage = fse.getInteger(CmnConst.CPAGE);
        if (cpage == null) {
            cpage = 1;
        }
        DataTableEntity dt = baseDao.listTable(fse.getTableName(), queryFilter, param, null, fse.getString("orderby"), pageSize, cpage);
        if (isLoadPromptData) {
            baseDao.loadPromptData(dt);
        }
        return dt;
    }

    /**
     * 通用数据查询
     * fse 中必须要表名 & uuid
     *
     * @param fse
     * @param isMoreSubData 是否查询子表
     * @return
     * @throws BaseException
     */
    public FieldSetEntity getFieldSetEntity(FieldSetEntity fse, boolean isMoreSubData) throws BaseException {
        return baseDao.getFieldSetEntity(fse.getTableName(), fse.getUUID(), isMoreSubData);
    }

    /**
     * 通用数据保存
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    @Transactional
    @Override
    public String saveFieldSetEntity(FieldSetEntity fse) throws BaseException {
        BaseUtil.createCreatorAndCreationTime(fse);
        baseDao.saveFieldSetEntity(fse);
        return fse.getUUID();
    }

    /**
     * 通用数据删除
     * fse 必传表名 && uuid(多个用逗号分割）
     *
     * @param fse
     * @return
     * @throws BaseException
     */
    @Transactional
    @Override
    public boolean delete(FieldSetEntity fse) throws BaseException {
        return baseDao.delete(fse.getTableName(), fse.getUUID().split(","));
    }

}