// Package manager ...
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 9:39 下午 2021/8/8
package manager

import (
	"errors"
	"fmt"
	"time"

	"git.zhangdeman.cn/zhangdeman/center-config/dao"
	"git.zhangdeman.cn/zhangdeman/center-config/define/model"

	"git.zhangdeman.cn/zhangdeman/center-config/define/form"
	"github.com/gin-gonic/gin"
)

type namespace struct {
	base
}

// Create 创建命名空间
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 2:18 下午 2021/8/9
func (n *namespace) Create(createForm *form.CreateNamespace) error {
	var (
		err           error
		namespaceInfo *model.Namespace
	)

	// 查询namespace是否已经存在
	if _, err = dao.Namespace.GetDetailByNamespace(createForm.Namespace); nil == err {
		return errors.New("namespace " + createForm.Namespace + " is already exist!")
	}

	// 写库
	tx := dao.Namespace.Begin()
	if nil != tx.Error {
		return tx.Error
	}

	// 创建命名空间
	namespaceInfo = &model.Namespace{
		Namespace:    createForm.Namespace,
		Name:         createForm.Name,
		Description:  createForm.Description,
		Status:       model.NamespaceStatusWaitActive,
		CreateUserID: createForm.CreateUserID,
		ModifyUserID: createForm.CreateUserID,
		CreateTime:   time.Now().Format("2006-01-02 15:04:05"),
		ModifyTime:   time.Now().Format("2006-01-02 15:04:05"),
	}
	if err = dao.Namespace.CreateNewData(tx, namespaceInfo, &dao.Option{DBTable: "namespace"}); nil != err {
		_ = dao.Namespace.Rollback(tx)
		return err
	}

	// 记录日志
	logData := n.GetLogData(namespaceInfo.ID, 0, namespaceInfo.CreateUserID, model.LogTypeCreateNamespace, "新建命名空间")
	logData.AfterValue = namespaceInfo.Namespace
	if err = dao.Log.CreateNewData(tx, logData, &dao.Option{DBTable: "log"}); nil != err {
		_ = dao.Namespace.Rollback(tx)
		return err
	}

	if err = dao.Namespace.Commit(tx); nil != err {
		_ = dao.Namespace.Rollback(tx)
		return err
	}

	return nil
}

// ValidateCreateForm 创建命名空间表单校验与预处理
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 2:36 下午 2021/8/9
func (n *namespace) ValidateCreateForm(ctx *gin.Context) (*form.CreateNamespace, error) {
	var (
		err        error
		createForm form.CreateNamespace
	)
	if err = n.ParsePostForm(ctx, &createForm); nil != err {
		return nil, err
	}
	// 表单校验
	if len(createForm.Namespace) == 0 {
		return nil, errors.New("namespace field is required")
	}
	if len(createForm.Name) == 0 {
		return nil, errors.New("name field is required")
	}
	if len(createForm.Description) == 0 {
		createForm.Description = createForm.Name
	}
	if len(createForm.CreateUserID) == 0 {
		return nil, errors.New("create_user_id field is required")
	}
	// 表单校验 end
	return &createForm, nil
}

// Active 激活命名空间
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 9:14 下午 2021/8/9
func (n *namespace) Active(activeForm *form.ActiveNamespace) error {
	if activeForm.NamespaceID <= 0 {
		activeForm.NamespaceID = n.GetNamespaceIDByNamespace(activeForm.Namespace)
	}
	var err error
	tx := dao.Namespace.Begin()
	if nil != tx.Error {
		return tx.Error
	}
	if err = dao.Namespace.UpdateData(tx, &model.Namespace{Status: model.NamespaceStatusNormal}, map[string]interface{}{"id": activeForm.NamespaceID, "status": model.NamespaceStatusWaitActive}, &dao.Option{Limit: 1, DBTable: "namespace"}); nil != err {
		_ = dao.Namespace.Rollback(tx)
		return err
	}
	logData := n.GetLogData(activeForm.NamespaceID, 0, activeForm.UpdateUserID, model.LogTypeActiveNamespace, "激活命名空间")
	logData.BeforeValue = fmt.Sprintf("%v", model.NamespaceStatusWaitActive)
	logData.AfterValue = fmt.Sprintf("%v", model.NamespaceStatusNormal)
	if err = dao.Log.CreateNewData(tx, logData, nil); nil != err {
		_ = dao.Namespace.Rollback(tx)
		return err
	}

	if err = dao.Namespace.Commit(tx); nil != err {
		_ = dao.Namespace.Rollback(tx)
		return err
	}
	return nil
}

// ValidateActiveForm 验证激活命名空间表单
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 9:14 下午 2021/8/9
func (n *namespace) ValidateActiveForm(ctx *gin.Context) (*form.ActiveNamespace, error) {
	var (
		err        error
		updateForm form.ActiveNamespace
	)
	if err = n.ParsePostForm(ctx, &updateForm); nil != err {
		return nil, err
	}

	if updateForm.NamespaceID <= 0 {
		if namespaceDetail, err := dao.Namespace.GetDetailByNamespace(updateForm.Namespace); nil == err {
			updateForm.NamespaceID = namespaceDetail.ID
		}
	}
	if updateForm.NamespaceID <= 0 {
		return nil, errors.New("namespace_id is required")
	}

	if len(updateForm.UpdateUserID) == 0 {
		return nil, errors.New("update_user_id is required")
	}
	return &updateForm, nil
}

// GetNamespaceDetail 获取namespace详情
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 12:07 上午 2021/8/10
func (n *namespace) GetNamespaceDetail(namespaceID int64, namespaceName string) (*model.Namespace, error) {
	var (
		namespaceInfo model.Namespace
		err           error
	)
	// 查询namespace
	if namespaceID > 0 {
		err = dao.Namespace.Detail(dao.DBInstance, &model.Namespace{ID: namespaceID}, &namespaceInfo, nil)
	} else {
		err = dao.Namespace.Detail(dao.DBInstance, &model.Namespace{Namespace: namespaceName}, &namespaceInfo, nil)
	}
	return &namespaceInfo, err
}

// GetAllNormalNamespace 获取
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 9:51 下午 2021/8/10
func (n *namespace) GetAllNamespaceByStatus(status int) ([]*model.Namespace, error) {
	var (
		list []*model.Namespace
		err  error
	)
	if err = dao.Namespace.Select(dao.DBInstance, &model.Namespace{Status: status}, &list, nil); nil != err {
		return make([]*model.Namespace, 0), err
	}
	return list, nil
}