package com.highdatas.mdm.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.google.gson.JsonObject;
import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.SysField;
import com.highdatas.mdm.entity.TUser;
import com.highdatas.mdm.entity.TableSchemaResult;
import com.highdatas.mdm.mapper.MaintainFieldMapper;
import com.highdatas.mdm.mapper.MasterModifiedMapper;
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.pojo.ActivitiStatus;
import com.highdatas.mdm.pojo.Segment;
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.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author kimi
 * @since 2020-03-11
 */
@Service
public class MasterModifiedServiceImpl implements IMasterModifiedService {
    @Autowired
    IMaintainService maintainService;
    @Autowired
    ISysFieldService fieldService;
    @Autowired
    MasterModifiedMapper masterModifiedMapper;
    @Autowired
    TableInfoMapper tableInfoMapper;
    @Autowired
    IMaintainFieldService maintainFieldService;
    @Autowired
    ITUserService userService;
    @Autowired
    MaintainFieldMapper maintainFieldMapper;
    @Autowired
    MasterDataService masterDataService;

    public static final String master_id = "master_id";
    public static final String pre_record = "pre_record";
    public static final String table_name = "table_name";
    public static final String master_modified = "master_modified";

    @Override
    public Map<String, String> getModifiedUserById(String maintainId, String masterId) {
        return null;
    }

    @Override
    public List<Map<String, String>> getModifiedUserByIds(String maintainId, List<String> masterId) {
        return null;
    }

    @Override
    public boolean updateModifiedUserById(String maintainId, String masterId, String userId, List<String> modifiedFieldList) {
        if (StringUtils.isEmpty(maintainId)) {
            return false;
        }
        try {
            Maintain nowMaintain = maintainService.selectById(maintainId);
            List<SysField> fieldByMaintain = fieldService.getFieldByMaintain(maintainId);
            if (nowMaintain == null) {
                return false;
            }
            Map<String, String> masterModifiedMap = masterModifiedMapper.selectByTableMasterId(DbUtils.quotedStr(nowMaintain.getTableName()), DbUtils.quotedStr(masterId));
            if (masterModifiedMap == null) {
                masterModifiedMap = new HashMap<>();
                masterModifiedMap.put(table_name, nowMaintain.getTableName());
                masterModifiedMap.put(master_id, masterId);
            }
            String preRecordStr = masterModifiedMap.get(pre_record);
            JSONObject preRecordJSON = null;
            if (!StringUtils.isEmpty(preRecordStr)) {
                preRecordJSON = JSONObject.parseObject(preRecordStr);
            }else  {
                preRecordJSON = new JSONObject();
            }
            for (String field : modifiedFieldList) {
                preRecordJSON.fluentPut(field, userId);
            }
            masterModifiedMap.put(pre_record,  preRecordJSON.toJSONString());
            String id = masterModifiedMap.get(Constant.ID);
            if (StringUtils.isEmpty(id)) {
                masterModifiedMap.put(Constant.ID, DbUtils.getUUID());
                insert(masterModifiedMap);
            }else {
                updateById(masterModifiedMap);
            }
            return true;
        }
        catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    private void insert(Map<String, String> masterModifiedMap) {
        String fields = masterModifiedMap.keySet().stream().collect(Collectors.joining(Constant.COMMA));
        String values = masterModifiedMap.values().stream().map(s -> DbUtils.quotedStr(s)).collect(Collectors.joining(Constant.COMMA));
        tableInfoMapper.insert(master_modified, fields, DbUtils.bracketStr(values));
    }

    private void updateById(Map<String, String> masterModifiedMap) {
        String id = masterModifiedMap.get(Constant.ID);
        Segment whereSegment = new Segment(Constant.ID, id);
        List<Segment> updateSgement = DbUtils.map2Segment(masterModifiedMap);
        String updateStr = updateSgement.stream().map(segment -> segment.toString()).collect(Collectors.joining(Constant.COMMA));
        tableInfoMapper.update(master_modified, updateStr, whereSegment.toString());
    }

    @Override
    @Async
    public void dealFlow(String maintainId, ActivitiStatus status) {
        Maintain maintain = maintainService.selectById(maintainId);
        String tableName = maintain.getTableName();
        String recordTableName = tableName + Constant.RECORD;
        List<Map<String,String>> modifiedList = masterModifiedMapper.selectByMaintainId(recordTableName, DbUtils.quotedStr(maintainId));
        switch (status) {
            case open:
                for (Map<String, String> masterModifiedMap : modifiedList) {
                    String preJson = masterModifiedMap.get(pre_record);
                    JSONObject jsonObject = JSONObject.parseObject(preJson);
                    if (jsonObject == null){
                        continue;
                    }
                    Set<String> keySet = jsonObject.keySet();
                    HashMap<String, String> userMap = new HashMap<>();
                    for (String field : keySet) {
                        String userId = jsonObject.getString(field);
                        if (userMap.containsKey(userId)) {
                            String preFieldStr = userMap.get(userId);
                            field = preFieldStr + Constant.SEMICOLON  + field;
                        }
                        userMap.put(userId, field);
                    }
                    List<TableSchemaResult> tableField = tableInfoMapper.getTableField(master_modified);
                    List<String> existsFieldList = tableField.stream().map(TableSchemaResult::getFieldName).collect(Collectors.toList());
                    Set<String> userIdList = userMap.keySet();

                    if (!existsFieldList.containsAll(userIdList)) {
                        //新增之前不存在的用户
                        List<String> unExistsUserList = userIdList.stream().filter(s -> !existsFieldList.contains(s)).collect(Collectors.toList());
                        for (String s : unExistsUserList) {
                            //新增字段
                            maintainFieldMapper.addCloumn(master_modified, s, Constant.Text);
                        }
                    }
                    masterModifiedMap.putAll(userMap);
                    updateById(masterModifiedMap);
                }
                break;
            case close:
                List<String> unUserIdList = new ArrayList<>();
                unUserIdList.add(Constant.ID);
                unUserIdList.add(master_id);
                unUserIdList.add(table_name);
                unUserIdList.add(pre_record);
                for (Map<String, String> masterModifiedMap : modifiedList) {
                    //todo   反更新 perjson  获取当前表所有可更改的用户 之后待修改 先从本地user表中拿
                    Set<String> keySet = masterModifiedMap.keySet();
                    List<String> userIdList = keySet.stream().filter(s -> !unUserIdList.contains(s)).collect(Collectors.toList());
                    JSONObject jsonObject = new JSONObject();
                    for (String s : userIdList) {
                        String fields = masterModifiedMap.get(s);
                        if (StringUtils.isEmpty(fields)) {
                            continue;
                        }
                        String[] split = fields.split(Constant.SEMICOLON);
                        for (String field : split) {
                            jsonObject.fluentPut(field, s);
                        }
                    }
                    masterModifiedMap.put(pre_record, jsonObject.toJSONString());
                    updateById(masterModifiedMap);
                }
                break;
        }
    }

    @Override
    public void dealAssemble(String maintainId, String userId, boolean audit) {
        List<SysField> fieldByMaintain = fieldService.getFieldByMaintain(maintainId);
        String fieldStr = fieldByMaintain.stream().map(SysField::getField).collect(Collectors.joining(Constant.SEMICOLON));
        List<TableSchemaResult> tableField = tableInfoMapper.getTableField(master_modified);
        long count = tableField.stream().map(tableSchemaResult -> tableSchemaResult.getFieldName()).filter(s -> s.equalsIgnoreCase(userId)).count();
        if (count == 0) {
            maintainFieldMapper.addCloumn(master_modified, userId, Constant.Text);
        }

        Maintain maintain = maintainService.selectById(maintainId);
        String tableName = maintain.getTableName();
        String recordTableName = tableName + Constant.RECORD;
        if (!audit) {
            masterModifiedMapper.insertUserByTableNameUserId(DbUtils.quotedStr(maintainId), DbUtils.quotedStr(tableName), recordTableName, userId, DbUtils.quotedStr(fieldStr));
        }
       else {
            JSONObject jsonObject = new JSONObject();
            for (SysField field : fieldByMaintain) {
                String oneField = field.getField();
                jsonObject.fluentPut(oneField, userId);
            }

            masterModifiedMapper.insertJsonByTableNameUserId(DbUtils.quotedStr(maintainId), DbUtils.quotedStr(tableName), recordTableName, DbUtils.quotedStr(jsonObject.toJSONString()));
        }
    }

}