package com.highdatas.mdm.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.highdatas.mdm.entity.Flows;
import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.MaintainField;
import com.highdatas.mdm.entity.SysField;
import com.highdatas.mdm.mapper.MaintainFieldMapper;
import com.highdatas.mdm.mapper.SysFieldMapper;
import com.highdatas.mdm.pojo.ActivitiStatus;
import com.highdatas.mdm.pojo.Operate;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.service.IFlowsService;
import com.highdatas.mdm.service.IMaintainFieldService;
import com.highdatas.mdm.service.IMaintainService;
import com.highdatas.mdm.service.ISysFieldService;
import com.highdatas.mdm.util.DbUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author kimi
 * @since 2019-12-18
 */
@Service
public class SysFieldServiceImpl extends ServiceImpl<SysFieldMapper, SysField> implements ISysFieldService {
    @Autowired
    IMaintainService maintainService;
    @Autowired
    SysFieldMapper fieldMapper;
    @Autowired
    IMaintainFieldService maintainFieldService;
    @Autowired
    MaintainFieldMapper maintainFieldMapper;
    @Autowired
    IFlowsService flowsService;


    @Override
    public List<SysField> getFieldByMaintain(String maintainId) {
        MaintainField maintainField;
        List<SysField> fieldList = null;

        if (StringUtils.isEmpty(maintainId)) {
          return null;
        }
        Maintain maintain = maintainService.selectById(maintainId);
        if (maintain == null) {
            return null;
        }

        maintainField = maintainFieldService.selectOne(new EntityWrapper<MaintainField>().eq("maintain_id", maintainId).orderBy("order_no desc"));
        if (maintainField == null) {
            //对应版本找不到 往前找
            String maintainFieldId = maintainFieldMapper.getMappedMatintainId(DbUtils.quotedStr(maintain.getTableName()), maintain.getOrderNo());
            if (StringUtils.isEmpty(maintainFieldId)) {
                fieldList = this.selectList(new EntityWrapper<SysField>().eq("table_name", maintain.getTableName()).isNull("maintain_field_id").orderBy("order_no"));
                return fieldList;
            }
            maintainField = maintainFieldService.selectById(maintainFieldId);
            if (maintainField == null){
                //无对应版本
                fieldList = this.selectList(new EntityWrapper<SysField>().eq("table_name", maintain.getTableName()).isNull("maintain_field_id").orderBy("order_no"));
                return fieldList;
            }
        }

        String maintainFieldId = maintainField.getId();
        String tableName = maintainField.getTableName();
        //TODO  判断版本
        ActivitiStatus status = flowsService.getStatusByBusinessId(maintainFieldId);
        if (status != null && status.equals(ActivitiStatus.open)) {
            fieldList = this.selectList(new EntityWrapper<SysField>().eq("maintain_field_id", maintainFieldId).eq("table_name", tableName).orderBy("order_no"));
            if (fieldList.size() != 0) {
                return fieldList;
            }
        }

        // 当前版本正在审批  找前一版本
        Integer maintainFieldOrderNo = maintainField.getOrderNo();
        if (maintainFieldOrderNo < 1) {
            fieldList = this.selectList(new EntityWrapper<SysField>().eq("table_name", maintain.getTableName()).isNull("maintain_field_id").orderBy("order_no"));
            return fieldList;
        }else {
            Integer preNo = maintainFieldOrderNo--;
            maintainField = maintainFieldService.selectOne(new EntityWrapper<MaintainField>().eq("table_name", maintain.getTableName()).eq("order_no", preNo));
            fieldList = this.selectList(new EntityWrapper<SysField>().eq("maintain_field_id", maintainFieldId).eq("table_name", tableName).orderBy("order_no"));
            return fieldList;
        }


    }

    @Override
    public List<SysField> getFieldByTable(String tableName) {
        Maintain nowVersion = maintainService.getNowVersion(tableName);
        if (nowVersion == null) {
            return null;
        }
        return getFieldByMaintain(nowVersion.getId());
    }

    @Override
    public Result getTotalFields(String tableName) {
        JSONObject result = new JSONObject();

        MaintainField maxVersion = maintainFieldService.getMaxVersion(tableName);
        MaintainField nowVersion = maintainFieldService.getNowVersion(tableName);
        if (nowVersion == null && maxVersion == null) {
            result.fluentPut("list", getFieldByTable(tableName));
            result.fluentPut("aduit", false);
            result.fluentPut("flowStatus", null);
            result.fluentPut("maintainFieldId", null);
            return Result.success(result);
        }else if (nowVersion == null){
            List<SysField> maxFieldList = getFieldByMaintainField(maxVersion.getId());
            List<SysField> createdFieldList = getFieldByTable(tableName);
            result.fluentPut("list", packageFieldList(createdFieldList, maxFieldList));
            result.fluentPut("aduit", true);
            result.fluentPut("flowStatus", null);
            result.fluentPut("maintainFieldId", maxVersion.getId());
            String flowId = maxVersion.getFlowId();
            Flows flows = flowsService.selectById(flowId);
            if (flows != null) {
                ActivitiStatus status = flows.getStatus();
                if (!status.equals(ActivitiStatus.open) || !status.equals(ActivitiStatus.close)) {
                    result.fluentPut("aduit", false);
                }
                result.fluentPut("flowStatus", status);
            }
            return Result.success(result);
        }

        if (maxVersion.getOrderNo().equals(nowVersion.getOrderNo())) {
            // 未存在

            result.fluentPut("list", getFieldByMaintainField(nowVersion.getId()));
            result.fluentPut("aduit", false);
            result.fluentPut("flowStatus", null);
            result.fluentPut("maintainFieldId", nowVersion.getId());
            return Result.success(result);
        }
        List<SysField> nowFields = getFieldByMaintainField(nowVersion.getId());
        List<SysField> maxFields = getFieldByMaintainField(maxVersion.getId());
        nowFields = packageFieldList(nowFields, maxFields);
        result.fluentPut("list", nowFields);
        result.fluentPut("aduit", true);
        result.fluentPut("flowStatus", null);
        result.fluentPut("maintainFieldId", maxVersion.getId());
        String flowId = maxVersion.getFlowId();
        Flows flows = flowsService.selectById(flowId);
        if (flows != null) {
            ActivitiStatus status = flows.getStatus();
            if (!status.equals(ActivitiStatus.open) || !status.equals(ActivitiStatus.close)) {
                result.fluentPut("aduit", false);
            }
            result.fluentPut("flowStatus", status);
        }

        return Result.success(result);
    }

    private List<SysField> packageFieldList(List<SysField> nowFields, List<SysField> maxFields) {
        //原始的清除operate用于前端显示
        nowFields =  nowFields.stream().map(sysField -> sysField.setOperate(null)).collect(Collectors.toList());
        for (SysField maxField : maxFields) {
            String field = maxField.getField();
            Operate operate = maxField.getOperate();
            if (operate == null) {
                continue;
            }
            if (operate.equals(Operate.update) || operate.equals(Operate.delete)) {
                nowFields = nowFields.stream().filter(sysField -> !sysField.getField().equalsIgnoreCase(field)).collect(Collectors.toList());
                nowFields.add(maxField);
            }
            else if (operate.equals(Operate.create)) {
                nowFields.add(maxField);
            }

        }
        Collections.sort(nowFields, new Comparator<SysField>() {
            @Override
            public int compare(SysField o1, SysField o2) {
                return o1.getOrderNo() - o2.getOrderNo() ;
            }
        });
        return nowFields;
    }

    @Override
    public boolean updateCommon(SysField preField, SysField updateField) {
        preField.setWidth(updateField.getWidth());
        preField.setDesp(updateField.getDesp());
        preField.setAlign(updateField.getAlign());
        String maintainId = preField.getMaintainFieldId();
        String maintainParams;
        if (StringUtils.isEmpty(maintainId)) {
            //初始状态
            String tableName = preField.getTableName();
            maintainParams = "maintain_field_id is null and table_name = " + DbUtils.quotedStr(tableName);
        }else {
            maintainParams = "maintain_field_id = " + DbUtils.quotedStr(maintainId);
        }
        Integer updateSize = null;
        Integer preOrderNo = preField.getOrderNo();
        Integer orderNo = updateField.getOrderNo();
        if (orderNo == preOrderNo) {
            return preField.updateById();
        }
//        else if (preOrderNo > orderNo) {
//            //往前调
//            updateSize = fieldMapper.updateOrderNoFront(maintainParams,orderNo, preOrderNo);
//        }else {
//            updateSize = fieldMapper.updateOrderNoBack(maintainParams,orderNo, preOrderNo);
//        }
        if (preField.getOperate() != null) {
            preField.setOperate(updateField.getOperate());
        }
        preField.setOrderNo(updateField.getOrderNo());
        return preField.updateById();
    }

    @Override
    public SysField getOneFieldByMaintainField(String maintainFieldId, String field) {
        List<SysField> fieldByMaintain = getFieldByMaintainField(maintainFieldId);
        List<SysField> collect = fieldByMaintain.stream().filter(sysField -> sysField.getField().equalsIgnoreCase(field)).collect(Collectors.toList());
        if (collect.isEmpty()) {
            return null;
        }
        return collect.get(0);
    }
    @Override
    public List<SysField> getFieldByMaintainField(String maintainId) {
        if (StringUtils.isEmpty(maintainId)) {
            return selectList(new EntityWrapper<SysField>().isNull("maintain_field_id").orderBy("order_no"));
        }
        return selectList(new EntityWrapper<SysField>().eq("maintain_field_id", maintainId).orderBy("order_no"));
    }

}