package com.web.generalKanBanPage.service.impl;

import com.app.base.data.ApiResponseResult;
import com.web.generalKanBanPage.dao.GeneralKanBanPageDao;
import com.web.generalKanBanPage.entity.GeneralKanBanPage;
import com.web.generalKanBanPage.service.IGeneralKanBanPageService;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;


@Service
public class GeneralKanBanPageServiceImpl implements IGeneralKanBanPageService {
    protected Logger logger = LoggerFactory.getLogger(GeneralKanBanPageServiceImpl.class);

    @Autowired
    private GeneralKanBanPageDao generalKanBanPageDao;

    // 前台自动新增触发
    @Transactional
    @Override
    public ApiResponseResult autoInsert(GeneralKanBanPage generalKanBanPage) {
        String ip = generalKanBanPage.getBsIp();
        String port = generalKanBanPage.getBsPort();
        String bsMac = generalKanBanPage.getBsMac();
        Date time = generalKanBanPage.getCreatedTime();

        if(ip==null||ip==""||port==null||port==""||bsMac==null||bsMac==""){
            return ApiResponseResult.failure("ip或端口号或mac地址都不能为空");
        }
        if(!port.matches("^([0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$")) {
            return ApiResponseResult.failure("请输入正确的端口号");
        }

        int count = 0;
        // 根据bsMac查找数据库中存在数量，有则修改，无则新增
        count = generalKanBanPageDao.countByBsMac(bsMac);
        if(count==1){
            int row = 0;
            GeneralKanBanPage kanban = generalKanBanPageDao.findByBsMac(bsMac);
            // 若前台绑定了ip和端口号，那么换了服务器之后，就无法请求到
            if(ip!=""||ip!=null){ // 因此若前台传入ip不为空，则将后台数据库的ip覆盖前台传入的ip且保存在数据库
                kanban.setBsIp(ip);
//                ip = kanban.getBsIp();
            }
            if(port!=""||port!=null){ // 因此若前台传入port不为空，则将后台数据库的port覆盖前台传入的port且保存在数据库
                kanban.setBsPort(port);
//                port = kanban.getBsPort();
            }
//            kanban.setBsIp(ip);
//            kanban.setBsPort(port);
            generalKanBanPageDao.save(kanban);
            return ApiResponseResult.success();
        }else if(count>1){
            logger.error("根据bsMac查询数据库，有多条数据，请修改！");
            return ApiResponseResult.failure("请联系技术人员!");
        }
        // count=0 根据mac没有找到对应的数据，则新增
        generalKanBanPageDao.save(generalKanBanPage);
        return ApiResponseResult.success();
    }

    // 前台点击提交触发
    @Transactional
    @Override
    public ApiResponseResult insert(GeneralKanBanPage generalKanBanPage) {
        String ip = generalKanBanPage.getBsIp();
        String port = generalKanBanPage.getBsPort();
        String path1 = generalKanBanPage.getBsPath1();
        String bsMac = generalKanBanPage.getBsMac();
        String nick = generalKanBanPage.getBsNick();
        Date time = generalKanBanPage.getCreatedTime();

        if(ip==null||ip==""||port==null||port==""||bsMac==null||bsMac==""){
            return ApiResponseResult.failure("ip或端口号或mac地址都不能为空");
        }
//        if(!ip.matches("^((2((5[0-5])|([0-4]\\d)))|([0-1]?\\d{1,2}))(\\.((2((5[0-5])|([0-4]\\d)))|([0-1]?\\d{1,2}))){3}$")){
//            return ApiResponseResult.failure("请输入正确的ip");
//        }
        if(!port.matches("^([0-9]{1,4}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])$")) {
            return ApiResponseResult.failure("请输入正确的端口号");
        }

        int count = 0;
        // 根据bsMac查找数据库中存在数量，有则修改，无则新增
        count = generalKanBanPageDao.countByBsMac(bsMac);
        if(count==1){
            int row = 0;
            GeneralKanBanPage kanban = generalKanBanPageDao.findByBsMac(bsMac);
            // 手动输入点提交时，path1为空，那么将后台查询到的路径传入前台
            if(path1==" "||StringUtils.isEmpty(path1)){
                if(kanban.getBsPath1()!=" "||StringUtils.isNotEmpty(kanban.getBsPath1())){
                    path1 = kanban.getBsPath1();
                }
                ApiResponseResult.failure("请联系技术人员,配置页面");
            }
            // 手动输入点提交时，nick为空，那么将后台查询到的nick传入前台
            if(nick==""||nick==null){
                nick = kanban.getBsNick();
            }

            row = generalKanBanPageDao.update(ip, port, path1, nick, bsMac);
            if(row==1){
                return ApiResponseResult.success();
            }
        }else if(count>1){
            logger.error("根据bsMac查询数据库，有多条数据，请修改！");
            return ApiResponseResult.failure("请联系技术人员!");
        }

        // count=0 根据mac没有找到对应的数据，则新增
        generalKanBanPageDao.save(generalKanBanPage);
        return ApiResponseResult.success();
    }

    @Override
    public ApiResponseResult selectByBsMac(String bsMac) {
        Map<String,String> map = new HashMap<>();
        GeneralKanBanPage kanBanPage = generalKanBanPageDao.findByBsMac(bsMac);
        if(kanBanPage==null){
            return ApiResponseResult.failure("请联系技术人员配置页面").data(kanBanPage);
        }
        String ip = kanBanPage.getBsIp();
        String port = kanBanPage.getBsPort();
        String bsPath1 = kanBanPage.getBsPath1();
        String bsPath2 = kanBanPage.getBsPath2();
        String bsPath3 = kanBanPage.getBsPath3();
        String bsPath4 = kanBanPage.getBsPath4();
        String bsPath5 = kanBanPage.getBsPath5();
        String bsMsg = "";
        map.put("ip",ip);
        map.put("port",port);
        if(bsPath1==" "||StringUtils.isEmpty(bsPath1)){
            return ApiResponseResult.failure("缺失页面路径1，请联系技术人员配置页面").data(kanBanPage);
        }
        Boolean checkURL = false;
        if(bsPath1!=null||StringUtils.isNotEmpty(bsPath1)){
            checkURL = checkUrl(ip, port, bsPath1);
            if(checkURL==false){
                bsMsg = "页面路径1连接失败，请检查mes框架配置或ip，端口号以及路径是否正确";
                generalKanBanPageDao.updataByBsMsg(bsMsg, bsMac);
                map.put("msg1",bsMsg);
                map.put("oracle_path1","0");
            }else{
                map.put("msg1","0");
                map.put("oracle_path1",bsPath1);
            }
        }

        if(bsPath2!=null||StringUtils.isNotEmpty(bsPath2)){
            checkURL = checkUrl(ip, port, bsPath2);
            if(checkURL==false){
                bsMsg ="页面路径2连接失败，请检查mes框架配置或ip，端口号以及路径是否正确";
                generalKanBanPageDao.updataByBsMsg(bsMsg, bsMac);
                map.put("msg2",bsMsg);
                map.put("oracle_path2","0");
            }else{
                map.put("msg2","0");
                map.put("oracle_path2",bsPath2);
            }
        }else {
            map.put("oracle_path2", "0");
        }

        if(bsPath3!=null||StringUtils.isNotEmpty(bsPath3)){
            checkURL = checkUrl(ip, port, bsPath3);
            if(checkURL==false){
                bsMsg ="页面路径3连接失败，请检查mes框架配置或ip，端口号以及路径是否正确";
                generalKanBanPageDao.updataByBsMsg(bsMsg, bsMac);
                map.put("msg3",bsMsg);
                map.put("oracle_path3","0");
            }else{
                map.put("msg3","0");
                map.put("oracle_path3",bsPath3);
            }
        }else {
            map.put("oracle_path3", "0");
        }

        if(bsPath4!=null||StringUtils.isNotEmpty(bsPath4)){
            checkURL = checkUrl(ip, port, bsPath4);
            if(checkURL==false){
                bsMsg ="页面路径4连接失败，请检查mes框架配置或ip，端口号以及路径是否正确";
                generalKanBanPageDao.updataByBsMsg(bsMsg, bsMac);
                map.put("msg4",bsMsg);
                map.put("oracle_path4","0");
            }else{
                map.put("msg4","0");
                map.put("oracle_path4",bsPath4);
            }
        }else {
            map.put("oracle_path4", "0");
        }

        if(bsPath5!=null||StringUtils.isNotEmpty(bsPath5)){
            checkURL = checkUrl(ip, port, bsPath5);
            if(checkURL==false){
                bsMsg ="页面路径5连接失败，请检查mes框架配置或ip，端口号以及路径是否正确";
                generalKanBanPageDao.updataByBsMsg(bsMsg, bsMac);
                map.put("msg5",bsMsg);
                map.put("oracle_path5","0");
            }else{
                map.put("msg5","0");
                map.put("oracle_path5",bsPath5);
            }
        }else {
            map.put("oracle_path5", "0");
        }
//        Boolean checkUrl = checkUrl(ip, port, path1);
//        if(checkUrl==false){
//            bsMsg = path1+"连接失败，请检查mes框架配置或ip，端口号以及路径是否正确";
//            generalKanBanPageDao.updataByBsMsg(bsMsg, bsMac);
//            return ApiResponseResult.failure(path1+"连接失败，请检查mes框架配置或ip，端口号以及路径是否正确").data(kanBanPage);
//        }
        generalKanBanPageDao.updataByBsMsg(bsMsg, bsMac);
        return ApiResponseResult.success().data(map);
    }


    public Boolean checkUrl(String ip,String port,String path){
        String url = "http://"+ip+":"+port+"/"+path;
        System.out.println("url:"+url);
        boolean flag = false;

        if(null==url||url.length()<=0){
            return flag;
        }
        try{
            HttpURLConnection connection = (HttpURLConnection) new URL(url)
                    .openConnection();
            int state = connection.getResponseCode();
            System.out.println("state: "+state);
            if(state==200){
                flag=true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;
    }


}