package com.highdatas.mdm.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.job.JobClient;
import com.highdatas.mdm.pojo.*;
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 lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.support.CronSequenceGenerator;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author kimi
 * @description
 * @date 2020-02-17 10:58
 */

@Slf4j
@RestController
@RequestMapping("/assemble")
public class AssembleController {
    @Autowired
    ISysAssembleService assembleService;
    @Autowired
    ISysAssembleDbService dbService;
    @Autowired
    ISysAssembleDbFieldService fieldService;
    @Autowired
    ISysAssembleDbTableService tableService;
    @Autowired
    ISysAssembleApiService apiService;
    @Autowired
    ISysAssembleCommonparamsService commonparamsService;
    @Autowired
    ISysAssembleParamsService paramsService;
    @Autowired
    ISysMenuService menuService;
    @Autowired
    IMenuMappingService menuMappingService;
    @Autowired
    BigDataDataSourceInfo bigDataDataSourceInfo;
    @Autowired
    UnBigDataDataSourceInfo unBigDataDataSourceInfo;
    @Autowired
    JobClient client;

    @RequestMapping(value = "run/{id}", method = RequestMethod.GET)
    public Result trigger(@PathVariable String id, HttpServletRequest request) {
        SysAssemble assemble = assembleService.selectById(id);
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        boolean trigger = client.trigger(assemble);
        if (trigger) {
            return Result.success(null);
        }else {
            return Result.error(CodeMsg.OPERATR_ERROR);
        }
    }

    @RequestMapping(value = "saveJobGroup", method = RequestMethod.GET)
    public Result saveJobGroup(HttpServletRequest request) {
        boolean b = client.saveJobGroup();
        if (b) {
            return Result.success(null);
        }else {
            return Result.error(CodeMsg.OPERATR_ERROR);
        }
    }

    @RequestMapping(value = "deleteJobGroup", method = RequestMethod.GET)
    public Result deleteJobGroup(HttpServletRequest request) {
        boolean b = client.saveJobGroup();
        if (b) {
            return Result.success(null);
        }else {
            return Result.error(CodeMsg.OPERATR_ERROR);
        }
    }


    @RequestMapping(value = "new", method = RequestMethod.GET)
    public Result delete(HttpServletRequest request) {
        SysAssemble assemble = new SysAssemble();
        TUser user = (TUser) request.getSession().getAttribute(Constant.USER);
        assemble.setStatus(SysAssembleStatus.edit).setCreateTime(new Date()).setUserId(user.getUserId()).setUpdateType(SysAssembleUpdateType.All);
        boolean insert = assemble.setId(DbUtils.getUUID()).setEmptyData(true).insert();
        if (insert) {
            String assembleId = assemble.getId();
            // 创建job的时候将所有 通用参数搬一份过去
            List<SysAssembleCommonparams> sysAssembleCommonparams = commonparamsService.selectList(null);
            for (SysAssembleCommonparams commonParam : sysAssembleCommonparams) {
                SysAssembleParams sysAssembleParams = new SysAssembleParams();
                sysAssembleParams
                        .setName(commonParam.getName())
                        .setCode(commonParam.getCode())
                        .setInitSql(commonParam.getInitSql()).setUpdateSql(commonParam.getUpdateSql())
                        .setCreateTime(new Date())
                        .setParentId(assembleId)
                        .setId(DbUtils.getUUID()).insert();
            }
            return Result.success(assemble);
        }else {
            return Result.error(CodeMsg.INSERT_ERROR);
        }
    }



    @RequestMapping(value = "/saveCommon/{id}", method = RequestMethod.GET)
    public Result saveCommon(@PathVariable String id, @RequestParam String menuId, @RequestParam SysAssembleUpdateType updateType, @RequestParam Boolean bigData, @RequestParam String updateFields, HttpServletRequest request) {
        SysAssemble assemble = assembleService.selectById(id);
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        assemble.setUpdateType(updateType).setUpdateFields(updateFields);
        assemble.setEmptyData(false);
        assemble.setBigdata(Boolean.valueOf(bigData));
        TUser user = (TUser) request.getSession().getAttribute(Constant.USER);
        boolean insert = assemble.setUserId(user.getUserId()).setMenuId(menuId).setUpdateTime(new Date()).updateById();

        if (insert) {
            return Result.success(assemble);
        }else {
            return Result.error(CodeMsg.INSERT_ERROR);
        }
    }

    @Transactional(rollbackFor=Exception.class)
    @RequestMapping(value = "delete/{id}", method = RequestMethod.GET)
    public Result delete(@PathVariable String id) throws Exception {
        SysAssemble assemble = assembleService.selectById(id);
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        Boolean bigdata = assemble.getBigdata();
        DataSourceInfo dataSourceInfo;
        if (bigdata) {
            dataSourceInfo = bigDataDataSourceInfo;
        }else {
            dataSourceInfo = unBigDataDataSourceInfo;
        }
        //delete db
        List<SysAssembleDb> dbList = dbService.selectList(new EntityWrapper<SysAssembleDb>().eq(Constant.PARENT_ID, id));
        for (SysAssembleDb sysAssembleDb : dbList) {
            String dbId = sysAssembleDb.getId();
            //delete table

            Wrapper<SysAssembleDbTable> eq = new EntityWrapper<SysAssembleDbTable>().eq(Constant.PARENT_ID, dbId);
            List<SysAssembleDbTable> tableList = tableService.selectList(eq);
            for (SysAssembleDbTable dbTable : tableList) {
                String tableId = dbTable.getId();
                //delete field
                String tempTableName = dbTable.getTempTableName();
                dataSourceInfo.dropData(tempTableName);

                Wrapper<SysAssembleDbField> fieldWrapper = new EntityWrapper<SysAssembleDbField>().eq(Constant.PARENT_ID, tableId);
                boolean delete = fieldService.delete(fieldWrapper);
                if (!delete) {
                    return Result.error(CodeMsg.DELETE_ERROR);
                }
                dbTable.deleteById();
            }
            sysAssembleDb.deleteById();
        }
        //TODO delete api
        apiService.delete(new EntityWrapper<SysAssembleApi>().eq(Constant.PARENT_ID, id));
        //delete param
        paramsService.delete(new EntityWrapper<SysAssembleParams>().eq(Constant.PARENT_ID, id));
        boolean b = true;
        String jobId = assemble.getJobId();
        if (!StringUtils.isEmpty(jobId)) {
            b = client.deleteJob(jobId);
        }
        if (!b) {
            throw new Exception("xxljob 删除失败");
        }
        boolean deleted = assemble.deleteById();
        if (deleted) {
            return Result.success(assemble);
        }else {
            return Result.error(CodeMsg.DELETE_ERROR);
        }
    }

    @RequestMapping(value = "saveCheckType/{id}", method = RequestMethod.GET)
    public Result saveUpdateType(@RequestParam SysAssembleCheckType type, @PathVariable String id,HttpServletRequest request) {
        SysAssemble assemble = assembleService.selectById(id);
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        assemble.setCheckType(type);
        if (type.equals(SysAssembleCheckType.partSuccessAdd)) {
            String fields = request.getParameter("fields");
            if (StringUtils.isEmpty(fields)) {
                return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
            }
            assemble.setCheckFields(fields);
        }
        boolean updated = assemble.updateById();
        if (updated) {
            return Result.success(assemble);
        }else {
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }


    @RequestMapping(value = "updateStatus/{id}", method = RequestMethod.GET)
    public Result updateStatus(@RequestParam SysAssembleStatus status,@RequestParam String id) {
        SysAssemble assemble = assembleService.selectById(id);
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        assemble.setStatus(status);
        boolean updated = assemble.updateById();
        if (updated) {
            return Result.success(assemble);
        }else {
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }

    @RequestMapping(value = "loadPurgeSql/{id}", method = RequestMethod.POST)
    public Result loadPurgeSql(@RequestBody JSONObject object,@PathVariable String id) {
        String sql = object.getString("sql");
        SysAssemble assemble = assembleService.selectById(id);
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        assemble.setPurgeSql(sql);
        boolean updated = assemble.updateById();
        if (updated) {
            return Result.success(assemble);
        }else {
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }

    @RequestMapping(value = "getTables/{id}", method = RequestMethod.GET)
    public Result getTables(@PathVariable String id) {
        SysAssemble assemble = assembleService.selectById(id);
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        //TODO  ONLY db 缺少 api的
        List<SysAssembleDb> dbList = dbService.selectList(new EntityWrapper<SysAssembleDb>().eq(Constant.PARENT_ID, id));
        JSONArray sourceTables = new JSONArray();

        for (SysAssembleDb sysAssembleDb : dbList) {
            List<SysAssembleDbTable> tableList = tableService.selectList(new EntityWrapper<SysAssembleDbTable>().eq(Constant.PARENT_ID, sysAssembleDb.getId()));
            for (SysAssembleDbTable dbTable : tableList) {
                JSONObject object = new JSONObject();
                object.fluentPut(Constant.ID, dbTable.getId());
                object.fluentPut(Constant.tableName, dbTable.getTempTableName());
                sourceTables.add(object);
            }
        }
        MenuMapping menuMapping = menuMappingService.selectOne(new EntityWrapper<MenuMapping>().eq("menu_id", assemble.getMenuId()));
        String tableName = menuMapping.getTableName();
        String tempTableName = Constant.Temp + tableName;
        JSONObject object = new JSONObject();
        object.fluentPut(Constant.ID, null);
        object.fluentPut(Constant.tableName, tempTableName);
        JSONObject result = new JSONObject();
        result.fluentPut("source", sourceTables);
        result.fluentPut("target", object);
        return Result.success(result);
    }

    @Transactional(rollbackFor=Exception.class)
    @RequestMapping(value = "saveCorn/{id}", method = RequestMethod.GET)
    public Result add(@RequestParam String cron,@PathVariable String id) throws Exception {
        SysAssemble assemble = assembleService.selectById(id);
        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        boolean validExpression = CronSequenceGenerator.isValidExpression(cron);
        if (!validExpression) {
            return Result.error(new CodeMsg(6006, "corn 表达式不规范"));
        }
        assemble.setCron(cron);
        boolean b = paramsService.updateCornVal(assemble.getId(), cron);
        if (!b) {
            return Result.error(new CodeMsg(6007, "corn 表达式更新值错误"));
        }
        assemble.setStatus(SysAssembleStatus.working);
        String jobId = assemble.getJobId();
        boolean xxljobStatus = true;
        if (StringUtils.isEmpty(jobId)) {
            xxljobStatus = client.addJob(assemble);
        }
        else {
            xxljobStatus = client.updateJob(assemble);
        }
        if (!xxljobStatus) {
            throw new Exception("add or update xxxljob fail");
        }

        boolean updated = assemble.updateById();
        if (updated) {
            return Result.success(assemble);
        }else {
            return Result.error(CodeMsg.UPDATE_ERROR);
        }
    }

    @RequestMapping(value = "get/{id}", method = RequestMethod.GET)
    public Result get(@PathVariable String id) {
        SysAssemble assemble = assembleService.selectById(id);
        String menuId = assemble.getMenuId();
        JSONObject o = (JSONObject) JSON.toJSON(assemble);
        if (!StringUtils.isEmpty(menuId)) {
            LinkedHashSet<String> ids = new LinkedHashSet<>();
            ids.add(menuId);
            Set<String> byParentId = menuService.getByParentId(ids);
            ArrayList<String> strings = new ArrayList<>(byParentId);
            Collections.reverse(strings);

            o.fluentPut("menupath", strings);
        }

        if (assemble == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        return Result.success(o);
    }

    @RequestMapping(value = "/{pageNo}", method = RequestMethod.GET)
    public Result page(@PathVariable Integer pageNo, HttpServletRequest request)  {
        EntityWrapper<SysAssemble> wrapper = new EntityWrapper<>();
        String dbName = request.getParameter("dbName");
        if (!StringUtils.isEmpty(dbName)) {
            List<SysAssembleDb> dbList = dbService.selectList(new EntityWrapper<SysAssembleDb>().eq("datasource_name", dbName));
            if (dbList != null && dbList.size() != 0) {
                List<String> collect = dbList.stream().map(sysAssembleDb -> sysAssembleDb.getParentId()).collect(Collectors.toList());
                wrapper.in(Constant.ID, collect);
            }
        }

        String menuId = request.getParameter("menuId");
        if (!StringUtils.isEmpty(menuId)) {
            wrapper.eq("menu_id", menuId);
        }
        String bigdata = request.getParameter("bigdata");
        if (!StringUtils.isEmpty(bigdata)) {
            wrapper.eq("bigdata", Boolean.valueOf(bigdata));
        }
        String status = request.getParameter("status");
        if (!StringUtils.isEmpty(status)) {
            wrapper.eq("status", status);
        }

        Page<SysAssemble> page;
        String pageSize = request.getParameter("pageSize");
        if (!StringUtils.isEmpty(pageSize)) {
            page = new Page(pageNo, Integer.valueOf(pageSize));
        }else {
            page = new Page(pageNo, 15);
        }

        Page<SysAssemble> resultPage = assembleService.selectPage(page,wrapper);
        List<SysAssemble> records = resultPage.getRecords();

        List<JSONObject> array = new ArrayList<>();
        for (SysAssemble record : records) {
            String id = record.getId();
            Wrapper<SysAssembleParams> eq = new EntityWrapper<SysAssembleParams>().eq(Constant.PARENT_ID, id).eq(Constant.Code, Constant.Cron);
            JSONObject o = (JSONObject) JSON.toJSON(record);

            SysAssembleParams sysAssembleParams = paramsService.selectOne(eq);
            String val = sysAssembleParams.getVal();
            o.fluentPut("nextTime", val);

            String realMenuId = record.getMenuId();
            if (!StringUtils.isEmpty(realMenuId)) {
                LinkedHashSet<String> menuSet = new LinkedHashSet<>();
                menuSet.add(realMenuId);
                LinkedHashSet<String> byParentId = menuService.getByParentId(menuSet);
                List<SysMenu> sysMenus = menuService.selectBatchIds(byParentId);
                o.fluentPut("menuList", sysMenus);
            }
            List<SysAssembleDb> dbList = dbService.selectList(new EntityWrapper<SysAssembleDb>().eq(Constant.PARENT_ID, record.getId()));
            o.fluentPut("dbList", dbList);

            array.add(o);
        }
        Page<JSONObject> jsonObjectPage = new Page<>();
        jsonObjectPage.setCurrent(resultPage.getCurrent());
        jsonObjectPage.setSize(resultPage.getSize());
        jsonObjectPage.setTotal(resultPage.getTotal());
        jsonObjectPage.setRecords(array);
        return Result.success(jsonObjectPage);
    }
}