package com.product.data.sync.util;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.product.common.collect.ListUtils;
import com.product.core.dao.BaseDao;
import com.product.core.entity.FieldSetEntity;
import com.product.core.exception.BaseException;
import com.product.core.service.support.AbstractBaseService;
import com.product.data.sync.config.CmnConst;
import com.product.util.BaseUtil;
import com.product.util.CallBack;
import org.springframework.beans.factory.annotation.Autowired;

import java.lang.reflect.InvocationTargetException;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class DataAddDeleteSynchronization extends AbstractBaseService implements Runnable {
    @Autowired
    public ExceptionLog exceptionLog;

    public ExceptionLog getExceptionLog() {
        return exceptionLog;
    }

    public void setExceptionLog(ExceptionLog exceptionLog) {
        this.exceptionLog = exceptionLog;
    }

    @Autowired
    public BaseDao baseDao;

    @Override
    public BaseDao getBaseDao() {
        return baseDao;
    }

    @Override
    public void setBaseDao(BaseDao baseDao) {
        this.baseDao = baseDao;
    }

    private ResultSet resultSet;
    private Map<String, String> map;
    private Map<String, String> syncMap;
    private Map<String, String> sileMap;
    private Map<String, String> deleteMap;
    private CallBack callBack;

    public DataAddDeleteSynchronization(ResultSet resultSet, Map<String, String> map, Map<String, String> sileMap, Map<String, String> syncMap, Map<String, String> deleteMap) {
        this.resultSet = resultSet;
        this.map = map;
        this.syncMap = syncMap;
        this.sileMap = sileMap;
        this.deleteMap = deleteMap;
    }

    public void setCallBack(CallBack callBack) {
        this.callBack = callBack;
    }

    @Override
    public void run() {
        //系统表名
        String tableName = map.get("tableName");
        //日志uuid
        String logUuid = map.get("logUuid");
        //事件前调用
        String savePreEvent = map.get("savePreEvent");
        //事件后调用
        String postSaveEvent = map.get("postSaveEvent");
        //迭代数量
        Integer resultRow = 0;
        //新增数量
        Integer addNum = 0;
        //删除数量
        Integer deleteNumber = 0;
        //错误数量
        Integer errorNum = 0;

        List<String> addDataRecord = new ArrayList<>();
        List<String> deleteDataRecord = new ArrayList<>();
        List<String> list = ListUtils.newArrayList();
        while (true) {
            try {
                if (!resultSet.next()) break;
            } catch (SQLException e) {
                exceptionLog.upExceptionLog(logUuid, e);
                break;
            }
            try {
                FieldSetEntity fieldSet = new FieldSetEntity();
                fieldSet.setTableName(tableName);
                resultRow++;
                //是否是删除数据
                Boolean is_delete = false;
                StringBuffer condition = new StringBuffer();
                for (String key : syncMap.keySet()) {
                    fieldSet.setValue(syncMap.get(key), resultSet.getString(key));
                }
                for (String key : deleteMap.keySet()) {
                    //删除验证值
                    String deleteValue = map.get("deleteValue");
                    //值相同就删除或者不新增
                    if (deleteValue.equals(resultSet.getString(key))) {
                        is_delete = true;
                    }
                }
                list.clear();
                for (String key : sileMap.keySet()) {
                    String value = resultSet.getString(key);
                    String fieldName = sileMap.get(key);
                    fieldSet.setValue(fieldName, value);
                    condition.append(fieldName).append(" = ? AND ");
                    list.add(value);
                }
                //调用保存前方法
                if (!BaseUtil.strIsNull(savePreEvent) && savePreEvent.indexOf(".") != -1) {
                    DataManipulationUtils.codeCalls(savePreEvent, fieldSet);
                }
                String term = condition.substring(0, condition.length() - 4);
                FieldSetEntity fieldSetEntityByFilter = baseDao.getFieldSetEntityByFilter(tableName, term, list.toArray(new String[]{}), false);

                if (is_delete) {
                    if (fieldSetEntityByFilter != null) {
                        baseDao.delete(tableName, new String[]{fieldSetEntityByFilter.getString(CmnConst.UUID)});
                        deleteDataRecord.add(fieldSetEntityByFilter.getUUID());
                    }
                    deleteNumber++;
                } else {
                    //如果未查到数据就新增
                    if (fieldSetEntityByFilter == null) {
                        baseDao.add(fieldSet);
                        addDataRecord.add(fieldSet.getUUID());
                        addNum++;
                    } else {
                        errorNum++;
                    }
                }
                //调用保存后方法
                if (!BaseUtil.strIsNull(postSaveEvent) && postSaveEvent.indexOf(".") != -1) {
                    DataManipulationUtils.codeCalls(postSaveEvent, fieldSet);
                }
            } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException | BaseException | SQLException e) {
                errorNum++;
                exceptionLog.addSubExceptionLog(logUuid, list, e);
                continue;
            }
        }
        Map<String, Object> map = Maps.newHashMap();
        //迭代数量
        map.put("resultRow", (resultRow));
        //新增数量
        map.put("addNum", (addNum));
        //删除数量
        map.put("deleteNumber", (deleteNumber));
        //错误数量
        map.put("errorNum", (errorNum));
        map.put("changeDataKeys", Lists.newArrayList(addDataRecord, null, deleteDataRecord));
        //回调函数
        if (this.callBack != null) {
            callBack.method(map);
        }
    }
}