package com.ui.ctrl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.ui.contants.HttpUriContants;
import com.ui.http.HttpRestClient;
import com.ui.model.BaseResponse;
import com.ui.model.domain.DockerProjectModel;
import com.ui.model.req.DockerInfoReq;
import com.ui.model.req.DockerJenkinsReq;
import com.ui.model.req.User;
import com.ui.project.ProjectEnvironment;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

import javax.annotation.PostConstruct;
import javax.servlet.http.HttpSession;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;


@RestController
@RequestMapping("/dockerBuild")
public class DockerBuildCtrl {
    Logger log = LoggerFactory.getLogger(DockerBuildCtrl.class);

    @Autowired
    private HttpRestClient httpRestClient;

    private Map<String,String> dockerClusterMapCache;

    @PostConstruct
    private  Map<String,String> initDockerClusterMap(){
        BaseResponse rtn= httpRestClient.defaultPost("/dockerMonitor/getDockerClusterMap",null,BaseResponse.class);
        if(rtn!=null&&200==rtn.getCode()&&null!=rtn.getData()){
            try{
                dockerClusterMapCache = (Map<String,String>)rtn.getData();
            }catch (Exception e){
                log.error("dockerClusterMapCache get error {}",e);
                dockerClusterMapCache = null;
            }
        }
        return dockerClusterMapCache;
    }

    @RequestMapping("/toProject")
    public ModelAndView toProject(Model model,String workJobId) {
        if(StringUtils.isNotBlank(workJobId)){
          //如果来源工单发布界面
            BaseResponse response = httpRestClient.defaultGet(HttpUriContants.GET_RELEASEWORKJOB_ID + "?id=" + workJobId, BaseResponse.class);
            if(response!=null&&response.getCode()==200&&response.getData()!=null){
                Map map=(Map)response.getData();
                String releaseWorkJob_environment=(String)(map.get("environment")==null?"":map.get("environment"));
                //int releaseWorkJob_enviCount=0;
                if(releaseWorkJob_environment!=null&&releaseWorkJob_environment.length()>0&&!releaseWorkJob_environment.endsWith(",")){
                    releaseWorkJob_environment+=",";
                }
               /* for(String tmp:releaseWorkJob_environment.split(",")){
                    if(tmp!=null&&tmp.length()>0){
                        releaseWorkJob_enviCount++;
                    }
                }*/

                String releaseWorkJob_project =  map.get("project")==null?"":(String)map.get("project");
                if(releaseWorkJob_project!=null&&releaseWorkJob_project.length()>0&&!releaseWorkJob_project.endsWith(",")){
                    releaseWorkJob_project += ",";
                }
                //model.addAttribute("releaseWorkJob_enviCount", releaseWorkJob_enviCount);
                model.addAttribute("releaseWorkJob_environment", releaseWorkJob_environment);
                model.addAttribute("releaseWorkJob_projectType", map.get("projectType")==null?"":(String)map.get("projectType"));
                model.addAttribute("releaseWorkJob_projectDeployType", map.get("projectDeployType")==null?"":(String)map.get("projectDeployType"));
                model.addAttribute("releaseWorkJob_branch", map.get("branch")==null?"":(String)map.get("branch"));
                model.addAttribute("releaseWorkJob_imageFile", map.get("imageFile")==null?"":(String)map.get("imageFile"));
                model.addAttribute("releaseWorkJob_uploadCDN", map.get("uploadCDN")==null?"":String.valueOf(map.get("uploadCDN")));
                model.addAttribute("releaseWorkJob_cdnBranch", map.get("cdnBranch")==null?"":String.valueOf(map.get("cdnBranch")));
                model.addAttribute("releaseWorkJob_project",releaseWorkJob_project);
                model.addAttribute("releaseWorkJob_id", workJobId);
            }
        }
        model.addAttribute("clusters", JSON.toJSONString(this.getDockerClusterMap()));
        model.addAttribute("environments", ProjectEnvironment.getDockerEnvironments(null));
        model.addAttribute("projectTypes", ProjectEnvironment.getDockerProjectTypeMap());
        model.addAttribute("projectDeployTypes", ProjectEnvironment.getProjectDeployTypeMap());
        return new ModelAndView("project/docker_project");
    }

    @RequestMapping("/toBuildView")
    public ModelAndView toBuildView(Model model,String project_id, String project_name,
                                    String environment_name,String clusters_name,String clusters_text,
                                    String operate_name,String project_deploy_type, String branch_name,String image_file_name, String rollbackImageStore,
                                    String workid_name, String buildIds,String failMsg, HttpSession session,String az2AutoSwitchOnlineCheck) {
        List<Map<String,String>> buildInfoList=new ArrayList<>();
        Map mapIds = new HashMap<>();
        mapIds.put("ids",project_id);
        BaseResponse response=httpRestClient.defaultGet("/dockerProject/getDockerProjectMapByIds", BaseResponse.class, mapIds);
        Map projectMap=JSON.parseObject((String)response.getData(),Map.class);

        if("deploy".equalsIgnoreCase(operate_name)&&"git".equals(project_deploy_type)){
            for(String buildIdWithProjectId:buildIds.split(",")){
                int index = buildIdWithProjectId.indexOf("-");
                String projectId=buildIdWithProjectId.substring(0,index);
                String buildId=buildIdWithProjectId.substring(index+1);
                Map map=new HashMap();
                map.put("projectId",projectId);
                map.put("buildId",buildId);
                map.put("projectName",buildId.substring(0,buildId.lastIndexOf("-")));
                map.put("projectInfo",projectMap.get(Integer.parseInt(projectId)));
                buildInfoList.add(map);
            }
        }else{
            //回滚 或者 镜像文件发布
            String projectId=project_id;
            Map map=new HashMap();
            map.put("projectId",projectId);
            map.put("projectName",project_name);
            map.put("projectInfo",projectMap.get(Integer.parseInt(projectId)));
            buildInfoList.add(map);
        }

        model.addAttribute("az2AutoSwitchOnlineCheck", StringUtils.isBlank(az2AutoSwitchOnlineCheck)?"":az2AutoSwitchOnlineCheck);
        if(StringUtils.isNotBlank(az2AutoSwitchOnlineCheck)){
            model.addAttribute("az2AutoSwitchOnlineCheck_project", project_name);
        }else{
            model.addAttribute("az2AutoSwitchOnlineCheck_project", "");
        }

        model.addAttribute("environment_name", environment_name);
        model.addAttribute("clusters_name", clusters_name);
        model.addAttribute("clusters_text", clusters_text);
        model.addAttribute("operate_name", operate_name);
        model.addAttribute("branch_name", branch_name);
        model.addAttribute("project_deploy_type", project_deploy_type);
        model.addAttribute("image_file_name", image_file_name);
        model.addAttribute("workid_name", workid_name);
        model.addAttribute("rollbackfile_name", rollbackImageStore);
        model.addAttribute("buildIds", buildIds);
        model.addAttribute("failMsg", failMsg);
        model.addAttribute("buildInfoList",JSONArray.toJSON(buildInfoList));

        return new ModelAndView("project/docker_build");
    }



    @RequestMapping("/toBuildViewNew")
    public ModelAndView toBuildViewNew(Model model,String project_id,String environment_name, String image_file_name,
                                       String branch_name,String workid_name, String buildId, HttpSession session) {
        List<Map<String,String>> buildInfoList=new ArrayList<>();
        Map mapIds = new HashMap<>();
        mapIds.put("ids",project_id);
        BaseResponse response=httpRestClient.defaultGet("/dockerProject/getDockerProjectMapByIds", BaseResponse.class, mapIds);
        Map projectMap=JSON.parseObject((String)response.getData(),Map.class);
        Map map=new HashMap();
        map.put("projectId",project_id);
        map.put("buildId",buildId);
        map.put("projectInfo",projectMap.get(Integer.parseInt(project_id)));
        buildInfoList.add(map);

        model.addAttribute("environment_name", environment_name);
        model.addAttribute("clusters_name","");
        model.addAttribute("clusters_text", "");
        model.addAttribute("operate_name", "DEPLOY");
        model.addAttribute("branch_name", branch_name);
        model.addAttribute("project_deploy_type", "");
        model.addAttribute("image_file_name", image_file_name);
        model.addAttribute("workid_name", workid_name);
        model.addAttribute("rollbackfile_name", "");
        model.addAttribute("buildIds", buildId);
        model.addAttribute("failMsg", "");
        model.addAttribute("buildInfoList",JSONArray.toJSON(buildInfoList));
        return new ModelAndView("project/docker_build");
    }


    /**
     * 把node项目的az2区域切换到gray
     * @env 发布环境 ，拦截器记录操作日志用
     * @branch 分支  ，拦截器记录操作日志用
     * @return
     */
    @RequestMapping(value = "/switchDockerNodeAz2")
    @ResponseBody
    public BaseResponse switchDockerNodeAz2(String project_name,String onlineOrGray,String env,String branch) {
        if(!"online".equals(onlineOrGray)&&!"gray".equals(onlineOrGray)){
            return new BaseResponse(201,"不支持参数onlineOrGray："+onlineOrGray);
        }
        String projectType;
        String inGrayKey;
        if("yohoblk-wap".equals(project_name)){
            projectType="blk";
            inGrayKey="inGray_blk";
        }else if("yohobuywap-node".equals(project_name)){
            projectType="wap";
            inGrayKey="inGray_wap";
        }else if("yohobuy-node".equals(project_name)){
            projectType="pc";
            inGrayKey="inGray_pc";
        }else{
            return new BaseResponse(201,"不支持参数："+project_name);
        }

        BaseResponse queryStatusResponse=httpRestClient.defaultGet("/pch5DockerSwitch/getDockerElbStatus", BaseResponse.class);
        if(queryStatusResponse!=null&&queryStatusResponse.getCode()==200){
            Map<String,Object> resultMap=(Map<String,Object>)queryStatusResponse.getData();
            if(resultMap.containsKey(inGrayKey)){
                boolean inGray=(Boolean)resultMap.get(inGrayKey);
                if("gray".equals(onlineOrGray)&&inGray){
                    //目标是切换到灰度，当前已经是灰度了，所以直接返回
                    return new BaseResponse();
                }

                if("online".equals(onlineOrGray)&&inGray==false){
                    //目标是切换到online，当前已经关闭灰度了，所以直接返回
                    return new BaseResponse();
                }
            }
        }

        Map map = new HashMap<>();
        map.put("projectType",projectType);
        map.put("onlineOrGray",onlineOrGray);
        BaseResponse response=httpRestClient.defaultGet("/pch5DockerSwitch/switchDockerAz2", BaseResponse.class, map);
        return response;
    }

    /**
     * 获取所有项目
     *
     * @return
     */
    @RequestMapping(value = "/getProjects")
    @ResponseBody
    public String getProjects(String projectType) {
        try {
            BaseResponse response=this.getDockerProjectsByType(projectType);
            return JSONArray.toJSON(response.getData()).toString();
        } catch (Exception ex) {
            return "failed";
        }
    }

    public BaseResponse getDockerProjectsByType(String projectType){
        Map map = new HashMap<>();
        map.put("projectType",projectType);
        BaseResponse response=httpRestClient.defaultGet("/dockerProject/getDockerProjectByProjectType", BaseResponse.class, map);
        return response;
    }


    @RequestMapping(value = "/getDeployImageList")
    @ResponseBody
    public String getDeployImageList(String projectId, String environment) {
        try {
            Map<String, String> map = new HashMap<>();
            map.put("projectId", projectId);
            map.put("environment", environment);
            return httpRestClient.defaultGet("/dockerProject/getDeployImageList", String.class, map);
        } catch (Exception ex) {
            return "false";
        }
    }

    @RequestMapping(value = "/getRollbackList")
    @ResponseBody
    public String getRollbackList(String projectId, String environment) {
        try {
            Map<String, String> map = new HashMap<>();
            map.put("projectId", projectId);
            map.put("environment", environment);
            return httpRestClient.defaultGet("/dockerProject/getRollbackList", String.class, map);
        } catch (Exception ex) {
            return "failed";
        }
    }
    /**
     * rollback项目
     **/
    @RequestMapping(value = "/rollback")
    @ResponseBody
    public BaseResponse deployByImageStore(String workId,String project_id, String environment_name, String clusters_name,String rollbackImageStore,String deployOrRollback){
        Map<String, String> map = new HashMap<>();
        map.put("workId", workId);
        map.put("projectId", project_id);
        map.put("environment", environment_name);
        map.put("clusters_name", clusters_name);
        map.put("rollbackImageStore", rollbackImageStore);
        if(StringUtils.isBlank(deployOrRollback)){
            map.put("operateType", "rollback");
        }else{
            map.put("operateType", deployOrRollback);
        }
        return httpRestClient.defaultGet(HttpUriContants.DOCKER_DEPLOY_ROLLBACK_BY_IMAGE, BaseResponse.class, map);
    }

    /**
     * deploy项目
     *
     * @return
     */
    @RequestMapping(value = "/jenkinsDeploy")
    @ResponseBody
    public BaseResponse jenkinsDeploy(String project_id,String workid_name,
                                        String environment_name,String image_file_name,String branch_name) {
        Map<String, String> map = new HashMap<>();
        map.put("projectId", project_id);
        map.put("environment", environment_name);
        map.put("rollbackImageStore", image_file_name);
        map.put("branchName", branch_name);
        map.put("workId", workid_name);
        return httpRestClient.defaultGet(HttpUriContants.DOCKER_DEPLOY_JENKINS_DEPLOY, BaseResponse.class, map);
    }



    /**
     * deploy项目
     *
     * @return
     */
    @RequestMapping(value = "/mirrorAndDeploy")
    @ResponseBody
    public BaseResponse mirrorAndDeploy(String project_id, String project_name,
                                        String environment_name,String clusters_name, String operate_name,String project_deploy_type,
                                        String branch_name,String image_file_name,
                                        String rollbackfile_name,String workid_name,int uploadCDN,String cdnBranch, Model model, HttpSession session) {
        User user = (User) session.getAttribute("user");
        String userName=user.getName();
        String userEmail=user.getEmail();
        if("image".equals(project_deploy_type)){
            /*if(1==uploadCDN){
                //发布异步任务
                CompletableFuture.runAsync(new Runnable() {
                   @Override
                   public void run() {
                       Map<String,String> param=new HashMap<>();
                       param.put("projectId",project_id);
                       param.put("cdnBranch",cdnBranch);
                       param.put("workid_name",workid_name);
                       param.put("operatorEmail",userEmail);
                       httpRestClient.defaultGet("/dockerProject/uploadCDN",BaseResponse.class,param);
                   }
                });
            }*/
            return deployByImageStore(workid_name,project_id,environment_name,clusters_name,image_file_name,"deploy");
        }
        DockerJenkinsReq dockerJenkinsReq=new DockerJenkinsReq();
        dockerJenkinsReq.setUserName(userName);
        dockerJenkinsReq.setUserMail(userEmail);
        dockerJenkinsReq.setProjectIds(project_id);
        dockerJenkinsReq.setNodeEnv(environment_name);
        dockerJenkinsReq.setClusterId(clusters_name);
        dockerJenkinsReq.setBranch(branch_name);
        dockerJenkinsReq.setReleaseWorkId(workid_name);
        if("deploy".equalsIgnoreCase(operate_name)){
                return httpRestClient.defaultPost("/dockerProject/mirrorAndDeploy",dockerJenkinsReq,BaseResponse.class);
        }
        BaseResponse rtnBaseResponse=new BaseResponse(201);
        rtnBaseResponse.setMessage("暂不支持的操作："+operate_name);
        return rtnBaseResponse;
    }

    /**
     * 镜像制作
     */
    @RequestMapping(value = "/queryJenkinsStatus")
    @ResponseBody
    public BaseResponse queryJenkinsStatus(String buildId) {
        Map map = new HashMap<>();
        map.put("id",buildId);
        BaseResponse response=httpRestClient.defaultGet("/dockerProject/queryJenkinsStatus", BaseResponse.class, map);
        return response;
    }

    /**
     * qq发布
     */
    @RequestMapping(value = "/queryDockerServerStatus")
    @ResponseBody
    public BaseResponse queryDockerServerStatus(DockerJenkinsReq dockerJenkinsReq) {
        BaseResponse rtn= httpRestClient.defaultPost("/dockerProject/queryDockerServerStatus",dockerJenkinsReq,BaseResponse.class);
        if(rtn!=null&&200==rtn.getCode()){
            Map<String,Object> map= (Map<String,Object>)rtn.getData();
            Map<String,String> descMap = (Map<String,String>)map.get("resultDescMap");
            Map<String,String> clusterMap=this.getDockerClusterMap();
            StringBuilder sb=new StringBuilder();
            for(String key:descMap.keySet()){
                sb.append(clusterMap.get(key)).append(":").append(descMap.get(key)).append(";");
            }
            map.put("resultMessage",sb.toString());
        }
        return rtn;
    }

    public  Map<String,String> getDockerClusterMap(){
        if(dockerClusterMapCache==null){
            return initDockerClusterMap();
        }
        return dockerClusterMapCache;
        //BaseResponse rtn= httpRestClient.defaultPost("/dockerMonitor/getDockerClusterMap",null,BaseResponse.class);
        //return (Map<String,String>)rtn.getData();
    }



    @RequestMapping(value = "/toDockerInfoList")
    public ModelAndView toDockerInfoList(Model model,DockerJenkinsReq dockerJenkinsReq) {
        model.addAttribute("clusters", JSON.toJSONString(this.getDockerClusterMap()));
        model.addAttribute("projectTypes", ProjectEnvironment.getDockerProjectTypeMap());
        model.addAttribute("projectJobTypes", httpRestClient.defaultGet("/dockerProject/getDockerProjectJobType",BaseResponse.class).getData());
        return new ModelAndView("project/docker_info");
    }

    /**
     * docker信息列表
     * @param req
     * @return
     * @throws Exception
     */
    @RequestMapping("/getDockerInfoList")
    @ResponseBody
    public BaseResponse getHostInfos(DockerInfoReq req) throws Exception {
        BaseResponse response = httpRestClient.defaultPost(HttpUriContants.DOCKER_INFO_LIST, req, BaseResponse.class);
        return response;
    }


    @RequestMapping("/toEditDockerInfo")
    public ModelAndView toEditDockerInfos(Model model) {
        model.addAttribute("clusters", this.getDockerClusterMap());
        model.addAttribute("projectTypes", ProjectEnvironment.getDockerProjectTypeMap());
        model.addAttribute("projectDeployTypes", ProjectEnvironment.getProjectDeployTypeMap());
        model.addAttribute("projectJobTypes", httpRestClient.defaultGet("/dockerProject/getDockerProjectJobType",BaseResponse.class).getData());
        return new ModelAndView("project/editDockerInfo");
    }


    @RequestMapping("/saveDockerInfo")
    @ResponseBody
    public BaseResponse saveDockerInfo(@RequestBody  DockerProjectModel req) throws Exception {
        BaseResponse response = httpRestClient.defaultPost(HttpUriContants.ADDORUPDATE_DOCKER_INFO, req, BaseResponse.class);
        return response;
    }


    @RequestMapping("/getDockerInfoById")
    @ResponseBody
    public BaseResponse getDockerInfoById(int id) throws Exception {
        BaseResponse response = httpRestClient.defaultGet(HttpUriContants.GET_DOCERK_INFO_BY_ID + "?id=" + id, BaseResponse.class);
        return response;
    }

    @RequestMapping("/delDockerInfoById")
    @ResponseBody
    public BaseResponse<Integer> delDockerInfoById(int id) throws Exception {
        BaseResponse response = httpRestClient.defaultGet(HttpUriContants.DEL_DOCKER_INFO_BYID + "?id=" + id, BaseResponse.class);
        return response;
    }
}