package validationtool

import (
	"ERP_storage/logs"
	"encoding/json"
	"fmt"
	"github.com/beego/beego/v2/adapter/orm"
	orm2 "github.com/beego/beego/v2/client/orm"
	"gogs.baozhida.cn/zoie/ERP_libs/lib"
	"time"
)

const (
	TransferPending   = "pending"   // 待确认
	TransferCompleted = "completed" // 已完成
	TransferCanceled  = "canceled"  // 已取消

)

// 验证工具转移记录
type ValidationToolTransfer struct {
	Id              int       `orm:"column(id);size(11);auto;pk"`
	TransferSn      string    `orm:"type(text);null"`                                       // 设备sn列表(JSON字符串)
	TransferUser    string    `orm:"size(256);null"`                                        // 转移人
	AcceptedUser    string    `orm:"size(256);null"`                                        // 接收人
	TransferUserUid string    `orm:"size(256);null"`                                        // 转移人uuid
	AcceptedUserUid string    `orm:"size(256);null"`                                        // 接收人uuid
	Status          string    `orm:"size(20);null"`                                         // 状态：pending-待确认，completed-已完成，canceled-已取消
	AcceptedNumber  int       `orm:"size(11);null"`                                         // 接收数量
	TransferRemark  string    `orm:"type(text);null"`                                       // 转移备注
	AcceptedRemark  string    `orm:"type(text);null"`                                       // 接收备注
	CreateTime      time.Time `orm:"column(create_time);type(timestamp);null;auto_now_add"` // 创建时间
	UpdateTime      time.Time `orm:"column(update_time);type(timestamp);null;auto_now"`     // 更新时间
	AcceptedSn      string    `orm:"type(text);null"`                                       // 实际接收的SN列表(JSON字符串)
	AcceptedTime    time.Time `orm:"column(accepted_time);type(timestamp);null"`            // 创建时间

}

func (t *ValidationToolTransfer) TableName() string {
	return "validation_tool_transfer"
}

type ValidationToolTransfer_R struct {
	Id             int
	TransferSn     []string
	AcceptedSn     []string
	TransferUser   string
	AcceptedUser   string
	Status         string
	TransferRemark string
	AcceptedRemark string
	CreateTime     string
	AcceptedTime   string
	AcceptedNumber int
	TransferNumber int
}

func ValidationToolTransferTo_R(v ValidationToolTransfer) (r ValidationToolTransfer_R) {
	r.Id = v.Id
	var TransferSn, AcceptedSn []string
	err := json.Unmarshal([]byte(v.TransferSn), &TransferSn)
	fmt.Println(err)
	r.TransferSn = TransferSn
	_ = json.Unmarshal([]byte(v.AcceptedSn), &AcceptedSn)
	r.AcceptedSn = AcceptedSn
	r.TransferUser = v.TransferUser
	r.AcceptedUser = v.AcceptedUser
	r.TransferNumber = len(r.TransferSn)
	r.AcceptedNumber = v.AcceptedNumber
	r.Status = v.Status
	r.TransferRemark = v.TransferRemark
	r.AcceptedRemark = v.AcceptedRemark
	r.CreateTime = v.CreateTime.Format("2006-01-02 15:04")
	if v.AcceptedTime.IsZero() {
		r.AcceptedTime = "-"
	} else {
		r.AcceptedTime = v.AcceptedTime.Format("2006-01-02 15:04")

	}
	return
}

// 获取单条转移记录
func (dao *ValidationToolTransferImpl) GetTransferRecordByID(id int) (transfer ValidationToolTransfer, err error) {
	transfer.Id = id
	err = dao.orm.Read(&transfer)
	return
}

// 确认转移，更新状态和接收的SN列表
func (dao *ValidationToolTransferImpl) ConfirmTransfer(id int, acceptedSNsJSON string) (err error) {
	transfer := ValidationToolTransfer{Id: id}
	if err = dao.orm.Read(&transfer); err == nil {
		transfer.Status = "completed"
		transfer.AcceptedSn = acceptedSNsJSON
		_, err = dao.orm.Update(&transfer, "Status", "AcceptedSn", "UpdateTime")
	}
	return err
}

type ValidationToolTransferImpl struct {
	orm orm.Ormer
}

func NewValidationToolTransfer(orm orm.Ormer) *ValidationToolTransferImpl {
	return &ValidationToolTransferImpl{orm: orm}
}

func init() {
	//注册模型
	orm.RegisterModel(new(ValidationToolTransfer))
}

// 添加转移记录
func (dao *ValidationToolTransferImpl) Add(transfer *ValidationToolTransfer) (id int64, err error) {
	id, err = dao.orm.Insert(transfer)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	return id, err
}

func (dao *ValidationToolTransferImpl) Update(r ValidationToolTransfer, cols ...string) (err error) {
	_, err = dao.orm.Update(&r, cols...)
	if err != nil {
		logs.Error(lib.FuncName(), err)
	}
	return err
}

// 获取接收人的待接收记录
func (dao *ValidationToolTransferImpl) GetTransferRecordsByUser(userUUID, status string, page, page_z int) (list []ValidationToolTransfer_R, cnt int64) {

	qs := dao.orm.QueryTable(new(ValidationToolTransfer))

	var offset int64
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}

	// 过滤
	cond := orm.NewCondition()
	cond = cond.And("TransferUserUid", userUUID)

	if len(status) > 0 {

		cond = cond.And("Status", status)
	}

	// 查询
	var records []ValidationToolTransfer
	_, err := qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond)).OrderBy("-Id").All(&records)

	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}

	cnt, err = qs.SetCond((*orm2.Condition)(cond)).Count()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}

	for _, m := range records {
		list = append(list, ValidationToolTransferTo_R(m))
	}
	return list, cnt
}
func (dao *ValidationToolTransferImpl) GetAcceptedRecordsByUser(userUUID, status string, page, page_z int) (list []ValidationToolTransfer_R, cnt int64) {

	qs := dao.orm.QueryTable(new(ValidationToolTransfer))

	var offset int64
	if page <= 1 {
		offset = 0
	} else {
		offset = int64((page - 1) * page_z)
	}

	// 过滤
	cond := orm.NewCondition()
	cond = cond.And("AcceptedUserUid", userUUID).AndNot("Status", TransferCanceled)

	if len(status) > 0 {
		cond = cond.And("Status", status)
	}

	// 查询
	var records []ValidationToolTransfer
	_, err := qs.Limit(page_z, offset).SetCond((*orm2.Condition)(cond)).OrderBy("-Id").All(&records)

	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}

	cnt, err = qs.SetCond((*orm2.Condition)(cond)).Count()
	if err != nil {
		logs.Error(lib.FuncName(), err)
		return
	}

	for _, m := range records {
		list = append(list, ValidationToolTransferTo_R(m))
	}
	return list, cnt
}

// 根据设备SN获取未完成的转移记录
func (dao *ValidationToolTransferImpl) GetPendingTransferById(TransferId int) (transfer ValidationToolTransfer, err error) {
	sql := "SELECT * FROM validation_tool_transfer WHERE id = ? AND status = 'pending' ORDER BY create_time DESC LIMIT 1"
	err = dao.orm.Raw(sql, TransferId).QueryRow(&transfer)
	return transfer, err
}