package system

import (
	"bytes"
	"encoding/json"
	err1 "errors"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/controller"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/controller/v1/app_manage"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/model"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/model/app_manage/node"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/model/app_manage/workspace_env"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/pkg/errors"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/pkg/request"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/service"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/service/app_manage/common"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/validator"
	"github.com/gin-gonic/gin"
	"strings"
)

func EditWorkspaceEnv(c *gin.Context) {
	w := &workspace_env.WorkspaceEnvVar{}
	err := validator.CheckPostParams(c, w)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}

	if w.Id == "" {
		if w.Name == "" || w.Value == "" {
			controller.FailCode(c, errors.InvalidParameter, nil, "请检查参数！")
		}
		err = checkInfo(w.Name, w.WorkspaceId)
		if err != nil {
			controller.FailCode(c, errors.InvalidParameter, err, err.Error())
			return
		}
		w.SetUserName(service.GetUserName(c))
		_, err = w.Create(w)
		if err != nil {
			controller.FailCode(c, errors.ServerError, err, "内部错误！")
			return
		}

		if w.NodeIds == "" {
			return
		}
		err = syncUpdateNodeEnvVar(w, strings.Split(w.NodeIds, ","))
		if err != nil {
			controller.FailCode(c, errors.ServerError, err, "内部错误！")
			return
		}
	} else {
		w1 := &workspace_env.WorkspaceEnvVar{}
		w1.Id = w.Id
		err = w1.GetById(w1)
		if err != nil {
			controller.FailCode(c, errors.ServerError, err, "数据不存在！")
			return
		}
		if w1.Privacy == 0 && w.Value == "" {
			controller.FailCode(c, errors.InvalidParameter, nil, "请检查参数！")
		}
		w1.Description = w.Description
		if w.Value != "" {
			w1.Value = w.Value
		}
		w1.Name = w.Name
		oldNodeIds := w1.NodeIds
		w1.NodeIds = w.NodeIds
		w1.SetModifyUserName(service.GetUserName(c))
		_, err = w.Update(w1, nil)
		if err != nil {
			controller.FailCode(c, errors.ServerError, err, "内部错误！")
			return
		}
		if w.NodeIds != "" {
			newNodeIdArray := strings.Split(w.NodeIds, ",")
			if oldNodeIds != "" && oldNodeIds != w.NodeIds {
				var delNodeIds []string
				oldNodeIdArray := strings.Split(oldNodeIds, ",")
				for _, oldId := range oldNodeIdArray {
					find := false
					for _, newId := range newNodeIdArray {
						if oldId == newId {
							find = true
							break
						}
					}
					if !find {
						delNodeIds = append(delNodeIds, oldId)
					}
				}
				if len(delNodeIds) > 0 {
					err = syncDelNodeEnvVar(w1.Name, delNodeIds)
					if err != nil {
						controller.FailCode(c, errors.ServerError, err, "删除节点变量异常！")
						return
					}
				}
			}
			err = syncUpdateNodeEnvVar(w, strings.Split(w.NodeIds, ","))
			if err != nil {
				controller.FailCode(c, errors.ServerError, err, "更新节点变量异常！")
				return
			}
		} else {
			if oldNodeIds != "" {
				err = syncDelNodeEnvVar(w1.Name, strings.Split(oldNodeIds, ","))
				if err != nil {
					controller.FailCode(c, errors.ServerError, err, "删除节点变量异常！")
					return
				}
			}
		}
	}

	controller.Success(c, "")
}

func syncUpdateNodeEnvVar(w *workspace_env.WorkspaceEnvVar, nodeIds []string) error {
	if len(nodeIds) == 0 {
		return nil
	}
	form := make(map[string]interface{}, 1)
	form["name"] = w.Name
	form["value"] = w.Value
	form["description"] = w.Description
	form["privacy"] = w.Privacy
	jsonBody, _ := json.Marshal(form)

	for _, nodeId := range nodeIds {
		n := &node.Node{}
		n.Id = nodeId
		err := n.GetById(n)
		if err != nil {
			return err1.New("数据不存在")
		}
		resp, err := common.Request5(n, common.Workspace_EnvVar_Update, bytes.NewReader(jsonBody))
		if err != nil {
			return err
		}
		if !resp.IsBusinessSuccess() {
			return err1.New(resp.Result.Msg)
		}
	}
	return nil
}

func syncDelNodeEnvVar(name string, nodeIds []string) error {
	if len(nodeIds) == 0 {
		return nil
	}
	body := make(map[string]string, 1)
	body["name"] = name
	jsonBody, _ := json.Marshal(body)
	for _, nodeId := range nodeIds {
		n := &node.Node{}
		n.Id = nodeId
		err := n.GetById(n)
		if err != nil {
			return err1.New("数据不存在")
		}
		resp, err := common.Request5(n, common.Workspace_EnvVar_Delete, bytes.NewReader(jsonBody))
		if err != nil {
			return err
		}
		if !resp.IsBusinessSuccess() {
			return err1.New(resp.Result.Msg)
		}
	}
	return nil
}

func checkInfo(name, workspaceId string) error {
	w := workspace_env.New()
	fields := make(map[string]interface{}, 2)
	fields["name"] = name
	if workspaceId != "GLOBAL" {
		fields["workspace_id"] = []string{workspaceId, "GLOBAL"}
	}
	result, _ := w.GetAll(w, fields, nil)
	if len(result.([]workspace_env.WorkspaceEnvVar)) > 0 {
		return err1.New("数据已存在")
	}
	return nil
}

func DeleteWorkspaceEnv(c *gin.Context) {
	id := c.Query("id")
	if id == "" {
		controller.FailCode(c, errors.InvalidParameter, nil, "请检查参数！")
		return
	}
	w := &workspace_env.WorkspaceEnvVar{}
	w.Id = id
	err := w.GetById(w)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "无法查找到对象！")
		return
	}

	if w.NodeIds != "" {
		err = syncDelNodeEnvVar(w.Name, strings.Split(w.NodeIds, ","))
		if err != nil {
			controller.FailCode(c, errors.ServerError, err, "删除节点变量异常！")
			return
		}
	}

	_, err = w.Delete(w)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}

	controller.Success(c, "")
}

type WorkspaceEnvPageBody struct {
	PageInfo    *request.PageInfo `json:"pageInfo" binding:"required"`
	WorkspaceId string            `json:"workspaceId"`
	Name        string            `json:"name"`
	Value       string            `json:"value"`
	Description string            `json:"description"`
}

func PageWorkspaceEnvs(c *gin.Context) {
	var pageBody WorkspaceEnvPageBody
	err := c.ShouldBindJSON(&pageBody)
	if err != nil {
		controller.FailCode(c, errors.InvalidParameter, err, "请检查参数！")
		return
	}
	if pageBody.WorkspaceId == "" {
		controller.FailCode(c, errors.InvalidParameter, nil, "请检查参数！")
		return
	}
	w := workspace_env.New()
	fields := map[string]interface{}{}
	workspaceId := app_manage.GetWorkspaceId(c)
	if len(workspaceId) == 0 {
		split := strings.Split(pageBody.WorkspaceId, ",")
		fields["workspace_id"] = split
	} else {
		fields["workspace_id"] = []string{workspaceId, "GLOBAL"}
	}

	if pageBody.Name != "" {
		fields["name"] = pageBody.Name
	}
	if pageBody.Value != "" {
		fields["value"] = pageBody.Value
	}
	if pageBody.Description != "" {
		fields["description"] = pageBody.Description
	}
	page := &model.PageConfig{}
	page.Covert(pageBody.PageInfo)
	tResult, err := w.Page(w, page, fields)
	if err != nil {
		controller.FailCode(c, errors.ServerError, err, "内部错误！")
		return
	}
	result := tResult.([]workspace_env.WorkspaceEnvVar)
	if result != nil && len(result) > 0 {
		for i := range result {
			if result[i].Privacy == 1 {
				result[i].Value = ""
			}
		}
	}
	page.Data = result
	controller.Success(c, page)
}