package com.highdatas.mdm.controller;


import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.mapper.UserMapper;
import com.highdatas.mdm.pojo.CodeMsg;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.pojo.ViewMapFieldItem;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.AESUtil;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.DbUtils;
import lombok.SneakyThrows;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author kimi
 * @since 2020-04-15
 */
@RestController
@RequestMapping("/sysView")
public class SysViewController {
    @Autowired
    ISysViewService viewService;
    @Autowired
    ISysViewJoinService sysViewJoinService;
    @Autowired
    IMaintainService maintainService;
    @Autowired
    ISysMenuService menuService;
    @Autowired
    UserMapper mapper;
    @Autowired
    IMasterAuthorService masterAuthorService;
    @Autowired
    MasterDataService masterDataService;
    @Autowired
    TableInfoMapper tableInfoMapper;
    @Autowired
    IMenuMappingService menuMappingService;
    @Autowired
    ISysViewLogicService logicService;
    @Autowired
    ISysViewLogicmapService logicmapService;

    @SneakyThrows
    @RequestMapping(value = "/test",  method = RequestMethod.GET)
    public Result test(HttpServletRequest request) throws Exception {
        List<Map<String, Object>> test = mapper.test();
        String keys = "ismytestkeys";
        byte[] secretKey = AESUtil.getSecretKey(keys);
        String content = JSONArray.toJSONString(test);
        long start = System.currentTimeMillis();
        byte[] bytes = content.getBytes("utf-8");
        int length = bytes.length;
        System.out.println(length  + "K");
        String s = AESUtil.aesPKCS7PaddingEncrypt(content, secretKey.toString());
        long end = System.currentTimeMillis();
        float time = (end - start) ;
        System.out.println(time + "s");
        return Result.success(s);
    }

    @RequestMapping(value = "/test1",  method = RequestMethod.GET)
    public Result test1(HttpServletRequest request) throws InterruptedException {
        Thread.sleep(3000);
        return Result.success(null);
    }

    @RequestMapping(value = "/all/{userId}",  method = RequestMethod.GET)
    public Result getAll(@PathVariable String userId, HttpServletRequest request) {
        //TODO
        Wrapper<SysView> eq = new EntityWrapper<SysView>().eq(Constant.USERID, userId);
        List<SysView> records = viewService.selectList(eq);
        for (SysView record : records) {
            String id = record.getId();
            String baseMaintainStr = record.getBaseMaintain();

            Maintain baseMaintain = viewService.getBaseMaintain(record);
            if (baseMaintain == null) {
                continue;
            }
            record.setBaseTableName(baseMaintain.getTableName());
            record.setBaseVersion(baseMaintain.getVersion());
            String menuId = record.getMenuId();
            SysMenu sysMenu = menuService.selectById(menuId);
            if (sysMenu == null) {
                continue;
            }
            record.setMenuName(sysMenu.getName());
            List<SysViewJoin> sysViewJoins = sysViewJoinService.selectList(new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, id));
            List<String> menuIds = sysViewJoins.stream()
                    .map(sysViewJoin -> sysViewJoin.getMenuId())
                    .collect(Collectors.toList());
            if (!menuIds.isEmpty()) {
                List<SysMenu> sysMenus = menuService.selectBatchIds(menuIds);
                Collections.reverse(sysMenus);
                String subMenuName = sysMenus.stream().map(subMenu -> subMenu.getName()).collect(Collectors.joining(Constant.SEMICOLON));
                record.setSubMenuName(subMenuName);
            }

        }
        return Result.success(records);
    }

    @RequestMapping(value = "/refreshData/{id}",  method = RequestMethod.GET)
    public Result createView(@RequestParam String id, @RequestParam Boolean active) {
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        viewService.createView(sysView.getId());
        return Result.success(sysView);
    }

    @RequestMapping(value = "/saveMapField/{id}",  method = RequestMethod.GET)
    public Result saveMapField(@RequestParam String id, @RequestParam String mapField) {
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        sysView.setMappingField(mapField).updateById();
        return Result.success(sysView);
    }

    @RequestMapping(value = "/createView/{id}",  method = RequestMethod.GET)
    public Result createView(@PathVariable String id) {
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        boolean view = viewService.createView(sysView.getId());
        if (view) {
            return Result.success(null);
        } else {
            return Result.error(CodeMsg.CREATE_ERROR);
        }

    }


    @RequestMapping(value = "/active/{id}",  method = RequestMethod.GET)
    public Result active(@PathVariable String id, @RequestParam Boolean active) {
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        sysView.setActive(active).updateById();
        return Result.success(sysView);
    }

    @RequestMapping(value = "/getViewData/{id}/page/{pageNo}",  method = RequestMethod.GET)
    public Result getViewData(@PathVariable String id, @PathVariable Integer pageNo, HttpServletRequest request) {
        String pageSizeStr = request.getParameter("pageSize");
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        int pageSize = 15;
        if (!StringUtils.isEmpty(pageSizeStr)) {
            pageSize = Integer.valueOf(pageSizeStr);
        }

        return viewService.getViewData(sysView, pageNo, pageSize);

    }

    @RequestMapping(value = "/getMapData/{id}/page/{pageNo}",  method = RequestMethod.GET)
    public Result getMapData(@PathVariable String id, @PathVariable Integer pageNo, @RequestParam String changedField, HttpServletRequest request) {
        String pageSizeStr = request.getParameter("pageSize");
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        int pageSize = 15;
        if (!StringUtils.isEmpty(pageSizeStr)) {
            pageSize = Integer.valueOf(pageSizeStr);
        }
        return viewService.getMapData(sysView, changedField, pageNo, pageSize);

    }

    @RequestMapping(value = "/field/{userId}", method = RequestMethod.GET)
    public Result<List<SysField>> fieldList(@PathVariable String userId, @RequestParam boolean needUpdate,  @RequestParam String maintainId, HttpServletRequest request) {
        TUser user = DbUtils.getUserById(userId);
        if (user == null) {
            return Result.error(CodeMsg.USER_NOT_MATHED);
        }
        if (needUpdate) {
            Maintain nowVersion = maintainService.getNowVersion(maintainId);
            List<SysField> field = masterAuthorService.getField(user, nowVersion.getId());
            return Result.success(field) ;
        }
        List<SysField> field = masterAuthorService.getField(user, maintainId);
        return Result.success(field) ;
    }

    @RequestMapping(value = "/mapFieldList/{id}",  method = RequestMethod.GET)
    public Result active(@PathVariable String id) {
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }

        List<ViewMapFieldItem> mapField = viewService.getMapField(sysView);
        return Result.success(mapField);
    }

    @RequestMapping(value = "/get/{id}",  method = RequestMethod.GET)
    public Result get(@PathVariable String id) {
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        String menuId = sysView.getMenuId();
        LinkedHashSet<String> parentIdSet = new LinkedHashSet<>();
        parentIdSet.add(menuId);
        LinkedHashSet<String> byParentId = menuService.getByParentId(parentIdSet);
        ArrayList<String> strings = new ArrayList<>(byParentId);
        Collections.reverse(strings);
        String collect = strings.stream().collect(Collectors.joining(Constant.SEMICOLON));
        sysView.setMenuName(collect);
        List<SysViewJoin> sysViewJoins = sysViewJoinService.selectList(new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, id));
        for (SysViewJoin sysViewJoin : sysViewJoins) {
            parentIdSet.clear();
            parentIdSet.add(sysViewJoin.getMenuId());
            LinkedHashSet<String> subParent = menuService.getByParentId(parentIdSet);
            ArrayList<String> subList = new ArrayList<>(subParent);
            Collections.reverse(subList);
            String subMenuName = subList.stream().collect(Collectors.joining(Constant.SEMICOLON));
            sysViewJoin.setMenuName(subMenuName);
        }
        sysView.setViewJoinList(sysViewJoins);

        List<SysViewLogicmap> sysViewLogicmaps = logicmapService.selectList(new EntityWrapper<SysViewLogicmap>().eq(Constant.PARENT_ID, sysView.getId()));
        sysView.setLogicmapList(sysViewLogicmaps);
        return Result.success(sysView);
    }

    @RequestMapping(value = "/getCnt/{userId}",  method = RequestMethod.GET)
    public Result cnt(@PathVariable String userId, HttpServletRequest request) {
        TUser user = DbUtils.getUserById(userId);
        if (user == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        Wrapper<SysView> userWrapper = new EntityWrapper<SysView>().eq("user_id", userId);
        int totalCnt = viewService.selectCount(userWrapper);
        userWrapper.eq("active", true);
        int activeCnt = viewService.selectCount(userWrapper);
        userWrapper.eq("subscribe", true);
        int subscribeCnt = viewService.selectCount(userWrapper);
        JSONObject object = new JSONObject();
        object.fluentPut("totalCnt", totalCnt);
        object.fluentPut("activeCnt", activeCnt);
        object.fluentPut("subscribeCnt", subscribeCnt);
        return Result.success(object);
    }


    @RequestMapping(value = "/create/{userId}",  method = RequestMethod.GET)
    public Result add(@PathVariable String userId, HttpServletRequest request) {
        SysView sysView = new SysView();
        sysView.setId(DbUtils.getUUID())
                .setUserId(userId)
                .setCreateTime(new Date())
                .setStatus(ViewStatus.edit)
                .setEmptyData(true)
                .insert();

        viewService.getMappingTableName(sysView);
        return Result.success(sysView);
    }

    @SneakyThrows
    @RequestMapping(value = "/deleteMap/{id}",  method = RequestMethod.GET)
    public Result deleteMap(@PathVariable String id, @RequestParam String changedField) {
        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }

        viewService.deleteMapField(sysView, changedField);
        logicmapService.delete(new EntityWrapper<SysViewLogicmap>().eq(Constant.PARENT_ID, id).eq(Constant.FIELD, changedField));
        List<SysViewLogicmap> sysViewLogicmaps = logicmapService.selectList(new EntityWrapper<SysViewLogicmap>().eq(Constant.PARENT_ID, sysView.getId()));
        sysView.setLogicmapList(sysViewLogicmaps);
        return Result.success(sysView);
    }
    @SneakyThrows
    @RequestMapping(value = "/delete/detail/{id}",  method = RequestMethod.GET)
    public Result deleteDetail(@PathVariable String id) {
        SysViewJoin sysViewJoin = sysViewJoinService.selectById(id);
        if (sysViewJoin == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        String parentId = sysViewJoin.getParentId();
        SysView sysView = viewService.selectById(parentId);
        String userId = sysView.getUserId();
        TUser user = DbUtils.getUserById(userId);

        Maintain joinMaintain = viewService.getJoinMaintain(sysViewJoin);
        List<String> subFieldList = viewService.getSubFieldList(sysViewJoin, user);
        boolean delete = false;

        for (String subField: subFieldList) {
            String changeFieldName = viewService.changeFieldName(joinMaintain.getTableName(), subField);
            logicmapService.delete(new EntityWrapper<SysViewLogicmap>()
                    .eq(Constant.PARENT_ID, sysView.getId())
                    .eq(Constant.FIELD, changeFieldName)
            );
            delete = viewService.deleteMapField(sysView, changeFieldName);
        }
        if (delete) {
            return  Result.success(CodeMsg.DELETE_SUCCESS);
        } else {
            return  Result.error(CodeMsg.DELETE_ERROR);
        }
    }


    @SneakyThrows
    @RequestMapping(value = "/delete/{id}",  method = RequestMethod.GET)
    public Result delete(@PathVariable String id) {
        return viewService.deleteView(id);
    }

    @RequestMapping(value = "/maintainList/{userId}", method = RequestMethod.GET)
    public Result add(@PathVariable String userId, @RequestParam String menuId, HttpServletRequest request) {
        TUser user = DbUtils.getUserById(userId);
        if (user == null) {
            return Result.error(CodeMsg.USER_NOT_MATHED);
        }
        String tableNameByMenu = menuMappingService.getTableNameByMenu(menuId);
        if (StringUtils.isEmpty(tableNameByMenu)) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        LinkedHashSet<Maintain> maintainSet = masterAuthorService.getMaintainSet(tableNameByMenu, user);
        ArrayList<Maintain> maintains = new ArrayList<>(maintainSet);
        for (Maintain maintain : maintains) {
            maintain.setNeedUpdate(false);
        }
        Maintain max = new Maintain();
        max.setId(tableNameByMenu);
        max.setTableName(tableNameByMenu);
        max.setNeedUpdate(true);
        maintains.add(0, max);
        return Result.success(maintains);
    }

    @RequestMapping(value = "/update",  method = RequestMethod.POST)
    public Result add(@RequestBody SysView view) {
        if (StringUtils.isEmpty(view.getId())) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        if (StringUtils.isEmpty(view.getMenuId()) || StringUtils.isEmpty(view.getBaseMaintain()) ) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        if (StringUtils.isEmpty(view.getViewTableName())) {
            viewService.getViewTableName(view);
        }
        List<SysViewLogicmap> logicmapList = view.getLogicmapList();

        logicmapService.delete(new EntityWrapper<SysViewLogicmap>().eq(Constant.PARENT_ID, view.getId()));
        if (logicmapList != null) {
            for (SysViewLogicmap logicmap : logicmapList) {
                logicmap.setId(DbUtils.getUUID()).setParentId(view.getId()).insert();
            }
        }

        view.setEmptyData(false).setStatus(ViewStatus.edit);
        //delete
        sysViewJoinService.delete(new EntityWrapper<SysViewJoin>().eq(Constant.PARENT_ID, view.getId()));

        List<SysViewJoin> viewJoinList = view.getViewJoinList();
        boolean insert;
        for (SysViewJoin sysViewJoin : viewJoinList) {
            insert = sysViewJoin.setId(DbUtils.getUUID()).insert();
            if (!insert) {
                return Result.error(CodeMsg.INSERT_ERROR);
            }
        }
        view.setUpdateTime(new Date());
        view.updateById();
        return Result.success(view);
    }
    @SneakyThrows
    @RequestMapping(value = "/download/{id}",  method = RequestMethod.GET)
    public void download(@PathVariable String id,  @RequestParam String menuId, @RequestParam String field, HttpServletResponse response) {

        SysView sysView = viewService.selectById(id);
        if (sysView == null) {
            return;
        }
        String userId = sysView.getUserId();
        TUser user = DbUtils.getUserById(userId);
        if (user == null) {
            return;
        }
        viewService.downlodMap(sysView,user, response, field, menuId);
    }
}