package com.highdatas.mdm.controller;


import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.pojo.ActivitiBusinessType;
import com.highdatas.mdm.pojo.ActivitiStatus;
import com.highdatas.mdm.pojo.CodeMsg;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.DbUtils;
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.HttpSession;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author kimi
 * @since 2019-12-16
 */
@RestController
@RequestMapping("/menu")
public class SysMenuController {
    @Autowired
    ISysMenuService menuService;

    @Autowired
    IMenuMappingService menuMappingService;
    @Autowired
    ISysFieldService fieldService;
    @Autowired
    IDeletedTableLogService deletedTableLogService;
    @Autowired
    IFlowsService flowsService;
    @Autowired
    IMaintainService maintainService;
    @Autowired
    IMaintainFieldService maintainFieldService;
    
    @RequestMapping(value = "/all", method = RequestMethod.GET)
    public Result<List<SysMenu>> getAll() {
        EntityWrapper<SysMenu> sysMenuEntityWrapper = new EntityWrapper<>();
        sysMenuEntityWrapper.orderBy("parent_id, order_no");
        return Result.success(menuService.selectList(sysMenuEntityWrapper)) ;
    }

    @RequestMapping(value = "/audit", method = RequestMethod.GET)
    public Result<List<SysMenu>> audit(HttpServletRequest request) {
        HttpSession session = request.getSession();
        TUser user = (TUser) session.getAttribute("user");
        String userId = user.getUserId();
        List<Flows> flows = flowsService.selectList(new EntityWrapper<Flows>().ne("business_type", ActivitiBusinessType.exists).ne("status", ActivitiStatus.open).ne("status", ActivitiStatus.close));
        flows = flows.stream().filter(flow ->  flowsService.isNextAudit(flow, userId)).collect(Collectors.toList());

        HashSet<String> tableNameSet = new HashSet<>();
        List<String> maintainIds = flows.stream().map(Flows::getBusinessId).collect(Collectors.toList());
        if (maintainIds.size() == 0) {
            return  Result.success(null);
        }
        List<Maintain> maintains = maintainService.selectBatchIds(maintainIds);
        List<String> tableNameList = maintains.stream().map(Maintain::getTableName).collect(Collectors.toList());
        tableNameSet.addAll(tableNameList);
        //
        List<MaintainField> maintainFields = maintainFieldService.selectBatchIds(maintainIds);
        tableNameSet.addAll(maintainFields.stream().map(MaintainField::getTableName).collect(Collectors.toList()));
        if (tableNameSet.size() == 0) {
            return Result.success(null);
        }
        List<MenuMapping> menuMappingList = menuMappingService.selectList(new EntityWrapper<MenuMapping>().in("table_name", tableNameSet));
        List<String> menuIds = menuMappingList.stream().map(MenuMapping::getMenuId).collect(Collectors.toList());
        LinkedHashSet<String> parentIdSet = new LinkedHashSet<>(menuIds);
        Set<String> byParentId = menuService.getByParentId(parentIdSet);
        List<SysMenu> parentList = menuService.selectBatchIds(byParentId);

        return Result.success(parentList);
    }


    @RequestMapping(value = "/list", method = RequestMethod.GET)
    public Result<List<SysMenu>> getMenuList() {
        EntityWrapper<SysMenu> sysMenuEntityWrapper = new EntityWrapper<>();
        sysMenuEntityWrapper.eq("menu_type", "DataMenu");
        sysMenuEntityWrapper.orderBy("parent_id, order_no");
        List<SysMenu> sysMenus = menuService.selectList(sysMenuEntityWrapper);
        LinkedHashSet<String> parentIdSet = new LinkedHashSet<>();
        for (SysMenu sysMenu : sysMenus) {
            MenuMapping menuMapping = menuMappingService.selectOne(new EntityWrapper<MenuMapping>().eq("menu_id", sysMenu.getId()));
            if (menuMapping == null) {
                continue;
            }
            String tableName = menuMapping.getTableName();
            List<SysField> fieldByTable = fieldService.getFieldByTable(tableName);
            if (fieldByTable == null || fieldByTable.size() == 0) {
                continue;
            }
            parentIdSet.add(sysMenu.getId());
        }
        Set<String> byParentId = menuService.getByParentId(parentIdSet);
        List<SysMenu> parentList = menuService.selectBatchIds(byParentId);

        return Result.success(parentList) ;
    }



    @RequestMapping(value = "/allTheme", method = RequestMethod.GET)
    public Result<List<SysMenu>> getAllTheme() {
        EntityWrapper<SysMenu> sysMenuEntityWrapper = new EntityWrapper<>();
        sysMenuEntityWrapper.eq("menu_type",Constant.StructureMenu).orderBy("parent_id desc");
        return Result.success(menuService.selectList(sysMenuEntityWrapper)) ;
    }


    @RequestMapping(value = "/{pageno}", method = RequestMethod.GET)
    public Result<Page<SysMenu>> getAll(@PathVariable int pageno, HttpServletRequest request) {
        String pageSize = request.getParameter("pageSize");
        if (StringUtils.isEmpty(pageSize)) {
            pageSize = "15";
        }
        Integer size = Integer.valueOf(pageSize);
        Page page = new Page(pageno, size);
        Page<SysMenu> menuPage = menuService.selectPage(page);
        return Result.success(menuPage);
    }

    @RequestMapping(value = "/get/{id}",  method = RequestMethod.GET)
    public Result<SysMenu> get(@PathVariable String id) throws Exception {
        return Result.success(menuService.selectById(id));
    }
    @RequestMapping(value = "/add", method = RequestMethod.GET)
    public Result<Object> insert(@RequestParam  String name, HttpServletRequest request){
        String ordernoStr = request.getParameter("orderno");
        String parentId = request.getParameter("parentId");
        String dataType = request.getParameter("dataType");
        String menuType = request.getParameter("menuType");

        Integer orderno = null;
        if (StringUtils.isEmpty(ordernoStr)){
            orderno = Integer.valueOf("1");
            EntityWrapper<SysMenu> menuEntityWrapper = new EntityWrapper<>();
            menuEntityWrapper.setEntity(new SysMenu());
            if (StringUtils.isEmpty(parentId)) {
                menuEntityWrapper.isNull("parent_id");
            }else {
                menuEntityWrapper.where("parent_id = {0}", parentId);
            }
            menuEntityWrapper.orderBy("order_no desc");
            SysMenu sysMenu = menuService.selectOne(menuEntityWrapper);
            if (sysMenu != null) {
                Integer orderNo = sysMenu.getOrderNo();
                orderno = orderNo + 1;
            } else {
                orderno = 0;
            }
        }else {
            orderno = Integer.valueOf(ordernoStr);
        }
        SysMenu menu = new SysMenu();
        menu.setName(name);
        String uuid = DbUtils.getUUID();
        menu.setId(uuid);
        menu.setParentId(parentId);
        menu.setOrderNo(orderno);
        menu.setMenuType(menuType);
        boolean inserted = menuService.insert(menu);
        if (inserted) {
            return  Result.success("插入成功", null);
        } else {
            return Result.error(CodeMsg.INSERT_ERROR);
        }

    }

    @RequestMapping(value = "/add/version", method = RequestMethod.GET)
    public Result insertAll(@RequestParam String id, @RequestParam  String operateCode, HttpServletRequest request)  {
        SysMenu menu = menuService.selectById(id);

        if(operateCode.equalsIgnoreCase(Constant.addAll) && menu != null) {
            return Result.error(CodeMsg.SELECT_ERROR);
        }
        else if (operateCode.equalsIgnoreCase(Constant.addAll) && menu == null)   {
            String ordernoStr = request.getParameter("orderNo");
            String parentId = request.getParameter("parentId");
            String menuType = request.getParameter("menuType");
            String name = request.getParameter("name");
            int orderno;
            if (StringUtils.isEmpty(ordernoStr)){
                orderno = Integer.valueOf("1");
                EntityWrapper<SysMenu> menuEntityWrapper = new EntityWrapper<>();
                menuEntityWrapper.setEntity(new SysMenu());
                if (StringUtils.isEmpty(parentId)) {
                    menuEntityWrapper.isNull("parent_id");
                }else {
                    menuEntityWrapper.where("parent_id = {0}", parentId);
                }
                menuEntityWrapper.orderBy("order_no desc");
                SysMenu sysMenu = menuService.selectOne(menuEntityWrapper);
                if (sysMenu != null) {
                    Integer orderNo = sysMenu.getOrderNo();
                    orderno = orderNo + 1;
                } else {
                    orderno = 0;
                }
            }else {
                orderno = Integer.valueOf(ordernoStr);
            }
            menu = new SysMenu().setId(id).setParentId(parentId).setMenuType(menuType).setName(name).setOrderNo(orderno);
            menu.insert();
        }

//        if (menu.getMenuType().equalsIgnoreCase(Constant.DataMenu)) {
//            Result<List<SysMenu>> listResult = menuByParentId(id);
//            List<SysMenu> data = listResult.getData();
//            long count = data.stream().filter(sysMenu -> sysMenu.getDataType().equals(MaintainDataType.unkonwn)).count();
//            if (count != data.size()) {
//                return Result.error(CodeMsg.SELECT_ERROR);
//            }
//        }

        return Result.success(CodeMsg.SUCCESS);
    }

    @RequestMapping(value = "/update", method = RequestMethod.GET)
    public Result<Object> update(@RequestParam  String id, HttpServletRequest request) {
        SysMenu menu = menuService.selectById(id);
        if (menu == null) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        String ordernoStr = request.getParameter("orderNo");
        String parentId = request.getParameter("parentId");
        String menuType = request.getParameter("menuType");
        String name = request.getParameter("name");

        if (!StringUtils.isEmpty(ordernoStr)){
            int orderno = Integer.valueOf(ordernoStr);
            menu.setOrderNo(orderno);
        }

        menu.setName(name);
        menu.setParentId(parentId);
        menu.setMenuType(menuType);

        boolean updated = menuService.updateById(menu);
        if (updated) {
            return  Result.success("更新成功", null);
        } else {
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }
    private HashSet<SysMenu> deleteMenuByParentId(List<SysMenu> data, String parentId) {
        HashSet<SysMenu> resultSet = new HashSet<>();
        for (SysMenu menu : data) {
            String menuParentId = menu.getParentId();
            if (StringUtils.isEmpty(menuParentId)) {
                continue;
            }
            if (menuParentId.equalsIgnoreCase(parentId)) {
                resultSet.add(menu);
            }
        }
        HashSet<SysMenu> result = new HashSet<>();
        for (SysMenu sysMenu : resultSet) {
            result.addAll(deleteMenuByParentId(data, sysMenu.getId()));
        }
        result.addAll(resultSet);
        return result;
    }
    @RequestMapping(value = "/delete/{menuid}", method = RequestMethod.GET)
    public Result<Object> delete(@PathVariable String menuid) throws Exception {
        Result<List<SysMenu>> all = getAll();
        List<SysMenu> data = all.getData();
        HashSet<SysMenu> sysMenus = deleteMenuByParentId(data, menuid);

        for (SysMenu sysMenu : sysMenus) {
            List<MenuMapping> menuMappingList = menuMappingService.selectList(new EntityWrapper<MenuMapping>().eq("menu_id", sysMenu.getId()));
            for (MenuMapping menuMapping : menuMappingList) {
                //todo 添加待删除表的日志
                DeletedTableLog deletedTableLog = new DeletedTableLog();
                deletedTableLog.setId(DbUtils.getUUID()).setTableName(menuMapping.getTableName()).setCreateTime(new Date());
                deletedTableLog.insert();
                menuMapping.deleteById();
            }
            sysMenu.deleteById();
        }
        boolean delete = menuService.deleteById(menuid);
        if (delete) {
            return Result.success(null);
        } else {
            return Result.error(CodeMsg.DELETE_ERROR);
        }

    }

    @RequestMapping(value = "/byParent/{parentid}/{pageno}", method = RequestMethod.GET)
    public Result<Page<SysMenu>> menuByParentIdPage(@PathVariable String parentid, @PathVariable int pageno, HttpServletRequest request) throws Exception {
        String pageSize = request.getParameter("pageSize");
        if (StringUtils.isEmpty(pageSize)) {
            pageSize = "15";
        }
        Integer size = Integer.valueOf(pageSize);
        Page<SysMenu> page = new Page(pageno, size);
        EntityWrapper<SysMenu> menuEntityWrapper = new EntityWrapper<>();
        menuEntityWrapper.setEntity(new SysMenu());
        menuEntityWrapper.where("parentid = {0}", parentid);
        Page<SysMenu> menuPage = menuService.selectPage(page, menuEntityWrapper);
        return Result.success(menuPage);
    }

    @RequestMapping(value = "/byParent/{parentid}", method = RequestMethod.GET)
    public Result<List<SysMenu>> menuByParentId(@PathVariable String parentid) {
        EntityWrapper<SysMenu> menuEntityWrapper = new EntityWrapper<>();
        menuEntityWrapper.setEntity(new SysMenu());
        menuEntityWrapper.where("parent_id = {0}", parentid);
        List<SysMenu> sysMenus = menuService.selectList(menuEntityWrapper);
        return Result.success(sysMenus);
    }


}