package com.highdatas.mdm.controller;


import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.pojo.CodeMsg;
import com.highdatas.mdm.pojo.Result;
import com.highdatas.mdm.pojo.SysAssembleTableType;
import com.highdatas.mdm.pojo.kettle.BigDataDataSourceInfo;
import com.highdatas.mdm.pojo.kettle.DataSourceInfo;
import com.highdatas.mdm.pojo.kettle.UnBigDataDataSourceInfo;
import com.highdatas.mdm.service.*;
import com.highdatas.mdm.util.Constant;
import com.highdatas.mdm.util.DbUtils;
import com.highdatas.mdm.util.RedisClient;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.sql.Connection;
import java.text.MessageFormat;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author kimi
 * @since 2020-02-20
 */
@RestController
@RequestMapping("/assemble/db/table")
public class SysAssembleDbTableController {
    @Autowired
    ISysAssembleService assembleService;
    @Autowired
    ISysAssembleDbService dbService;
    @Autowired
    ISysAssembleDbTableService dbTableService;
    @Autowired
    ISysAssembleDbFieldService dbFieldService;
    @Autowired
    ISysAssembleParamsService paramsService;
    @Autowired
    UnBigDataDataSourceInfo unBigDataDataSourceInfo;
    @Autowired
    BigDataDataSourceInfo bigDataDataSourceInfo;
    @Autowired
    RedisClient redisClient;

    @RequestMapping(value = "/get/parent/{id}", method = RequestMethod.GET)
    public Result get(@PathVariable String id, HttpServletRequest request) {
        SysAssembleDb sysAssembleDb = dbService.selectById(id);
        if (sysAssembleDb == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        //check 是否需要额外字段
        Wrapper<SysAssembleDbTable> parentWrapper = new EntityWrapper<SysAssembleDbTable>().eq(Constant.PARENT_ID, id);
        List<SysAssembleDbTable> sysAssembleDbs = dbTableService.selectList(parentWrapper);
        return Result.success(sysAssembleDbs);

    }

    @Transactional(rollbackFor=Exception.class)
    @RequestMapping(value = "/delete/{id}", method = RequestMethod.GET)
    public Result delete(@PathVariable String id) {
        SysAssembleDbTable sysAssembleDb = dbTableService.selectById(id);
        if (sysAssembleDb == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        boolean delete = dbFieldService.delete(new EntityWrapper<SysAssembleDbField>().eq("parent_id", id));
        if (!delete) {
            return Result.error(CodeMsg.DELETE_ERROR);
        }
        delete = sysAssembleDb.deleteById();

        if (delete) {
            return Result.success(sysAssembleDb);
        } else {
            return Result.error(CodeMsg.DELETE_ERROR);
        }
    }

    @RequestMapping(value = "/get/{id}", method = RequestMethod.GET)
    public Result get(@PathVariable String id) {
        SysAssembleDbTable sysAssembleDb = dbTableService.selectById(id);
        if (sysAssembleDb == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        Wrapper<SysAssembleDbField> fieldWrapper = new EntityWrapper<SysAssembleDbField>().eq(Constant.PARENT_ID, id);
        List<SysAssembleDbField> sysAssembleDbFields = dbFieldService.selectList(fieldWrapper);
        sysAssembleDb.setFieldList(sysAssembleDbFields);
        return Result.success(sysAssembleDb);
    }

    @RequestMapping(value = "/getField/{id}", method = RequestMethod.GET)
    public Result check(@PathVariable String id) {
        SysAssembleDbTable sysAssembleDb = dbTableService.selectById(id);
        if (sysAssembleDb == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        Wrapper<SysAssembleDbField> fieldWrapper = new EntityWrapper<SysAssembleDbField>().eq(Constant.PARENT_ID, id);
        List<SysAssembleDbField> sysAssembleDbFields = dbFieldService.selectList(fieldWrapper);
        sysAssembleDb.setFieldList(sysAssembleDbFields);
        return Result.success(sysAssembleDb);
    }

    @RequestMapping(value = "/getSqlField/{id}", method = RequestMethod.GET)
    public Result getSqlField(@PathVariable String id) {
        SysAssembleDbTable sysAssembleDb = dbTableService.selectById(id);
        if (sysAssembleDb == null || !sysAssembleDb.getType().equals(SysAssembleTableType.sql)) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        String sql = sysAssembleDb.getSql();
        List<String> fieldsBySql = dbService.getFieldsBySql(sysAssembleDb.getParentId(), sql);

        return Result.success(fieldsBySql);
    }

    @RequestMapping(value = "/setFilterSql/{id}", method = RequestMethod.GET)
    public Result setFilterSql(@PathVariable String id,@RequestParam String filter, HttpServletRequest request) {
        //TODO 对filter 做检验?

        SysAssembleDbTable sysAssembleDbTable = dbTableService.selectById(id);
        if (sysAssembleDbTable == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        sysAssembleDbTable.setFilter(filter).updateById();
        return Result.success(sysAssembleDbTable);
    }

    @RequestMapping(value = "/testFilter/{id}", method = RequestMethod.GET)
    public Result testFilter(@PathVariable String id, @RequestParam String filter) {
        SysAssembleDbTable sysAssembleDbTable = dbTableService.selectById(id);
        if (sysAssembleDbTable == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        String parentId = sysAssembleDbTable.getParentId();
        if (StringUtils.isEmpty(parentId)) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        SysAssembleDb sysAssembleDb = dbService.selectById(parentId);
        if (sysAssembleDb == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        String assembleId = sysAssembleDb.getParentId();

        List<SysAssembleDbField> fieldList = dbFieldService.selectList(new EntityWrapper<SysAssembleDbField>().eq(Constant.PARENT_ID, id));
        String fields = fieldList.stream().map(SysAssembleDbField::getField).collect(Collectors.joining(Constant.COMMA));
        SysAssembleTableType type = sysAssembleDbTable.getType();
        String tableName = null;
        if (type.equals(SysAssembleTableType.sql)) {
            tableName = sysAssembleDbTable.getSql();
        } else if (type.equals(SysAssembleTableType.table)) {
            tableName = sysAssembleDbTable.getTableName();
        }

        Set<String> matcher = DbUtils.matcher(filter);
        for (String code : matcher) {
            SysAssembleParams sysAssembleParams = paramsService.selectOne(new EntityWrapper<SysAssembleParams>().eq(Constant.PARENT_ID, assembleId).eq(Constant.Code, code));
            if (sysAssembleParams == null){
                return Result.error(new CodeMsg(6009, assembleId + "有变量未匹配到:"+ code));
            }
            String val = sysAssembleParams.getVal();
            if (StringUtils.isEmpty(val)) {
                return Result.error(new CodeMsg(6009, assembleId + "有变量未获取到值:"+ code));
            }
            val = DbUtils.quotedStr(val);
            filter = filter.replace(DbUtils.assemblParam(code), val);
        }
        String runSqlTemplate = null;
        if (type.equals(SysAssembleTableType.table)){
            runSqlTemplate = Constant.selectFieldTableTemplate;
        }else if(type.equals(SysAssembleTableType.sql)){
            runSqlTemplate = Constant.selectFieldSqlTemplate;
        }
        String sql = MessageFormat.format(runSqlTemplate, fields, tableName, filter);
        boolean b = dbService.testSql(parentId, sql);
        return Result.success(b);
    }

    @ResponseBody
    @RequestMapping(value = "/addOrUpdate", method = RequestMethod.POST)
    public Result addOne(@RequestBody SysAssembleDbTable sysAssembleDb) {
        if (sysAssembleDb == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        if (StringUtils.isEmpty(sysAssembleDb.getId())) {
            sysAssembleDb.setId(DbUtils.getUUID());
            if (StringUtils.isEmpty(sysAssembleDb.getSqlId()) && sysAssembleDb.getType().equals(SysAssembleTableType.sql)) {
                return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
            }
        }

        if (StringUtils.isEmpty(sysAssembleDb.getTableName()) && sysAssembleDb.getType().equals(SysAssembleTableType.table)){
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }

        SysAssemble assemble = assembleService.selectById(sysAssembleDb.getAssembleId());
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        Boolean bigdata = assemble.getBigdata();
        DataSourceInfo dataSourceInfo = null;
        if (bigdata) {
            dataSourceInfo =  bigDataDataSourceInfo;
        }else {
            dataSourceInfo = unBigDataDataSourceInfo;
        }
        List<String> fieldStrList = sysAssembleDb.getFieldList().stream().map(SysAssembleDbField::getField).collect(Collectors.toList());
        String suffix = null;
        try {
            suffix = DbUtils.Bit16(assemble.getId());
        } catch (Exception e) {
            e.printStackTrace();
            suffix = DbUtils.getUUID(16);
        }
        String tempTableName = null;
        if (sysAssembleDb.getType().equals(SysAssembleTableType.table)) {
            tempTableName = (Constant.AssembleTempTable  +  sysAssembleDb.getTableName() + Constant.UnderLine + suffix);
        }else {
            tempTableName = (Constant.AssembleTempSql +  DbUtils.getUUID(5) + Constant.UnderLine + suffix);
            String redisVal = redisClient.getRedisVal(sysAssembleDb.getSqlId());
            if (StringUtils.isEmpty(redisVal)) {
                return Result.error(new CodeMsg(6008,"获取sql失败"));
            }
            sysAssembleDb.setSql(redisVal);
            redisClient.deleteRedisVal(sysAssembleDb.getSqlId());
        }

        sysAssembleDb.setTempTableName(tempTableName);

        boolean created = dataSourceInfo.createTable(tempTableName, fieldStrList);
        if (!created) {
            return Result.error(new CodeMsg(6008,"创建表失败:" + tempTableName));
        }
        boolean update = sysAssembleDb.insertOrUpdate();
        if (update) {
            // update field
            boolean delete = dbFieldService.delete(new EntityWrapper<SysAssembleDbField>().eq(Constant.PARENT_ID, sysAssembleDb.getId()));
            if (!delete) {
                return Result.error(CodeMsg.DELETE_ERROR);
            }
            List<SysAssembleDbField> fieldList = sysAssembleDb.getFieldList();
            for (SysAssembleDbField sysAssembleDbField : fieldList) {
                sysAssembleDbField.setId(DbUtils.getUUID()).setCreateTime(new Date()).setParentId(sysAssembleDb.getId()).insert();
            }
            return Result.success(sysAssembleDb);
        }else {
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }
}