package service

import (
	"strings"
	"time"
	"twin-api/app/admin/request"
	"twin-api/app/common/dao"
	"twin-api/app/common/model"
	"twin-api/base/config"

	gsUtils "git.u8t.cn/open/go-server/utils"
	"github.com/spf13/cast"
)

type Pkg struct{}

func NewPkg() *Pkg {
	return &Pkg{}
}

func (s *Pkg) Query(req *request.PkgGet) (int64, []any, error) {
	req.Default()
	list, count, err := dao.NewPackage().Query(
		strings.TrimSpace(req.Name),
		strings.TrimSpace(req.Version),
		cast.ToInt(req.Status),
		req.PageInt(),
		req.SizeInt(),
		req.Sort,
	)
	if err != nil {
		return 0, nil, config.ErrDb.New().Append(err)
	}

	packageIds := make([]int64, 0, len(list))
	for _, item := range list {
		packageIds = append(packageIds, item.Id)
	}
	userCounts, err := dao.NewUserPkg().CountByPackageIds(packageIds)
	if err != nil {
		return 0, nil, config.ErrDb.New().Append(err)
	}

	res := make([]any, 0, len(list))
	for _, item := range list {
		res = append(res, item.FormatAdmin(userCounts[item.Id]))
	}
	return count, res, nil
}

func (s *Pkg) Create(req *request.PkgCreate) error {
	name := strings.TrimSpace(req.Name)
	version := strings.TrimSpace(req.Version)
	expire := strings.TrimSpace(req.Expire)
	if name == "" || version == "" || expire == "" {
		return config.ErrParam.New().Append("package_name, version and expire are required")
	}

	expireTime, err := model.ParseExpire(expire)
	if err != nil {
		return config.ErrParam.New().Append(err)
	}
	if expireTime <= time.Now().Unix() {
		return config.ErrParam.New().Append("expire time must be greater than current time")
	}
	if gsUtils.VersionToInt(version) < 0 {
		return config.ErrParam.New().Append("invalid version format")
	}

	pkgDao := dao.NewPackage()
	exist, err := pkgDao.GetByNameVersion(name, version)
	if err != nil {
		return config.ErrDb.New().Append(err)
	}
	if exist != nil {
		return config.ErrExist.New().Append("package name and version already exist")
	}

	latest, err := pkgDao.GetLatestByName(name)
	if err != nil {
		return config.ErrDb.New().Append(err)
	}
	if latest != nil && gsUtils.VersionToInt(version) <= gsUtils.VersionToInt(latest.Version) {
		return config.ErrParam.New().Append("version must be greater than the latest version")
	}

	now := time.Now().Unix()
	m := &model.Pkg{
		Name:       name,
		Version:    version,
		Link:       strings.TrimSpace(req.Link),
		ExpireTime: expireTime,
		Status:     model.PkgNormal,
		CreateTime: now,
		UpdateTime: now,
	}
	if err = pkgDao.Create(m); err != nil {
		return config.ErrDb.New().Append(err)
	}
	return nil
}

func (s *Pkg) Update(req *request.PkgPut) error {
	id := cast.ToInt64(strings.TrimSpace(req.Id))
	if id <= 0 {
		return config.ErrParam.New().Append("id is required")
	}
	expire := strings.TrimSpace(req.Expire)
	status := strings.TrimSpace(req.Status)
	if expire == "" && status == "" {
		return config.ErrParam.New().Append("at least one of expire or status is required")
	}

	pkgDao := dao.NewPackage()
	m, err := pkgDao.GetById(id)
	if err != nil {
		return config.ErrDb.New().Append(err)
	}
	if m == nil {
		return config.ErrNoData.New()
	}

	cols := []string{"update_time"}
	if expire != "" {
		expireTime, err := model.ParseExpire(expire)
		if err != nil {
			return config.ErrParam.New().Append(err)
		}
		if expireTime <= time.Now().Unix() {
			return config.ErrParam.New().Append("expire time must be greater than current time")
		}
		m.ExpireTime = expireTime
		cols = append(cols, "expire_time")
	}
	if status != "" {
		statusVal := cast.ToInt64(status)
		if statusVal != model.PkgNormal && statusVal != model.PkgDelete {
			return config.ErrParam.New().Append("invalid status value")
		}
		m.Status = statusVal
		cols = append(cols, "status")
	}
	m.UpdateTime = time.Now().Unix()
	if err = pkgDao.UpdateCols(m, cols...); err != nil {
		return config.ErrDb.New().Append(err)
	}
	return nil
}

func (s *Pkg) Delete(id int64) error {
	if id <= 0 {
		return config.ErrParam.New().Append("id is required")
	}

	pkgDao := dao.NewPackage()
	m, err := pkgDao.GetById(id)
	if err != nil {
		return config.ErrDb.New().Append(err)
	}
	if m == nil {
		return config.ErrNoData.New()
	}
	if m.Status == model.PkgDelete {
		return nil
	}
	if err = pkgDao.Delete(m); err != nil {
		return config.ErrDb.New().Append(err)
	}
	return nil
}