package model

import (
	"errors"
	"github.com/fonchain_enterprise/fonchain-approval/api/approval"
	"github.com/fonchain_enterprise/fonchain-approval/pkg/m"
	"gorm.io/gorm"
	"gorm.io/plugin/soft_delete"
	"time"
)

// Approval 审批
type Approval struct {
	ID            uint64                `gorm:"primaryKey;column:id" json:"id"`             // ID
	DeletedAt     soft_delete.DeletedAt `gorm:"column:deleted_at" json:"deletedAt"`         // 删除时间
	CreatedAt     time.Time             `gorm:"column:created_at" json:"createdAt"`         // 创建时间
	UpdatedAt     time.Time             `gorm:"column:updated_at" json:"updatedAt"`         // 更新时间
	SubmitterID   uint64                `gorm:"column:submitter_id" json:"submitterId"`     // 提交人ID
	ApproverID    uint64                `gorm:"column:approver_id" json:"approverId"`       // 审核人ID
	Status        int8                  `gorm:"column:status" json:"status"`                // 状态0-待 1-可 2-否
	SubmitterName string                `gorm:"column:submitter_name" json:"submitterName"` // 提交人名称缓存
	ApproverName  string                `gorm:"column:approver_name" json:"approverName"`   // 审核人名称缓存
	CopyUsers     CopyUsers             `gorm:"column:copy_users" json:"copyUsers"`         // 抄送人
	Type          string                `gorm:"column:type" json:"type"`                    // 类型
	Content       string                `gorm:"column:content" json:"content"`              // 提交审批内容
	Reply         string                `gorm:"column:reply" json:"reply"`                  // 回复内容
	Domain        *string               `gorm:"column:domain" json:"domain"`                // 环境变量
	Show          *Show                 `gorm:"foreignKey:ApprovalID" json:"Show"`          // 环境变量
	Work          *Work                 `gorm:"foreignKey:ApprovalID" json:"Work"`          // 环境变量
	Bundle        *Bundle               `gorm:"foreignKey:ApprovalID" json:"Bundle"`        // 环境变量
	Exhibition    *Exhibition           `gorm:"foreignKey:ApprovalID" json:"Exhibition"`    // 环境变量
}

const (
	TypeContent    = "content"
	TypeWork       = "work"
	TypeExhibition = "exhibition"
	TypeShow       = "show"
	TypeBundle     = "bundle"
)
const (
	StatusDoing = 0
	StatusOk    = 1
	StatusFail  = 2
)

type ApprovalContentInterface interface {
	SaveApprovalContent(in *approval.CreateRequest, a *Approval) error
	UpdateApprovalContent(in *approval.CreateRequest, a *Approval) error
	BuildResContent(a *Approval, request *approval.CreateRequest)
	DeleteApproval(p *Approval) error
}

// TableName get sql table name.获取数据库表名
func (m *Approval) TableName() string {
	return "approval"
}

func StoreApproval(in *approval.CreateRequest) (*Approval, error) {
	var entity *Approval

	err := DB.Transaction(func(tx *gorm.DB) error {

		// 保存基本信息
		entity = &Approval{
			Domain:        &in.Domain,
			SubmitterID:   in.SubmitterID,
			SubmitterName: in.SubmitterName,
			ApproverID:    in.ApproverID,
			ApproverName:  in.ApproverName,
			CopyUsers:     FormatCopyUsers(in.CopyUsers),
			Type:          in.Type,
			Content:       in.Content,
		}

		if err := DB.Create(&entity).Error; err != nil {
			return err
		}

		// 不同类型保存不同的结构体
		err := entity.SaveContent(in)

		return err
	})

	return entity, err

}

func Viewed(in *approval.ViewedRequest) error {

	var entity *Approval
	var err error

	if err = DB.First(&entity, in.ID).Error; err != nil {
		return errors.New(m.ErrorNotFound)
	}

	copyUsers := entity.CopyUsers

	for i, temp := range copyUsers {
		if temp.ID == in.UserID {
			temp.IsViewed = true
			copyUsers[i] = temp
		}
	}

	return DB.Model(&Approval{}).Where(&Approval{ID: in.ID}).Updates(&Approval{CopyUsers: copyUsers}).Error

}

func UpdateApproval(in *approval.CreateRequest) (*Approval, error) {
	var entity *Approval

	err := DB.Transaction(func(tx *gorm.DB) error {

		if departErr := DB.First(&entity, in.ID).Error; departErr != nil {
			return errors.New(m.ErrorNotFound)
		}

		if entity.Type != in.Type {
			return errors.New(m.ErrorChangeType)
		}

		if entity.Status != StatusDoing {
			return errors.New(m.ErrorWrongStatus)
		} else if in.Status != StatusDoing { //审批
			// 保存基本信息
			entity = &Approval{
				ID:     in.ID,
				Status: int8(in.Status),
				Reply:  in.Reply,
			}

			return DB.Save(&entity).Error
		}

		// 保存基本信息
		entity = &Approval{
			ID: in.ID,
			//Domain:        in.Domain,
			//SubmitterID:   in.SubmitterId,
			//SubmitterName: in.SubmitterName,
			//ApproverID:   in.ApproverId,
			//ApproverName: in.ApproverName,
			//CopyUsers: FormatCopyUsers(in.CopyUsers),
			//Type:          in.Type,
			Content: in.Content,
		}

		if err := DB.Where(&Approval{ID: in.ID}).Updates(&entity).Error; err != nil {
			return err
		}

		// 不同类型保存不同的结构体
		err := entity.UpdateContent(in)

		return err
	})

	return entity, err

}

func approvalCalc(filter *Approval) *approval.Information {

	var num int64

	info := &approval.Information{}

	DB.Model(&Approval{}).Where(&filter).Count(&num)
	info.Total = uint64(num)

	DB.Model(&Approval{}).Where(&filter).Where(&Approval{Status: StatusOk}).Count(&num)
	info.DoingTotal = uint64(num)

	DB.Model(&Approval{}).Where(&filter).Where(&Approval{Status: StatusOk}).Count(&num)
	info.SuccessTotal = uint64(num)

	DB.Model(&Approval{}).Where(&filter).Where(&Approval{Status: StatusFail}).Count(&num)
	info.FailTotal = uint64(num)

	return info
}

// ApprovalInfo 统计
func ApprovalInfo(in *approval.InformationRequest) (*approval.InformationResponse, error) {

	response := &approval.InformationResponse{
		MySubmitInfo: approvalCalc(&Approval{Domain: &in.Domain, SubmitterID: in.UserID}),
		SubmitMeInfo: approvalCalc(&Approval{Domain: &in.Domain, ApproverID: in.UserID}),
		DomainInfo:   approvalCalc(&Approval{Domain: &in.Domain}),
	}

	return response, nil

}

func (m *Approval) SaveApprovalContent(in *approval.CreateRequest, a *Approval) error {
	return nil
}

func (m *Approval) UpdateApprovalContent(in *approval.CreateRequest, a *Approval) error {
	return nil
}

func (m *Approval) DeleteApproval(p *Approval) error {
	return nil
}

func (m *Approval) DeleteContent() error {

	factory, err := GetApprovalContentFactory(m.Type)

	if err != nil {
		return err
	}

	return factory.DeleteApproval(m)
}

func (m *Approval) BuildResContent(a *Approval, request *approval.CreateRequest) {

}

func (m *Approval) SetResContent(request *approval.CreateRequest) error {

	factory, err := GetApprovalContentFactory(m.Type)

	if err != nil {
		return err
	}

	factory.BuildResContent(m, request)

	return nil
}

func (m *Approval) SaveContent(in *approval.CreateRequest) error {

	factory, err := GetApprovalContentFactory(in.Type)
	if err != nil {
		return err
	}

	err = factory.SaveApprovalContent(in, m)

	return err
}

func (m *Approval) UpdateContent(in *approval.CreateRequest) error {

	factory, err := GetApprovalContentFactory(in.Type)
	if err != nil {
		return err
	}

	err = factory.UpdateApprovalContent(in, m)

	return err
}

func ApprovalList(in *approval.ListRequest) ([]*Approval, int64) {
	var list []*Approval
	var count int64

	//list
	modelObj := DB.Model(&Approval{}).
		Preload("Show").
		Preload("Work.ApprovalWorks").
		Preload("Bundle").
		Preload("Exhibition.ApprovalExhibitions")

	if in.Type != "" {
		modelObj = modelObj.Where(&Approval{Type: in.Type})
	}

	if in.Status != 0 {
		modelObj = modelObj.Where(&Approval{Status: int8(in.Status)})
	}

	modelObj.Count(&count)

	modelObj.Limit(int(in.Limit)).Offset(int(in.Offset)).Order("id desc").Find(&list)

	return list, count
}

func GetApprovalContentFactory(typeFiled string) (ApprovalContentInterface, error) {
	switch typeFiled {
	case TypeContent:
		return &Approval{}, nil
	case TypeShow:
		return &Show{}, nil
	case TypeWork:
		return &Work{}, nil
	case TypeBundle:
		return &Bundle{}, nil
	case TypeExhibition:
		return &Exhibition{}, nil
	default:
		return nil, errors.New(m.ErrorApprovalType)
	}
}

// ApprovalColumns get sql column name.获取数据库列名
var ApprovalColumns = struct {
	ID            string
	DeletedAt     string
	CreatedAt     string
	UpdatedAt     string
	SubmitterID   string
	ApproverID    string
	Status        string
	SubmitterName string
	ApproverName  string
	CopyName      string
	Type          string
	Content       string
	Reply         string
	Domain        string
}{
	ID:            "id",
	DeletedAt:     "deleted_at",
	CreatedAt:     "created_at",
	UpdatedAt:     "updated_at",
	SubmitterID:   "submitter_id",
	ApproverID:    "approver_id",
	Status:        "status",
	SubmitterName: "submitter_name",
	ApproverName:  "approver_name",
	CopyName:      "copy_name",
	Type:          "type",
	Content:       "content",
	Reply:         "reply",
	Domain:        "domain",
}