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.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.MenuMapping;
import com.highdatas.mdm.entity.SysMenu;
import com.highdatas.mdm.entity.TUser;
import com.highdatas.mdm.mapper.MenuMappingMapper;
import com.highdatas.mdm.mapper.TableInfoMapper;
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 com.highdatas.mdm.util.WorkflowUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpSession;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.Map;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author kimi
 * @since 2019-12-16
 */
@Service
public class MenuMappingServiceImpl extends ServiceImpl<MenuMappingMapper, MenuMapping> implements IMenuMappingService {
    @Autowired
    TableInfoMapper tableInfoMapper;

    @Autowired
    MenuMappingMapper menuMappingMapper;

    @Autowired
    IMaintainService maintainService;

    @Autowired
    ActivitiService activitiService;

    @Autowired
    ISysMenuService menuService;
    @Autowired
    IMaintainFieldService maintainFieldService;
    @Autowired
    IMasterAuthorService masterAuthorService;

    public static final String key = "process";

    @Override
    public MenuMapping create(String json, HttpSession session) {
        JSONObject jsonObject = JSONObject.parseObject(json);
//        //1
//        Flows flows = activitiService.start(key, session);
//        if (flows == null) {
//            return false;
//        }
//        //2
//        String flowsId = flows.getId();
        TUser user = (TUser)session.getAttribute(Constant.USER);
        String userId = user.getUserId();
        //Maintain maintain = createMaintain(userId, jsonObject, null);
        /*if (maintain == null) {
            return false;
        }*/
        //String maintainId = maintain.getId();
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        MenuMapping menuMapping = null;
        try {
            menuMapping = objectMapper.readValue(json, MenuMapping.class);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return null;
        }
        String menuId = menuMapping.getMenuId();
        if (StringUtils.isEmpty(menuId)) {
            return null;
        }
        int cnt = selectCount(new EntityWrapper<MenuMapping>().eq("menu_id", menuId));
        if (cnt != 0)  {
            return null;
        }
        //menuMapping.setMaintainFieldId(maintainId);
        return  create(menuMapping);
    }

    private Maintain createMaintain(String userId, JSONObject jsonObject, String flowsId) {
        Maintain maintain = new Maintain();
        maintain.setCreateTime(new Date());

        maintain.setChargeId(userId);
//        maintain.setFlowId(flowsId);
        maintain.setVersion(Constant.VERSION_Default);
        maintain.setId(DbUtils.getUUID());
        String desp = jsonObject.getString("desp");
        String tableName = jsonObject.getString("tableName");
        if(StringUtils.isEmpty(tableName)) {
            return null;
        }
        maintain.setDesp(desp);
        maintain.setTableName(tableName);
        boolean insert = maintainService.insert(maintain);
        if (insert) {
            return maintain;
        }
        return null;
    }
    @Override
    public MenuMapping create(MenuMapping menuMapping) {
        menuMapping.setCreateTime(new Date());
        menuMapping.setId(DbUtils.getUUID());
        String name = menuMapping.getName();
        name = DbUtils.getChineseOrEnglishOrNumber(name);
        String tableName = WorkflowUtils.toFirstChar(name.toLowerCase());
        tableName = Constant.MD + tableName;
        String tableByName = tableInfoMapper.selectTableByName(tableName);

        if (!StringUtils.isEmpty(tableByName)){
            int sameCount = selectCount(new EntityWrapper<MenuMapping>().eq("table_name", tableName));
            if (sameCount > 0) {
                tableName =  tableName + "_" +  DbUtils.getUUID(5);
            }
        }
        int length = 0;
        try {
            length = tableName.getBytes("UTF-8").length;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        if (length > 18) {
            tableName = Constant.MD + DbUtils.getUUID(10);
        }
        menuMapping.setTableName(tableName);
        boolean insert = this.insert(menuMapping);
        if (insert) {
            return menuMapping;
        } else {
            return null;
        }
    }

    @Override
    public boolean update(String json) {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        MenuMapping menuMapping = null;
        try {
            menuMapping = objectMapper.readValue(json, MenuMapping.class);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return false;
        }

        //update menu name
        String menuId = menuMapping.getMenuId();
        SysMenu sysMenu = menuService.selectById(menuId);
        if (sysMenu == null) {
            return false;
        }
        sysMenu.setName(menuMapping.getName());
        sysMenu.updateById();

        return this.updateById(menuMapping);
    }

    @Override
    public Result getMapping(HttpSession session, String id) {
        SysMenu sysMenu = menuService.selectById(id);
        if (sysMenu == null) {
            return Result.error(CodeMsg.SELECT_ERROR);
        }
        String menuType = sysMenu.getMenuType();
        if (StringUtils.isEmpty(menuType)) {
            return Result.error(CodeMsg.SELECT_ERROR);
        }

        if (menuType.equalsIgnoreCase("StructureMenu")) {
            return Result.success(null);
        }

        Map mapping = menuMappingMapper.getMapping(id);

        Wrapper<MenuMapping> menuWrapper = new EntityWrapper<MenuMapping>().eq("menu_id", sysMenu.getId());
        MenuMapping menuMapping = selectOne(menuWrapper);
        if (menuMapping == null) {
            return Result.error(new CodeMsg(10008,"当前主题无版本数据"));
        }
        String tableName = menuMapping.getTableName();
        String chargeId = menuMapping.getChargeId();
        TUser userByChargeId = DbUtils.getUserById(chargeId);

        TUser user = (TUser) session.getAttribute(Constant.USER);

        Maintain resultMaintain = masterAuthorService.getMaxVersionMaintain(user, tableName);
        Maintain nowVersion = maintainService.getNowVersion(tableName);

        if (resultMaintain != null) {
            if (nowVersion.getOrderNo().equals(resultMaintain.getOrderNo())) {
                mapping.put("maintainType", 0);
            }else {
                mapping.put("maintainType", 1);
            }
            mapping.put("version", resultMaintain.getVersion());
            mapping.put("maintainId", resultMaintain.getId());
        }
        if (userByChargeId != null) {
            mapping.put("userName", userByChargeId.getUserName());
        }
        if (nowVersion != null) {
            mapping.put("hasData", true);
        }else {
            mapping.put("hasData", false);
        }
        return Result.success(mapping);

    }

    @Override
    public SysMenu getMenuByTableName(String tableName) {
        MenuMapping menuMapping = selectOne(new EntityWrapper<MenuMapping>().eq("table_name", tableName).orderBy("create_time desc"));
        if (menuMapping == null) {
            return null;
        }
        String menuId = menuMapping.getMenuId();
        SysMenu sysMenu = menuService.selectById(menuId);
        return sysMenu;
    }

    @Override
    public MenuMapping getMenuMappingByTableName(String tableName) {
        MenuMapping menuMapping = selectOne(new EntityWrapper<MenuMapping>().eq("table_name", tableName).orderBy("create_time desc"));
        if (menuMapping == null) {
            return null;
        }
        return menuMapping;
    }



    @Override
    public String getTableNameByMenu(String menuId) {
        MenuMapping menuMapping = selectOne(new EntityWrapper<MenuMapping>().eq("menu_id", menuId).orderBy("create_time desc"));
        if (menuMapping == null) {
            return null;
        }
        return menuMapping.getTableName();

    }
}