package com.highdatas.mdm.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.mapper.SysViewMapper;
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.pojo.*;
import com.highdatas.mdm.pojo.kettle.UnBigDataDataSourceInfo;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.*;
import com.highdatas.mdm.util.pool.MqEntity;
import com.highdatas.mdm.util.pool.MqMessage;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletResponse;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author kimi
 * @since 2020-04-15
 */
@Service
@Slf4j
public class SysViewServiceImpl extends ServiceImpl<SysViewMapper, SysView> implements ISysViewService {
    @Autowired
    ISysViewJoinService joinService;
    @Autowired
    IMaintainService maintainService;
    @Autowired
    UnBigDataDataSourceInfo unBigDataDataSourceInfo;
    @Autowired
    TableInfoMapper tableInfoMapper;
    @Autowired
    SysViewMapper viewMapper;
    @Autowired
    MasterDataService masterDataService;
    @Autowired
    IMasterAuthorService masterAuthorService;
    @Autowired
    ISysMenuService menuService;
    @Autowired
    IMenuMappingService menuMappingService;
    @Autowired
    ISysFieldService fieldService;
    @Autowired
    DispenseService dispenseService;
    @Autowired
    RuleClient ruleClient;
    @Autowired
    AntianaphylaxisClient antianaphylaxisClient;
    @Autowired
    RedisClient redisClient;

    @Override
    public Page getInitPageInfo(String viewId) {


        SysView sysView = selectById(viewId);
        String userId = sysView.getUserId();
        String realRedisKey = RedisClient.getRealRedisKey(userId + "-" + sysView.getId());
        Object redisValObj = redisClient.getRedisValObj(realRedisKey);
        if (redisValObj != null) {
            JSONObject object = (JSONObject) redisValObj;
            Page page = JSONObject.parseObject(object.toJSONString(), Page.class);
            return page;
        }

        Page page = new Page(0);
        String viewTableName = sysView.getViewTableName();
        List<TableSchemaResult> tableField = tableInfoMapper.getTableField(viewTableName);
        int totalLength = 0;
        for (TableSchemaResult tableSchemaResult : tableField) {
            int length = tableSchemaResult.getLength();
            totalLength += length;
        }
        int pageSize = 20;
       if (totalLength != 0) {
           pageSize = Constant.MaxDispenseSize / totalLength;
       }
        page.setPageSize(pageSize);
        Long viewCount = getViewCount(sysView);
        if (viewCount == 0) {
            redisClient.putRedisValObj(realRedisKey, page);
            return page;
        }
        page.setRecordCount(viewCount.intValue());
        int pages;
        if (viewCount % pageSize == 0) {
            pages = Long.valueOf(viewCount/pageSize).intValue();
        }else  {
            pages =  (Long.valueOf(viewCount/pageSize).intValue())  + 1;
        }
        page.setPages(pages);

        redisClient.putRedisValObj(realRedisKey, page);
        return page;
    }
    @Override
    public boolean createView(String viewId) {
        try {
            SysView sysView = selectById(viewId);

            if (sysView == null) {
                log.error("view not found");
                return false;
            }
            String userId = sysView.getUserId();
            TUser user = DbUtils.getUserById(userId);
            if (user == null) {
                log.error("user not found");
                return false;
            }

            Maintain baseMaintain = getBaseMaintain(sysView);
            if (baseMaintain == null) {
                log.error("baseMaintain not found");
                return false;
            }
            String baseTableName = baseMaintain.getTableName();
            sysView.setBaseTableName(baseTableName);

            List<String> totalFieldList = getTotalFieldList(sysView);

            //
            String tableName = getViewTableName(sysView);
            log.info("View TABLE name:" + tableName);
            totalFieldList.add(Constant.ID);
            boolean created = dropCreateViewTable(totalFieldList, tableName);

            //TODO 主键
            if (!created) {
                log.info("un create view table:" + tableName);
                return false;
            }
            totalFieldList.remove(Constant.ID);
            List<String> baseFieldList = getBaseFieldList(sysView);
            //trans first
            if (baseFieldList == null && baseFieldList.isEmpty()) {
                log.error("base field not found:");
                return false;
            }
            baseFieldList.add(Constant.ID);
            String baseFields = baseFieldList.stream()
                    .map(s -> Constant.ID.equalsIgnoreCase(s) ? Constant.MYSQL_UUID : s)
                    .collect(Collectors.joining(Constant.COMMA));
            String fixBaseFields = baseFieldList.stream()
                    .map(s -> Constant.ID.equalsIgnoreCase(s) ? Constant.ID : changeFieldName(baseTableName, s))
                    .collect(Collectors.joining(Constant.COMMA));

            baseFieldList.remove(Constant.ID);

            String filter = masterAuthorService.getFilter(user, baseMaintain.getId());
            if (StringUtils.isEmpty(filter)) {
                filter = Constant.WHERE_DEFAULT;
            }

            log.info("View base filter:" + filter);
            String s = masterDataService.selectByVersionSql(null, baseTableName, baseFieldList, filter, baseMaintain.getVersion(), false);
            log.info("View base select sql:" + s);
            //base INSERT
            tableInfoMapper.insertOneSelect(tableName, fixBaseFields, baseFields, s);

            log.info("insert select");
            // left insert
            InsertJoin(sysView);
            log.info("insert left join");
            // change val common
            changeValCommon(sysView);
            log.info("changeValCommon");
            //change logic


            boolean checked = checkTempData(sysView);
            if (!checked) {
                sysView.setStatus(ViewStatus.unChecked).updateById();
            } else {
                sysView.setStatus(ViewStatus.working).updateById();
            }

            //
            return true;
        }
        catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    private boolean checkTempData(SysView sysView) {
        SysAssembleCheckType checkType = sysView.getCheckType();
        if (checkType == null) {
            return false;
        }
        if (checkType.equals(SysAssembleCheckType.unlimited)) {
            return true;
        }


        HashMap<String,Boolean> fieldResultSet =  ruleClient.execuImmeForCollect(sysView.getViewTableName(), sysView.getUserId());
        switch (checkType){
            case successAdd:
                String unSuccessFields = fieldResultSet.keySet().stream().filter(s -> !fieldResultSet.get(s)).collect(Collectors.joining(Constant.COMMA));
                if (fieldResultSet.keySet().contains(false)) {
                    return false;
                }
                break;
            case partSuccessAdd:
                String checkFields = sysView.getCheckField();
                String[] split = checkFields.split(Constant.SEMICOLON);
                for (String s : split) {
                    Boolean checked = fieldResultSet.get(s);
                    if (checked == null || !checked) {
                        return false;
                    }
                }
                break;
        }
        return true;
    }

    private void InsertJoin(SysView sysView) {
        String userId = sysView.getUserId();
        TUser user = DbUtils.getUserById(userId);
        String baseTableName = sysView.getBaseTableName();
        String tableName = sysView.getViewTableName();
        ContentBuilder joinBuilder = new ContentBuilder(Constant.EMPTY);
        ContentBuilder updateFieldBuilder = new ContentBuilder(Constant.COMMA);
        List<SysViewJoin> viewJoinList = sysView.getViewJoinList();

        for (SysViewJoin sysViewJoin : viewJoinList) {
            sysViewJoin.setBaseField(changeFieldName(sysView.getBaseTableName(), sysViewJoin.getBaseField()));
            Maintain joinMaintain = getJoinMaintain(sysViewJoin);
            String joinTableName = joinMaintain.getTableName();
            sysViewJoin.setBaseTableName(sysView.getViewTableName());
            String joinStr = sysViewJoin.createJoinStr();
            if (StringUtils.isEmpty(joinStr)) {
                continue;
            }
            joinBuilder.append(joinStr);
            List<String> subFieldList = getSubFieldList(sysViewJoin, user);
            for (String subOneField : subFieldList) {
                String changeFieldName = changeFieldName(sysViewJoin.getJoinTableName(), subOneField);
                String base = MessageFormat.format(Constant.Alias, sysView.getViewTableName(), changeFieldName);
                String join = MessageFormat.format(Constant.Alias, joinTableName, subOneField);
                Segment segment = new Segment(base, join);
                updateFieldBuilder.append(segment.toRawString());
            }
        }
        // JOIN
        String joinSql = joinBuilder.toString();
        if (StringUtils.isEmpty(joinSql)) {
            log.info("sysViewJoin sql is null");
            return;
        }
        tableInfoMapper.updateJoin(tableName, joinSql, updateFieldBuilder.toString(), Constant.WHERE_DEFAULT);
    }

    private void changeValCommon(SysView sysView) {
        String mappingField = sysView.getMappingField();
        String tableName = sysView.getViewTableName();
        String mappingTable = sysView.getMappingTable();
        mappingTable = tableInfoMapper.selectTableByName(mappingTable);
        if (StringUtils.isEmpty(mappingTable)) {
            return;
        }
        List<String> split = DbUtils.split(mappingField);
        for (String oneMapField : split) {
            String base = MessageFormat.format(Constant.Alias, tableName, oneMapField);
            String join = MessageFormat.format(Constant.Alias, mappingTable, Constant.Pre);
            String updateJoin = MessageFormat.format(Constant.Alias, mappingTable, Constant.fix);
            Segment joinSegment = new Segment(base, join);
            Segment updateSegment = new Segment(base, updateJoin);
            Segment filterSegment = new Segment(MessageFormat.format(Constant.Alias, mappingTable, Constant.Code), oneMapField);
            String changeJoinStr = MessageFormat.format(Constant.InnerJoinTemplate, ViewJoinType.inner, mappingTable, joinSegment.toRawString());
            if (StringUtils.isEmpty(changeJoinStr)){
                return;
            }
            tableInfoMapper.updateJoin(tableName, changeJoinStr, updateSegment.toRawString(), filterSegment.toString());
        }
    }

    private boolean dropCreateViewTable(List<String> totalFieldList, String tableName) {
        boolean created = unBigDataDataSourceInfo.dropData(tableName);
        if (!created) {
            return false;
        }

        created = unBigDataDataSourceInfo.createTable(tableName, totalFieldList);
        if (!created) {
            //TODO
            return false;
        }
        return true;
    }

    @Override
    public String getViewTableName(SysView view) {
        String viewTableName = view.getViewTableName();
        if (StringUtils.isEmpty(viewTableName)) {
            Maintain baseMaintain = getBaseMaintain(view);
            viewTableName = Constant.VIEW + baseMaintain.getTableName() + baseMaintain.getOrderNo() + DbUtils.getUUID(5);
            view.setViewTableName(viewTableName).updateById();
        }
        return viewTableName;
    }

    @Override
    public String getMappingTableName(SysView view) {
        String id = view.getId();
        String top = id.substring(0, 5);
        String mappingTableName = Constant.VIEW + top + "mapping" + DbUtils.getUUID(4);
        view.setMappingTable(mappingTableName).updateById();
        return mappingTableName;
    }
    @Override
    public List<String> getSubFieldList(SysViewJoin join, TUser user) {
        String fieldsStr = join.getFields();
        List<String> baseFieldList = new ArrayList<>();
        if (Constant.All.equalsIgnoreCase(fieldsStr)) {
            Maintain joinMaintain = getJoinMaintain(join);
            List<SysField> fieldList = masterAuthorService.getField(user, joinMaintain.getId());
            if (fieldList != null) {
                baseFieldList = fieldList.stream().map(sysField -> sysField.getField()).collect(Collectors.toList());
            }
        }else {
            baseFieldList = DbUtils.split(fieldsStr);
        }

        return baseFieldList;
    }

    private List<String> getBaseFieldList(SysView sysView) {
        String fieldsStr = sysView.getFields();
        List<String> baseFieldList = new ArrayList<>();
        if (Constant.All.equalsIgnoreCase(fieldsStr)) {
            String userId = sysView.getUserId();
            TUser user = DbUtils.getUserById(userId);
            Maintain baseMaintain = getBaseMaintain(sysView);
            List<SysField> fieldList = masterAuthorService.getField(user, baseMaintain.getId());
            baseFieldList = fieldList.stream().map(sysField -> sysField.getField()).collect(Collectors.toList());
        }else {
            baseFieldList = DbUtils.split(fieldsStr);
        }

        return baseFieldList;
    }
    @Override
    public List<ViewMapFieldItem> getMapField(SysView sysView) {
        List<ViewMapFieldItem> result = new ArrayList<>();
        Maintain baseMaintain = getBaseMaintain(sysView);
        SysMenu menuByTableName = menuMappingService.getMenuByTableName(baseMaintain.getTableName());
        if (menuByTableName == null) {
            return null;
        }
        List<String> baseFieldList = getBaseFieldList(sysView);

        for (String field : baseFieldList) {
            String changeFieldName = changeFieldName(baseMaintain.getTableName(), field);
            SysField oneFieldByMaintainField = fieldService.getOneFieldByMaintain(baseMaintain.getId(), field);
            if (oneFieldByMaintainField == null) {
                continue;
            }
            ViewMapFieldItem viewMapFieldItem = new ViewMapFieldItem();
            viewMapFieldItem.setChangedField(changeFieldName);
            viewMapFieldItem.setField(field);
            viewMapFieldItem.setFieldName(oneFieldByMaintainField.getAlias());
            viewMapFieldItem.setMenuId(menuByTableName.getId());
            viewMapFieldItem.setMenuName(menuByTableName.getName());

            result.add(viewMapFieldItem);
        }
        String userId = sysView.getUserId();
        TUser user = DbUtils.getUserById(userId);
        List<SysViewJoin> joinList =  getJoinList(sysView);
        for (SysViewJoin sysViewJoin : joinList) {
            Maintain joinMaintain = getJoinMaintain(sysViewJoin);
            SysMenu subMenu = menuMappingService.getMenuByTableName(joinMaintain.getTableName());
            List<String> subFieldList = getSubFieldList(sysViewJoin, user);
            for (String subField : subFieldList) {
                String changeFieldName = changeFieldName(joinMaintain.getTableName(), subField);
                SysField oneFieldByMaintainField = fieldService.getOneFieldByMaintain(joinMaintain.getId(), subField);
                if (oneFieldByMaintainField == null) {
                    continue;
                }
                ViewMapFieldItem viewMapFieldItem = new ViewMapFieldItem();
                viewMapFieldItem.setChangedField(changeFieldName);
                viewMapFieldItem.setField(subField);
                viewMapFieldItem.setFieldName(oneFieldByMaintainField.getAlias());
                viewMapFieldItem.setMenuId(subMenu.getId());
                viewMapFieldItem.setMenuName(subMenu.getName());

                result.add(viewMapFieldItem);
            }
        }
        return result;
    }

    private List<SysViewJoin> getJoinList(SysView sysView) {
        String id = sysView.getId();
        Wrapper<SysViewJoin> eq = new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, id);
        List<SysViewJoin> joinList = joinService.selectList(eq);
        return joinList;
    }

    public List<String> getTotalFieldList(SysView sysView) {
        String userId = sysView.getUserId();
        TUser user = DbUtils.getUserById(userId);

        List<String> totalFieldList = new ArrayList<>();
        Maintain baseMaintain = getBaseMaintain(sysView);
        List<String> baseFieldList = getBaseFieldList(sysView);
        totalFieldList.addAll(baseFieldList);

        totalFieldList = totalFieldList.stream().map(s -> changeFieldName(baseMaintain.getTableName(), s)).collect(Collectors.toList());
        List<SysViewJoin> sysViewJoins = joinService.selectList(new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, sysView.getId()));
        for (SysViewJoin sysViewJoin : sysViewJoins) {
            Maintain joinMaintain = getJoinMaintain(sysViewJoin);
            List<String> subFieldList = getSubFieldList(sysViewJoin, user);
            subFieldList = subFieldList.stream().map(s -> changeFieldName(joinMaintain.getTableName(), s)).collect(Collectors.toList());
            totalFieldList.addAll(subFieldList);

            sysViewJoin.setJoinTableName(joinMaintain.getTableName());
            sysViewJoin.setBaseTableName(baseMaintain.getTableName());
        }
        sysView.setViewJoinList(sysViewJoins);
        return totalFieldList;
    }

    @Override
    public Maintain getBaseMaintain(SysView sysView) {

    String baseMaintainStr = sysView.getBaseMaintain();
    if (StringUtils.isEmpty(baseMaintainStr)) {
        return null;
    }
    Maintain baseMaintain;
    if (sysView.getNeedUpdate()) {
        baseMaintain = maintainService.getNowVersion(baseMaintainStr);
    }else {
        baseMaintain = maintainService.selectById(baseMaintainStr);
    }
    return baseMaintain;
    }

    @Override
    public Maintain getJoinMaintain(SysViewJoin viewJoin) {

        String baseMaintainStr = viewJoin.getJoinMaintain();
        if (StringUtils.isEmpty(baseMaintainStr)) {
            return null;
        }
        Maintain baseMaintain;
        if (viewJoin.getNeedUpdate()) {
            baseMaintain = maintainService.getNowVersion(baseMaintainStr);
        }else {
            baseMaintain = maintainService.selectById(baseMaintainStr);
        }
        return baseMaintain;
    }

    @Override
    public String changeFieldName(String baseTableName, String field) {
        return DbUtils.StrJoinLink(Constant.EMPTY_Str, baseTableName, Constant.UnderLine, field);
    }

    @Override
    public void dealFlow(String maintainId, ActivitiStatus status) {
        try {
            if (!ActivitiStatus.open.equals(status)) {
                return;
            }
            Maintain maintain = maintainService.selectById(maintainId);
            String maintainTableName = maintain.getTableName();

            Wrapper<SysView> eq = new EntityWrapper<SysView>()
                    .eq("need_update", true)
                    .eq("base_maintain", maintainTableName);
            List<SysView> sysViews = selectList(eq);
            for (SysView sysView : sysViews) {
                ViewStatus viewStatus = sysView.getStatus();
                if (!ViewStatus.working.equals(viewStatus)) {
                    continue;
                }
                createView(sysView.getId());

                Boolean subscribe = sysView.getSubscribe();
                if (!subscribe) {
                    continue;
                }
                MqEntity mqEntity = new MqEntity();
                mqEntity.setUserId(sysView.getUserId());
                mqEntity.setMsgTopicName(Constant.View);
                mqEntity.setType(Constant.View);
                mqEntity.setDataId(sysView.getId());
                mqEntity.setMsgTagName(sysView.getId());
                mqEntity.setMsgKey(DbUtils.getUUID(16));
                MqMessage mqMessage = new MqMessage(mqEntity);
                dispenseService.pushActiveMq(mqMessage);
            }
            return;
        }
        catch (Exception e) {
            e.printStackTrace();
        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result deleteView(String id) throws Exception {
        SysView sysView = selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        joinService.delete(new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, id));
        String viewTableName = sysView.getViewTableName();
        if (!StringUtils.isEmpty(viewTableName)) {
            unBigDataDataSourceInfo.dropData(viewTableName);
        }
        String mappingTable = sysView.getMappingTable();
        if (!StringUtils.isEmpty(mappingTable)) {
            unBigDataDataSourceInfo.dropData(mappingTable);
        }
        sysView.deleteById();
        return Result.success(CodeMsg.DELETE_SUCCESS);
    }

    @Override
    public List<ViewDictItem> getViewFieldMap(String viewId) {
        SysView sysView = selectById(viewId);
        if (sysView == null) {
            return null;
        }
        Maintain baseMaintain = getBaseMaintain(sysView);
        if (baseMaintain == null) {
            return null;
        }
        String menuId = sysView.getMenuId();
        SysMenu sysMenu = menuService.selectById(menuId);
        if (sysMenu == null) {
            return null;
        }
        List<String> baseFieldList = getBaseFieldList(sysView);
        ArrayList<ViewDictItem> dictList = new ArrayList<>();

        for (String field : baseFieldList) {
            ViewDictItem viewDictItem = new ViewDictItem();
            viewDictItem.setMenuId(sysMenu.getId());
            viewDictItem.setRawField(field);
            String changeFieldName = changeFieldName(baseMaintain.getTableName(), field);
            viewDictItem.setViewField(changeFieldName);
            dictList.add(viewDictItem);
        }

        List<SysViewJoin> sysViewJoins = joinService.selectList(new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, sysView.getId()));
        for (SysViewJoin sysViewJoin : sysViewJoins) {
            String subMenuId = sysViewJoin.getMenuId();
            SysMenu subMenu = menuService.selectById(subMenuId);
            if (subMenu == null) {
                continue;
            }
            Maintain joinMaintain = getJoinMaintain(sysViewJoin);
            if (joinMaintain == null) {
                continue;
            }
            String fields = sysViewJoin.getFields();

            List<String> subFieldList = DbUtils.split(fields);
            for (String field : subFieldList) {
                ViewDictItem viewDictItem = new ViewDictItem();
                viewDictItem.setMenuId(subMenu.getId());
                viewDictItem.setRawField(field);
                String changeFieldName = changeFieldName(joinMaintain.getTableName(), field);
                viewDictItem.setViewField(changeFieldName);
                dictList.add(viewDictItem);
            }
        }
        return dictList;
    }

    @Override
    public Result getMapData(SysView sysView, String changedField, Integer pageNo, int pageSize) {
        String mappingTable = sysView.getMappingTable();

        if (StringUtils.isEmpty(mappingTable) && !StringUtils.isEmpty(sysView.getMappingField())) {
            return  Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        boolean exists = unBigDataDataSourceInfo.checkTableExists(mappingTable);
        if (!exists) {
            return null;
        }
        Segment segment = new Segment(Constant.Code, changedField);

        Long count = tableInfoMapper.getCount(mappingTable, segment.toString());
        if (count == 0) {
            return null;
        }
        Page page = new Page(count);
        page.setPageSize(pageSize);
        page.setPageNo(pageNo);
        ArrayList<String> fields = new ArrayList<>();
        fields.add(Constant.Code);
        fields.add(Constant.Pre);
        fields.add(Constant.fix);
        String fieldStr = fields.stream().collect(Collectors.joining(Constant.COMMA));
        List<Map<String, Object>> maps = tableInfoMapper.selectByPage(mappingTable, fieldStr, segment.toString(), page.getLimitSQL());
        JSONObject object = new JSONObject();
        object.fluentPut("records", maps);
        object.fluentPut("pages", page.getPageCount());
        object.fluentPut("current", pageNo);
        object.fluentPut("total", count);

        return Result.success(object);
    }
    @Override
    public long getViewCount(SysView sysView) {
        String viewTableName = sysView.getViewTableName();
        if (StringUtils.isEmpty(viewTableName)) {
            log.info(" view table is null");
            return  0;
        }
        boolean exists = unBigDataDataSourceInfo.checkTableExists(viewTableName);
        if (!exists) {
            log.info(" view table is not exist" + viewTableName);
            return 0;
        }

        Long count = tableInfoMapper.getCount(viewTableName, Constant.WHERE_DEFAULT);
        log.info(" view table count" + count);
        if (count == null) {
            return 0L;
        }
        return count;
    }
    @Override
    public Result getViewData(SysView sysView, Integer pageNo, int pageSize) {
        return getViewData(sysView, pageNo, pageSize,null);
    }

    @Override
    public Result getViewData(SysView sysView, Integer pageNo, int pageSize, Page page) {
        String viewTableName = sysView.getViewTableName();
        long count = 0;

        if (page == null) {
            count = getViewCount(sysView);
            page = new Page(count);
            page.setPageSize(pageSize);
            page.setPageNo(pageNo);
        }else {
            count = page.getRecordCount();
        }

        log.info(" view count "+count);
        if (count == 0) {
            return null;
        }

        List<TableSchemaResult> tableField = tableInfoMapper.getTableField(viewTableName);
        String fields = tableField.stream().map(tableSchemaResult -> tableSchemaResult.getFieldName()).collect(Collectors.joining(Constant.COMMA));
        log.info(" view field" + fields);

        List<Map<String, Object>> maps = tableInfoMapper.selectByPage(viewTableName, fields, Constant.WHERE_DEFAULT, page.getLimitSQL());
        if (maps == null || maps.isEmpty()) {
            log.info(" view data is null");
        }
        Map<String, AntianaphylaxisResult> helpfulField = antianaphylaxisClient.getHelpfulField(fields, viewTableName);
        antianaphylaxisClient.fixMasterData(maps,helpfulField);

        JSONObject object = new JSONObject();
        object.fluentPut("records", maps);
        if (page == null) {
            object.fluentPut("pages", page.getPageCount());
            object.fluentPut("current", pageNo);
            object.fluentPut("total", count);
            object.fluentPut("pageSize", page.getPageSize());
        }


        //fields
        ArrayList<ViewField> sysFields = new ArrayList<>();
        Maintain baseMaintain = getBaseMaintain(sysView);
        List<String> baseFieldList = getBaseFieldList(sysView);

        for (String field : baseFieldList) {
            SysField oneFieldByMaintain = fieldService.getOneFieldByMaintain(baseMaintain.getId(), field);
            if (oneFieldByMaintain == null) {
                continue;
            }
            String changeFieldName = changeFieldName(baseMaintain.getTableName(), field);
            ViewField viewField = new ViewField();
            viewField.setChangedField(changeFieldName);
            viewField.setField(field);
            viewField.setAlias(oneFieldByMaintain.getAlias());
            viewField.setMenuId(sysView.getId());
            viewField.setMenuName(sysView.getName());
            sysFields.add(viewField);
        }
        String userId = sysView.getUserId();
        TUser user = DbUtils.getUserById(userId);

        List<SysViewJoin> joinList = joinService.selectList(new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, sysView.getId()));
        for (SysViewJoin sysViewJoin : joinList) {
            Maintain joinMaintain = getJoinMaintain(sysViewJoin);
            List<String> subFieldList = getSubFieldList(sysViewJoin, user);
            for (String subField : subFieldList) {
                SysField oneFieldByMaintain = fieldService.getOneFieldByMaintain(joinMaintain.getId(), subField);
                if (oneFieldByMaintain == null) {
                    continue;
                }
                String changeFieldName = changeFieldName(joinMaintain.getTableName(), subField);
                ViewField viewField = new ViewField();
                viewField.setChangedField(changeFieldName);
                viewField.setField(subField);
                viewField.setAlias(oneFieldByMaintain.getAlias());
                viewField.setMenuId(sysView.getId());
                viewField.setMenuName(sysView.getName());
                sysFields.add(viewField);
            }
        }
        object.fluentPut("fields", sysFields);

        return Result.success(object);
    }

    @SneakyThrows
    @Override
    public void downlodMap(SysView sysView, TUser user, HttpServletResponse response,String field, String menuId) {
        Maintain maintain = getMaintainByMenu(sysView, menuId);
        if (maintain == null) {
            return;
        }
        ArrayList<String> fields = new ArrayList<>();
        fields.add(field);
        fields.add(Constant.ID);
        String filter = masterAuthorService.getFilter(user, maintain.getId());
        if (StringUtils.isEmpty(filter)) {
            filter = Constant.WHERE_DEFAULT;
        }
        String sql = masterDataService.selectByVersionSql(user, maintain.getTableName(), fields, filter, maintain.getVersion(), false);
        String tableName = MessageFormat.format(Constant.asTempSql, sql, Constant.H);
        String mappingTable = sysView.getMappingTable();
        boolean exists = unBigDataDataSourceInfo.checkTableExists(mappingTable);
        List<Map<String, Object>> maps;
        if (exists) {
            String changeFieldName = changeFieldName(maintain.getTableName(), field);
            maps = viewMapper.selectMapVal(tableName, MessageFormat.format(Constant.FieldAsAlias, field, Constant.Pre), Constant.WHERE_DEFAULT, mappingTable, DbUtils.quotedStr(changeFieldName));

        } else {
            maps = tableInfoMapper.selectDistinct(tableName, MessageFormat.format(Constant.FieldAsAlias, field, Constant.Pre), Constant.WHERE_DEFAULT);

        }
        //todo 大数据量优化
        fields.remove(Constant.ID);
        ArrayList<SysField> sysFields = new ArrayList<>();
        sysFields.add(new SysField().setField(Constant.Pre).setAlias(Constant.PreValue));
        sysFields.add(new SysField().setField(Constant.fix).setAlias(Constant.fixValue));
        ExcelUtil.export(response, maps, sysFields);
    }

    @Override
    public Maintain getMaintainByMenu(SysView sysView, String menuId) {
        Maintain maintain = null;
        String baseMenu = sysView.getMenuId();
        if (baseMenu != null && baseMenu.equalsIgnoreCase(menuId)) {
            maintain = getBaseMaintain(sysView);
        }else {
            List<SysViewJoin> joinList = joinService.selectList(new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, sysView.getId()));

            for (SysViewJoin sysViewJoin : joinList) {
                String subMenuId = sysViewJoin.getMenuId();
                if (subMenuId != null && subMenuId.equalsIgnoreCase(menuId)) {
                    maintain = getJoinMaintain(sysViewJoin);
                }

            }
        }
        return maintain;
    }

    @Override
    public boolean deleteMapField(SysView sysView, String changedField) {
        try {
            Segment segment = new Segment(Constant.Code, changedField);
            String mappingTable = sysView.getMappingTable();
            String mappingfield = sysView.getMappingField();
            if (StringUtils.isEmpty(mappingTable) || StringUtils.isEmpty(mappingfield)) {
                return true;
            }
            mappingTable = tableInfoMapper.selectTableByName(mappingTable);
            if (!StringUtils.isEmpty(mappingTable)){
                tableInfoMapper.delete(mappingTable, segment.toString());
            }

            String mappingField = sysView.getMappingField();
            List<String> split = DbUtils.split(mappingField);
            String collect = split.stream().filter(s -> !s.equalsIgnoreCase(changedField)).collect(Collectors.joining(Constant.SEMICOLON));
            boolean b = sysView.setMappingField(collect).updateById();
            return b;
        }
        catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }
}