package models

import (
	"errors"
	"zhiyuan/pkg/db"

	"github.com/gin-gonic/gin"
)

type WorkNode struct {
	ID         int64         `json:"id" prop:"add:false"`
	Name       string        `json:"name" label:"节点名称" type:"string" prop:"add edit" search:"like"`
	Color      string        `json:"color" label:"节点颜色" type:"string" prop:"add edit"`
	Logo       string        `json:"logo" label:"节点图标" type:"string" prop:"add edit"`
	WorkTypeId int64         `json:"work_type_id" label:"需求工种" type:"int" prop:"edit" default:"0"`
	State      int64         `json:"state" label:"状态" type:"int" prop:"edit" default:"0"`
	OrderAt    int64         `json:"order_at" prop:"add:false select:false"`
	DeletedAt  int64         `json:"deleted_at" prop:"add:false select:false"`
	CreatedAt  int64         `json:"created_at" prop:"add:false select:false"`
	UpdatedAt  int64         `json:"updated_at" prop:"add:false select:false"`
	Processs   []WorkProcess `json:"processs" prop:"ignore"`
	db.BaseModel
}

func (WorkNode) TableName() string {
	return "zy_work_node"
}

func (WorkNode) ListPrivilege(c *gin.Context, data map[string]interface{}, s *db.Select) bool {
	return true
}

func (WorkNode) OnePrivilege(c *gin.Context, id int64) bool {
	return true
}

func (WorkNode) AddPrivilege(c *gin.Context, data map[string]interface{}, post map[string]interface{}) error {
	return nil
}

func (WorkNode) EditPrivilege(c *gin.Context, id int64, data map[string]interface{}, post map[string]interface{}) error {
	return nil
}

func (WorkNode) DelPrivilege(c *gin.Context, id int64) error {
	return nil
}

func (WorkNode) OrderField() string {
	return "order_at"
}

func (WorkNode) Page() bool {
	return false
}

func (WorkNode) Count() bool {
	return true
}

func (a WorkNode) GetOne(where map[string]interface{}, fields []string, retVal interface{}) (*WorkNode, error) {
	if retVal == nil {
		var work_node *WorkNode
		err := db.GetOne(a.TableName(), where, fields, &work_node)
		return work_node, err
	} else {
		err := db.GetOne(a.TableName(), where, fields, retVal)
		return nil, err
	}
}

func (a WorkNode) GetMulti(where map[string]interface{}, fields []string, retVal interface{}) ([]*WorkNode, error) {
	if retVal == nil {
		var work_node []*WorkNode
		err := db.GetMulti(a.TableName(), where, fields, &work_node)
		return work_node, err
	} else {
		err := db.GetMulti(a.TableName(), where, fields, retVal)
		return nil, err
	}
}

func (a WorkNode) GetOneRaw(where map[string]string, param map[string]interface{}, retVal interface{}) (*WorkNode, error) {
	work_node, err := a.GetMultiRaw(where, param, retVal)
	if err != nil {
		return nil, err
	}
	if len(work_node) == 0 {
		return nil, errors.New("empty record2")
	}
	return work_node[0], nil
}

func (a WorkNode) GetMultiRaw(where map[string]string, param map[string]interface{}, retVal interface{}) ([]*WorkNode, error) {
	field := "SELECT * FROM zy_work_node "
	if retVal == nil {
		var work_node []*WorkNode
		err := db.GetMultiRaw(field, where, param, &work_node)
		return work_node, err
	} else {
		err := db.GetMultiRaw(field, where, param, retVal)
		return nil, err
	}
}

func GetWorkNodeModel(id int64) *WorkNode {
	var node *WorkNode
	db.GetModel(map[string]interface{}{"id": id}, &node)
	if node != nil {
		var processs []WorkProcess
		where := map[string]interface{}{"node_id": id, "deleted_at": 0}
		db.GetModel(where, &processs)
		node.Processs = processs
		for i, v := range node.Processs {
			where := map[string]interface{}{"process_id": v.ID, "deleted_at": 0}
			db.GetModel(where, &(node.Processs[i].Requires))
		}
	}
	return node
}

func (model WorkNode) Copy(name string, order int64) (int64, error) {
	id, err := db.InsertModel(db.Type(model), map[string]interface{}{
		"name":         name,
		"color":        model.Color,
		"logo":         model.Logo,
		"work_type_id": model.WorkTypeId,
		"state":        model.State,
		"order_at":     order,
	})
	if err != nil {
		return 0, err
	}
	err = CopyWorkProcesss(model.Processs, id, order)
	if err != nil {
		return id, err
	}
	return id, nil
}