package dao

import (
	"errors"
	"fmt"
	"time"
	"twin-api/app/common/model"
	"twin-api/base/global"

	"git.u8t.cn/open/go-server/utils"
	"gorm.io/gorm"
)

type Pkg struct {
	db *gorm.DB
}

func NewPackage() *Pkg {
	return &Pkg{
		db: global.GetDB(),
	}
}

func (p *Pkg) TableName() string {
	return "tw_package"
}

func (p *Pkg) Create(m *model.Pkg) error {
	return p.db.Table(p.TableName()).Create(m).Error
}

func (p *Pkg) Update(m *model.Pkg) error {
	return p.db.Table(p.TableName()).Save(m).Error
}

func (p *Pkg) UpdateCols(m *model.Pkg, cols ...string) error {
	return p.db.Table(p.TableName()).Select(cols).Updates(m).Error
}

func (p *Pkg) Delete(m *model.Pkg) error {
	return p.db.Table(p.TableName()).Where("id = ?", m.Id).Updates(map[string]any{
		"status":      model.PkgDelete,
		"update_time": time.Now().Unix(),
	}).Error
}

func (p *Pkg) Get(id int64) (*model.Pkg, error) {
	var res model.Pkg
	if err := p.db.Table(p.TableName()).Where("id = ?", id).Where("status = ?", model.PkgNormal).First(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}

	return &res, nil
}

func (p *Pkg) GetById(id int64) (*model.Pkg, error) {
	var res model.Pkg
	if err := p.db.Table(p.TableName()).Where("id = ?", id).First(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}
	return &res, nil
}

func (p *Pkg) GetByPkgName(name string) (*model.Pkg, error) {
	var res model.Pkg
	tx := p.db.Table(p.TableName()).Where("status = ?", model.PkgNormal)
	if name != "" {
		tx = tx.Where("name = ?", name)
	}
	tx = tx.Order("id desc")
	if err := tx.First(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}
	return &res, nil
}

func (p *Pkg) GetLatestByName(name string) (*model.Pkg, error) {
	var list []*model.Pkg
	if err := p.db.Table(p.TableName()).Where("name = ? AND status = ?", name, model.PkgNormal).Find(&list).Error; err != nil {
		return nil, err
	}
	if len(list) == 0 {
		return nil, nil
	}
	latest := list[0]
	latestVal := utils.VersionToInt(latest.Version)
	for _, item := range list[1:] {
		if v := utils.VersionToInt(item.Version); v > latestVal {
			latest = item
			latestVal = v
		}
	}
	return latest, nil
}

func (p *Pkg) GetByNameVersion(name, version string) (*model.Pkg, error) {
	var res model.Pkg
	if err := p.db.Table(p.TableName()).Where("name = ? AND version = ?", name, version).First(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}
	return &res, nil
}

func (p *Pkg) GetOne(name, version string) (*model.Pkg, error) {
	var res model.Pkg
	tx := p.db.Table(p.TableName()).Where("status = ?", model.PkgNormal)
	if name != "" {
		tx = tx.Where("name = ? AND version = ?", name, version)
	}

	tx = tx.Order("id desc")
	if err := tx.First(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}
		return nil, err
	}
	return &res, nil
}

func (p *Pkg) GetUserPkg(userId int64, pkg, version string) (*model.Pkg, error) {
	var res model.Pkg
	tx := p.db.Table(p.TableName() + " p ")
	tx = tx.Joins(fmt.Sprintf(" JOIN %s u ON u.package_id = p.id", NewUserPkg().TableName()))
	tx = tx.Where("u.user_id = ?", userId)
	tx = tx.Where("p.name = ? ", pkg)
	tx = tx.Where("p.version = ?", version)
	tx = tx.Where("p.status = ?", model.PkgNormal)
	if err := tx.Select("u.*,p.*").Find(&res).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, nil
		}

		return nil, err
	}
	if res.Id == 0 {
		return nil, nil
	}

	return &res, nil
}

func (p *Pkg) Query(pkgName, version string, status, page, size int, sort string) ([]*model.Pkg, int64, error) {
	var res []*model.Pkg
	var count int64
	tx := p.db.Table(p.TableName())
	if pkgName != "" {
		tx = tx.Where("name = ?", pkgName)
	}
	if version != "" {
		tx = tx.Where("version = ?", version)
	}
	if status != 0 {
		tx = tx.Where("status = ?", status)
	}
	if err := tx.Count(&count).Error; err != nil {
		return nil, 0, err
	}
	if sort != "" {
		tx = tx.Order(sort)
	} else {
		tx = tx.Order("id desc")
	}

	if err := tx.Limit(size).Offset((page - 1) * size).Find(&res).Error; err != nil {
		return nil, 0, err
	}

	return res, count, nil
}