package com.highdatas.mdm.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.highdatas.mdm.entity.SysField;
import com.highdatas.mdm.entity.TableSchemaResult;
import com.highdatas.mdm.mapper.TableInfoMapper;
import com.highdatas.mdm.pojo.CodeMsg;
import com.highdatas.mdm.pojo.Page;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.pojo.Segment;
import com.highdatas.mdm.service.BaseDataService;
import com.highdatas.mdm.service.ISysFieldService;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.ContentBuilder;
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.*;
import java.util.stream.Collectors;

/**
 * @author kimi
 * @description
 * @date 2019-12-17 12:09
 */

@Service
public class BaseDataServiceImpl implements BaseDataService{
    @Autowired
    TableInfoMapper mapper;
    @Autowired
    ISysFieldService fieldService;


    public Result selectById(String tableName, String id) {
        try{
            EntityWrapper<SysField> sysFieldEntityWrapper = new EntityWrapper<>();
            sysFieldEntityWrapper.eq("table_name", tableName);
            List<SysField> sysFields = fieldService.selectList(sysFieldEntityWrapper);
            JSONObject object = new JSONObject();

            String whereStr = DbUtils.combieOneSegment(Constant.ID, id);
            String fields = getFields(tableName);
            List<Map<String, Object>> select = mapper.select(tableName, fields, whereStr);
            if (select == null || select.size() == 0) {
                return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
            }
            else if (select.size() == 1) {

                object.fluentPut("grid", select.get(0));
                object.fluentPut("fields", sysFields);
                return Result.success(object);
            }else {
                object.fluentPut("grid", select);
                object.fluentPut("fields", sysFields);
                return Result.success(object);
            }
        }
        catch (Exception e) {
            return Result.error(CodeMsg.SELECT_ERROR);
        }
    }


    public Result selectList(String tableName){
        return selectList(tableName, Constant.WHERE_DEFAULT);
    }




    public Result selectList(String tableName, String whereSegment) {
        return selectList(tableName, null, whereSegment);
    }



    public Result selectList(String tableName,List<String> fieldList, String whereSegment) {
        try{
            EntityWrapper<SysField> sysFieldEntityWrapper = new EntityWrapper<>();
            sysFieldEntityWrapper.eq("table_name", tableName);
            List<SysField> sysFields = fieldService.selectList(sysFieldEntityWrapper);
            JSONObject object = new JSONObject();

            String fields;
            if (fieldList == null || fieldList.size() == 0) {
                fields = getFields(tableName);
            } else {
                fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA));
            }

            List<Map<String, Object>> select = mapper.select(tableName, fields, whereSegment);
            object.fluentPut("grid", select);
            object.fluentPut("fields", sysFields);
            return  Result.success(object);
        }
        catch (Exception e) {
            return Result.error(CodeMsg.SELECT_ERROR);
        }
    }


    public Result selectList(String tableName, List<String> fields) {
        return selectList(tableName, fields, Constant.WHERE_DEFAULT);
    }

    public Long getCount(String tableName, String whereSegment) {
        try{
            if (StringUtils.isEmpty(whereSegment)) {
                whereSegment = Constant.WHERE_DEFAULT;
            }
            Long count = mapper.getCount(tableName, whereSegment);
            return count;
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public String getFields(String tableName) {
        List<TableSchemaResult> tableField = mapper.getTableField(tableName);
        ContentBuilder contentBuilder = new ContentBuilder(Constant.COMMA);
        for (TableSchemaResult tableSchemaResult : tableField) {
            String fieldName = tableSchemaResult.getFieldName();
            if (fieldName.equalsIgnoreCase(Constant.DEAL)) {
                //DEAL 不给看
                continue;
            }
            contentBuilder.append(fieldName);
        }
        return contentBuilder.toString();
    }


    public Result selectListByPage(String tableName, Integer pageNo, Integer pageSize) {
        return selectListByPage(tableName,Constant.WHERE_DEFAULT,pageNo,pageSize);
    }


    public Result selectListByPage(String tableName, String whereSegment, Integer pageNo) {
        return selectListByPage(tableName,whereSegment,pageNo, null);
    }


    public Result selectListByPage(String tableName, Integer pageNo) {
        return selectListByPage(tableName,Constant.WHERE_DEFAULT,pageNo, null);
    }


    public Result selectListByPage(String tableName, String whereSegment, Integer pageNo, Integer pageSize) {
        return selectListByPage(tableName,null,whereSegment,pageNo,pageSize);
    }


    public Result selectListByPage(String tableName, List<String> fieldList, String whereSegment, Integer pageNo) {
        return selectListByPage(tableName,null,whereSegment,pageNo, null);
    }


    public Result selectListByPage(String tableName, List<String> fieldList, Integer pageNo) {
        return selectListByPage(tableName,null,Constant.WHERE_DEFAULT,pageNo);
    }


    public Result selectListByPage(String tableName,List<String> fieldList, String whereSegment, Integer pageNo, Integer pageSize) {
        Long count = getCount(tableName, whereSegment);
        if (count == null) {
            return Result.error(CodeMsg.SELECT_ERROR);
        }
        Page page = new Page(count);
        if (pageSize != null && pageSize.compareTo(1) != -1) {
            page.setPageSize(pageSize);
        }

        if (page.getPageCount() < pageNo) {
            return Result.error(CodeMsg.SELECT_ERROR_NOTFOUND);
        }
        page.setPageNo(pageNo);

        String limitSQL = page.getLimitSQL();

        String fields;
        if (fieldList == null || fieldList.size() == 0) {
            fields = getFields(tableName);
            fieldList = Arrays.stream(fields.split(Constant.COMMA_TRIM)).collect(Collectors.toList());
        } else {
            fields = fieldList.stream().collect(Collectors.joining(Constant.COMMA));
        }
        EntityWrapper<SysField> sysFieldEntityWrapper = new EntityWrapper<>();
        sysFieldEntityWrapper.eq("table_name", tableName);
        List<SysField> sysFields = fieldService.selectList(sysFieldEntityWrapper);
        JSONObject resultobject = new JSONObject();

        List<Map<String, Object>> maps = mapper.selectByPage(tableName, fields, whereSegment, limitSQL);
        JSONObject object = new JSONObject();

        object.fluentPut("total", page.getRecordCount());
        object.fluentPut("passiveQueueSize", page.getPageSize());
        object.fluentPut("pages", page.getPageCount());
        object.fluentPut("current", page.getPageNo());
        object.fluentPut("record", maps);

        resultobject.fluentPut("grid",object);
        resultobject.fluentPut("fields",sysFields);

        return Result.success(resultobject);
    }


    public Result insert(String tableName, String fields, String values) {
        try {
            String[] split = fields.split(Constant.SEMICOLON);
            List<String> fieldNameList = Arrays.stream(split).map(s -> s.trim()).collect(Collectors.toList());
            ContentBuilder builder = new ContentBuilder(Constant.COMMA);
            Object parse = JSON.parse(values);
            List<String> ids = new ArrayList<>();
            if (parse instanceof JSONObject){
                JSONObject jsonObject = (JSONObject) parse;
                String id = appendOneValue(jsonObject, fieldNameList, builder);
                ids.add(id);
                String sqlValues  = builder.toString();
                mapper.insert(tableName, fields, sqlValues);
                return Result.success(CodeMsg.INSERT_SUCCESS);
            } else if (parse instanceof JSONArray) {
                JSONArray jsonArray = (JSONArray) parse;
                int size = jsonArray.size();
                for (int i = 0; i < size; i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    ids.add(appendOneValue(jsonObject, fieldNameList, builder));

                }
                String sqlValues = builder.toString();
                mapper.insert(tableName, fields, sqlValues);
                return Result.success(ids);
            } else {
                return Result.error(CodeMsg.INSERT_ERROR);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(CodeMsg.INSERT_ERROR);
        }

    }

    public Result insert(String tableName, String json) {
        try {
            List<TableSchemaResult> tableFieldList = mapper.getTableField(tableName);
            List<String> fieldNameList = tableFieldList.stream().map(TableSchemaResult::getFieldName).collect(Collectors.toList());
            String fields = tableFieldList.stream().map(TableSchemaResult::getFieldName).collect(Collectors.joining(Constant.COMMA));

            ContentBuilder builder = new ContentBuilder(Constant.COMMA);
            Object parse = JSON.parse(json);
            List<String> ids = new ArrayList<>();
            if (parse instanceof JSONObject){
                JSONObject jsonObject = (JSONObject) parse;
                ids.add(appendOneValue(jsonObject, fieldNameList, builder));
                String sqlValues  = builder.toString();
                mapper.insert(tableName, fields, sqlValues);
                return Result.success(CodeMsg.INSERT_SUCCESS);
            } else if (parse instanceof JSONArray) {
                JSONArray jsonArray = (JSONArray) parse;
                int size = jsonArray.size();
                for (int i = 0; i < size; i++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(i);
                    ids.add(appendOneValue(jsonObject, fieldNameList, builder));
                }
                String sqlValues = builder.toString();
                mapper.insert(tableName, fields, sqlValues);
                return Result.success(ids);
            } else {
                return Result.error(CodeMsg.INSERT_ERROR);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(CodeMsg.INSERT_ERROR);
        }

    }

    private String appendOneValue(JSONObject jsonObject, List<String> fieldNameList, ContentBuilder builder) {
        String id = null;
        builder.append("(");
        boolean first = true;
        for (int i = 0; i < fieldNameList.size(); i++) {
            String fieldName = fieldNameList.get(i);

            Object value = jsonObject.get(fieldName);
            if (fieldName.equalsIgnoreCase(Constant.ID) && value == null) {
                id =  DbUtils.getUUID();
                value = id;
            }
            if (value == null) {
                continue;
            }
            if (value instanceof String) {
                value = DbUtils.quotedStr(value);
            }
            if (first) {
                builder.appendOnly(String.valueOf(value));
                first = false;
            }  else {
                builder.append(value);
            }
        }
        //deal
        builder.append(1);

        builder.appendOnly(")");
        return id;
    }


    public Result updateById(String tableName, String fieldsSegment, String id, boolean total) {
        String whereStr = DbUtils.combieOneSegment(Constant.ID, id);
        return update(tableName, fieldsSegment,whereStr, total);
    }


    public Result update(String tableName, String fieldsSegment, boolean total) {
        String whereSegment = Constant.WHERE_DEFAULT;
        return update(tableName, fieldsSegment,whereSegment, total);
    }


    public Result update(String tableName, String fieldsSegment, String whereSegment) {
        try {
            ContentBuilder builder = new ContentBuilder(Constant.COMMA);
            JSONObject jsonObject = JSONObject.parseObject(fieldsSegment);
            List<TableSchemaResult> tableFieldResultList = mapper.getTableField(tableName);
            for (TableSchemaResult tableSchemaResult : tableFieldResultList) {
                String dbType = tableSchemaResult.getDbType();
                String fieldName = tableSchemaResult.getFieldName();
                Object o = jsonObject.get(fieldName);
                String javaTypeStr = DbUtils.toSqlToJava(dbType);
                Segment segment;
                if ("string".equalsIgnoreCase(javaTypeStr.trim())) {
                    segment = new Segment(fieldName, String.valueOf(o));
                } else {
                    segment = new Segment(fieldName, o);
                }
                builder.append(segment.toString());
            }
            String updateSegment = builder.toString();
            mapper.update(tableName, updateSegment, whereSegment);
            return Result.success(CodeMsg.UPDATE_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }


    public Result update(String tableName, String fieldsSegment, String whereSegment, boolean total) {
        try {
            ContentBuilder builder = new ContentBuilder(Constant.COMMA);
            JSONObject jsonObject = JSONObject.parseObject(fieldsSegment);
            List<TableSchemaResult> tableFieldResultList = mapper.getTableField(tableName);
            if (total) {
                for (TableSchemaResult tableSchemaResult : tableFieldResultList) {
                    String dbType = tableSchemaResult.getDbType();
                    String fieldName = tableSchemaResult.getFieldName();
                    Object o = jsonObject.get(fieldName);
                    String javaTypeStr = DbUtils.toSqlToJava(dbType);
                    Segment segment;
                    if (o == null) {
                        continue;
                    }
                    if ("string".equalsIgnoreCase(javaTypeStr.trim())) {
                        segment = new Segment(fieldName, String.valueOf(o));
                    } else {
                        if (fieldName.equalsIgnoreCase(Constant.DEAL)) {
                            segment = new Segment(fieldName, 1);
                        } else {
                            segment = new Segment(fieldName, o);
                        }
                    }
                    builder.append(segment.toString());
                }
            } else {
                Set<String> fieldSet = jsonObject.keySet();
                for (String fieldName : fieldSet) {
                    List<TableSchemaResult> collect = tableFieldResultList.stream().filter(tableSchemaResult -> tableSchemaResult.getFieldName().equalsIgnoreCase(fieldName)).collect(Collectors.toList());
                    TableSchemaResult tableSchemaResult = collect.get(0);
                    String dbType = tableSchemaResult.getDbType();
                    Object o = jsonObject.get(fieldName);
                    String javaTypeStr = DbUtils.toSqlToJava(dbType);
                    Segment segment;
                    if ("string".equalsIgnoreCase(javaTypeStr.trim())) {
                        segment = new Segment(fieldName, String.valueOf(o));
                    } else {
                        if (fieldName.equalsIgnoreCase(Constant.DEAL)) {
                            segment = new Segment(fieldName, 1);
                        } else {
                            segment = new Segment(fieldName, o);
                        }
                    }
                    builder.append(segment.toString());
                }
            }

            String updateSegment = builder.toString();
            mapper.update(tableName, updateSegment, whereSegment);
            return Result.success(CodeMsg.UPDATE_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }


    public Result delete(String tableName) {
        return  delete(tableName, Constant.WHERE_DEFAULT);
    }


    public Result deleteById(String tableName, String id) {
        String whereStr = DbUtils.combieOneSegment(Constant.ID, id);
        return  delete(tableName, whereStr);
    }

    public Result delete(String tableName, String whereSegment) {
        try {
            mapper.delete(tableName, whereSegment);
            return Result.success(CodeMsg.DELETE_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(CodeMsg.DELETE_ERROR);
        }
    }
}