package com.highdatas.mdm.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
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.pojo.ActivitiStatus;
import com.highdatas.mdm.pojo.Operate;
import com.highdatas.mdm.service.IFlowsService;
import com.highdatas.mdm.service.IMaintainFieldService;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.highdatas.mdm.service.IMaintainService;
import com.highdatas.mdm.service.ISysFieldService;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.DbUtils;
import org.apache.commons.lang3.StringUtils;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.MessageFormat;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author kimi
 * @since 2020-03-06
 */
@Service
public class MaintainFieldServiceImpl extends ServiceImpl<MaintainFieldMapper, MaintainField> implements IMaintainFieldService {
    @Autowired
    IMaintainService maintainService;
    @Autowired
    IFlowsService flowsService;
    @Autowired
    ISysFieldService fieldService;

    @Autowired
    MaintainFieldMapper maintainFieldMapper;

    @Override
    public MaintainField getNextMaintain(String tableName, String userId) {
        MaintainField maintain = this.getMaxVersion(tableName);
        Maintain nowVersion = maintainService.getNowVersion(tableName);
        if (nowVersion == null) {
            return null;
        }
        if (maintain == null){
            MaintainField maintainField = new MaintainField().setId(DbUtils.getUUID()).setVersion(Constant.VERSION_Default).setCreateTime(new Date()).setChargeId(userId).setOrderNo(0).setTableName(tableName);
            maintainField.setMaintainId(nowVersion.getId());
            return maintainField;
        }
        MaintainField unFlowMaxVersion = this.getUnFlowMaxVersion(tableName);
        if (unFlowMaxVersion == null) {
            unFlowMaxVersion = new MaintainField();
            if (maintain != null) {
                unFlowMaxVersion.setVersion(DbUtils.versionAddSub(maintain.getVersion()));
                int orderNo = maintain.getOrderNo();
                orderNo++;
                unFlowMaxVersion.setOrderNo(orderNo);
            } else {
                unFlowMaxVersion.setVersion(Constant.VERSION_Default);
                unFlowMaxVersion.setOrderNo(0);
            }

            unFlowMaxVersion.setId(DbUtils.getUUID());
            unFlowMaxVersion.setChargeId(userId);
            unFlowMaxVersion.setCreateTime(new Date());
            unFlowMaxVersion.setTableName(tableName);
        }

        MaintainField nowMaintain = unFlowMaxVersion;
        if (DbUtils.compareVersion(maintain, unFlowMaxVersion) != 0) {
            nowMaintain = new MaintainField();
            String maintanId = DbUtils.getUUID();
            nowMaintain.setId(maintanId);
            nowMaintain.setCreateTime(new Date());
            int orderNo = maintain.getOrderNo();
            orderNo++;
            nowMaintain.setVersion(DbUtils.versionAddSub(maintain.getVersion()));
            nowMaintain.setOrderNo(orderNo);
            nowMaintain.setTableName(tableName);
        }

        if (nowVersion!= null){
            nowMaintain.setMaintainId(nowVersion.getId());
        }

        nowMaintain.setChargeId(userId);
        String maintainId = nowMaintain.getId();
        if(StringUtils.isEmpty(maintainId)) {
            nowMaintain.setId(DbUtils.getUUID());
        }
        return nowMaintain;
    }

    @Override
    public boolean checkNowVersion(String maintainFieldId) {
        MaintainField maintain = selectById(maintainFieldId);
        MaintainField maxVersion = getNowVersion(maintain.getTableName());
        Integer compared = DbUtils.compareVersion(maxVersion, maintain);
        if (compared != null && compared == 0) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public boolean checkFirstVersion(String id) {
        MaintainField maintain = selectById(id);
        MaintainField order_no = selectOne(new EntityWrapper<MaintainField>().eq("table_name", maintain.getTableName()).orderBy("order_no"));
        if (maintain.getId().equalsIgnoreCase(order_no.getId())) {
            return true;
        }
        return false;
    }

    @Override
    public boolean checkdMaxVersion(String maintainFieldId) {
        MaintainField maintain = selectById(maintainFieldId);
        MaintainField maxVersion = getMaxVersion(maintain.getTableName());
        Integer compared = DbUtils.compareVersion(maxVersion, maintain);
        if (compared == 0) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public MaintainField getMaxVersion(String tableName) {
        Wrapper<MaintainField> versionWrapper = new EntityWrapper<MaintainField>().eq("table_name", tableName).orderBy("order_no desc");

        MaintainField maxVersion = this.selectOne(versionWrapper);
        return maxVersion;
    }

    @Override
    public MaintainField getUnFlowMaxVersion(String tableName) {
        Wrapper<MaintainField> versionWrapper = new EntityWrapper<MaintainField>().isNull("flow_id").eq("table_name", tableName).orderBy("order_no desc");

        MaintainField maxVersion = selectOne(versionWrapper);
        return maxVersion;
    }

    @Override
    public MaintainField getNowVersion(String tableName) {
        Wrapper<MaintainField> versionWrapper = new EntityWrapper<MaintainField>().eq("table_name", tableName).isNotNull("flow_id").orderBy("order_no desc");

        List<MaintainField> maintains = selectList(versionWrapper);
        for (MaintainField maintain : maintains) {
            Flows flows = flowsService.selectById(maintain.getFlowId());
            if (flows == null){
                continue;
            }
            ActivitiStatus status = flows.getStatus();
            if (status.equals(ActivitiStatus.open)) {
                return maintain;
            }
        }
        return null;
    }

    @Override
    public MaintainField getMaintainFromVersion(String tableName, String verison) {
        Wrapper<MaintainField> versionWrapper = new EntityWrapper<MaintainField>().eq("version", verison).eq("table_name", tableName);
        MaintainField maxVersion = selectOne(versionWrapper);
        return maxVersion;
    }

    @Override
    public void dealFlow(String maintainId, ActivitiStatus status) {
        MaintainField maintainField = selectById(maintainId);
        if (status.equals(ActivitiStatus.close)) {
            //delete maintain
            fieldService.delete(new EntityWrapper<SysField>().eq("maintain_field_id", maintainField.getId()));
            maintainField.deleteById();
        }
        else if (status.equals(ActivitiStatus.open)) {
            List<SysField> fieldList = fieldService.selectList(new EntityWrapper<SysField>().eq("maintain_field_id", maintainField.getId()));

            List<SysField> collect = fieldList.stream().filter(sysField -> Operate.delete.equals(sysField.getOperate())).collect(Collectors.toList());
            //delete
            for (SysField field : collect) {
                field.deleteById();
            }
            //update
            List<SysField> updateList = fieldList.stream().filter(sysField -> (Operate.update.equals(sysField.getOperate()))).collect(Collectors.toList());
            for (SysField field : updateList) {
                field.setOperate(null).updateById();
            }
            List<SysField> createList = fieldList.stream().filter(sysField -> (Operate.create.equals(sysField.getOperate()))).collect(Collectors.toList());
            for (SysField field : createList) {
                String fieldType = field.getFieldType();
                if (StringUtils.isEmpty(fieldType)) {
                    fieldType = Constant.varchar;
                }
                String fieldTypeStr;
                if (fieldType.equalsIgnoreCase(Constant.varchar)) {
                    fieldTypeStr = DbUtils.StrJoin(fieldType, Constant.varcharSize);
                }else {
                    fieldTypeStr = fieldType;
                }
                String tableName = field.getTableName();
                String tempTableName = Constant.Temp + tableName;
                String recordTableName =  tableName + Constant.RECORD;


                maintainFieldMapper.addCloumn(tempTableName, field.getField(), fieldTypeStr);
                maintainFieldMapper.addCloumn(recordTableName, field.getField(), fieldTypeStr);
                maintainFieldMapper.addCloumn(tableName, field.getField(), fieldTypeStr);

                field.setOperate(null).updateById();
            }
        }
    }

    @Override
    public int getUnFlowCount(String tableName, String userId) {
        List<MaintainField> maintainFields = selectList(new EntityWrapper<MaintainField>().eq("table_name", tableName));
        List<String> flowIdList = maintainFields.stream().filter(maintainField -> maintainField.getFlowId() != null).map(MaintainField::getFlowId).collect(Collectors.toList());
        if (flowIdList.size() == 0) {
            return 0;
        }
        List<Flows> flowsList = flowsService.selectBatchIds(flowIdList);
        List<Flows> unFlowedList = flowsList.stream().filter(flows -> flows.getStatus().equals(ActivitiStatus.working) || flows.getStatus().equals(ActivitiStatus.refuse)).collect(Collectors.toList());
        int cnt = 0;
        for (Flows flows : unFlowedList) {
            boolean nextAudit = flowsService.isNextAudit(flows, userId);
            if (nextAudit) {

                cnt++;
            }
        }
        return cnt;
    }
}