package com.salpa.web.controller.subject;

import com.salpa.common.config.SalpaConfig;
import com.salpa.common.constant.UserConstants;
import com.salpa.common.core.controller.BaseController;
import com.salpa.common.core.domain.AjaxResult;
import com.salpa.common.utils.file.FileUploadUtils;
import com.salpa.subject.domain.MonitorDatabaseType;
import com.salpa.subject.service.DatabaseTypeService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.List;

/**
 * 数据库类型
 *
 * @author zhuff
 */
@RestController
@RequestMapping("/subject/databaseType")
public class DatabaseTypeController extends BaseController {

    @Autowired
    private DatabaseTypeService databaseTypeService;

    /**
     * 获取数据库类型列表
     * @author zhuff
     * @return
     */
    @GetMapping("getDatabaseType")
    public AjaxResult getDatabaseTypeAll() {
        List<MonitorDatabaseType> list = databaseTypeService.getDatabaseTypeAll();
        return AjaxResult.success(list);
    }

    /**
     * 数据库类型列表查询
     * @author zhuff
     * @return
     */
    @GetMapping("list")
    public AjaxResult getList(String databaseType) {
        List<MonitorDatabaseType> list = databaseTypeService.getList(databaseType);
        return AjaxResult.success(list);
    }

    /**
     * 创建数据库类型
     * @param monitorDatabaseType
     * @return
     */
    @PostMapping("add")
    public AjaxResult addDatabaseType(@RequestBody MonitorDatabaseType monitorDatabaseType) {
        if (monitorDatabaseType.getUrlPattern() == null) {
            return AjaxResult.error("url pattern 不能为空");
        }
        if (!monitorDatabaseType.getUrlPattern().contains("{{jdbc.protocol}}")) {
            return AjaxResult.error("必须包含变量{{jdbc.protocol}}");
        }
        if (!monitorDatabaseType.getUrlPattern().contains("{{db.url}}")) {
            return AjaxResult.error("必须包含变量{{db.url}}不能为空");
        }
        if (!monitorDatabaseType.getUrlPattern().contains("{{db.schema}}") && !monitorDatabaseType.getUrlPattern().contains("{{db.name}}")) {
            return AjaxResult.error("{{db.schema}} 和 {{db.name}} 至少设置一个");
        }
        if (UserConstants.NOT_UNIQUE.equals(databaseTypeService.checkDatabaseTypeUnique(monitorDatabaseType.getDatabaseType()))) {
            return AjaxResult.error("该数据库类型已存在");
        }
        return toAjax(databaseTypeService.addDatabaseType(monitorDatabaseType));
    }

    /**
     * 修改数据库类型
     * @param monitorDatabaseType
     * @return
     */
    @PostMapping("update")
    public AjaxResult updateDatabaseType(@RequestBody MonitorDatabaseType monitorDatabaseType) {
        if (monitorDatabaseType.getUrlPattern() == null) {
            return AjaxResult.error("url pattern 不能为空");
        }
        if (!monitorDatabaseType.getUrlPattern().contains("{{jdbc.protocol}}")) {
            return AjaxResult.error("必须包含变量{{jdbc.protocol}}");
        }
        if (!monitorDatabaseType.getUrlPattern().contains("{{db.url}}")) {
            return AjaxResult.error("必须包含变量{{db.url}}不能为空");
        }
        /*if (!monitorDatabaseType.getUrlPattern().contains("{{db.schema}}") && !monitorDatabaseType.getUrlPattern().contains("{{db.name}}")) {
            return AjaxResult.error("{{db.schema}} 和 {{db.name}} 至少设置一个");
        }*/
        if (!databaseTypeService.getById(monitorDatabaseType.getId()).getDatabaseType().equals(monitorDatabaseType.getDatabaseType())) {
            if (UserConstants.NOT_UNIQUE.equals(databaseTypeService.checkDatabaseTypeUnique(monitorDatabaseType.getDatabaseType()))) {
                return AjaxResult.error("该数据库类型已存在");
            }
        }
        return toAjax(databaseTypeService.updateDatabaseType(monitorDatabaseType));
    }

    /**
     * 删除数据库类型
     * @param id
     * @return
     */
    @DeleteMapping("delete")
    public AjaxResult deleteDatabaseType(Integer id) {
        return toAjax(databaseTypeService.deleteDatabaseType(id));
    }

    /**
     * 解析数据库驱动类名
     * @param jdbcDriverFileUrl
     * @return
     */
    @GetMapping("resolveDriverClassName")
    public AjaxResult resolveDriverClassName(String jdbcDriverFileUrl,String jdbcDriverFilePath) {
        if (StringUtils.isAllBlank(jdbcDriverFilePath, jdbcDriverFileUrl)) {
            return AjaxResult.error("请填写下载驱动的地址或手动上传驱动文件");
        } else if (StringUtils.isNotBlank(jdbcDriverFilePath)) {
            File saveDir = new File(SalpaConfig.getProfile()+jdbcDriverFilePath);
            if (!saveDir.exists()) {
                return AjaxResult.error("驱动文件不存在，请重新上传");
            } else {
                String className = databaseTypeService.resolveDriverClassNameFromLocal(jdbcDriverFilePath);
                if (className == "") {
                    return AjaxResult.error("解析失败，请检查地址");
                } else {
                    return AjaxResult.success(className);
                }
            }
        } else if (StringUtils.isNotBlank(jdbcDriverFileUrl)) {
            String className = databaseTypeService.resolveDriverClassName(jdbcDriverFileUrl);
            if (className == "") {
                return AjaxResult.error("解析失败，请检查地址");
            } else {
                return AjaxResult.success(className);
            }
        } else {
            return AjaxResult.error("解析失败，请检查地址");
        }
    }

    /**
     * 上传数据库驱动
     * @param file
     * @return
     */
    @PostMapping("uploadDriver")
    public AjaxResult uploadDriver(MultipartFile file) {
        String fileName = "";
        try {
            // 上传驱动文件路径
            String filePath = SalpaConfig.getDriverPath();
            File file1 = new File(filePath);
            if (file1.exists()) {
                file1.delete();
            }
            // 上传并返回新文件名称
            fileName = FileUploadUtils.upload(filePath, file);
        } catch (IOException e) {
            return AjaxResult.error("上传失败，请检查后重新上传");
        }
        return AjaxResult.success(fileName);
    }

}
