package model

import (
	"errors"
	c "git.inspur.com/sbg-jszt/cfn/cfn-schedule/config"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/data"
	"git.inspur.com/sbg-jszt/cfn/cfn-schedule/internal/pkg/request"
	"github.com/google/uuid"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"gorm.io/plugin/soft_delete"
	"strings"
	"time"
)

type BaseIdModel struct {
	Handler ResultHandler `gorm:"-" json:"-"`
	Id      string        `gorm:"column:id;not null;primarykey" json:"id"`
}

type ResultHandler interface {
	FindResult(*gorm.DB) (interface{}, error)
}

func (b *BaseIdModel) Create(t schema.Tabler) (int64, error) {
	b.GenerateId()
	tx := DB().Table(t.TableName()).Create(t)
	if tx.Error != nil {
		return 0, tx.Error
	}
	return tx.RowsAffected, nil
}

func (b *BaseIdModel) Update(t schema.Tabler, column []string) (int64, error) {
	if b.Id == "" {
		return 0, errors.New("id cannot be null")
	}
	db := DB().Table(t.TableName())
	if column != nil && len(column) > 0 {
		db = db.Select(column)
	}
	tx := db.Updates(t)
	return tx.RowsAffected, tx.Error
}

func (b *BaseIdModel) GetById(t schema.Tabler) error {
	if b.Id == "" {
		return errors.New("id cannot be null")
	}
	tx := DB().Table(t.TableName()).Take(t)
	return tx.Error
}

func (b *BaseIdModel) Delete(t schema.Tabler) (int64, error) {
	if b.Id == "" {
		return 0, errors.New("id cannot be null")
	}
	tx := DB().Table(t.TableName()).Delete(t)
	return tx.RowsAffected, tx.Error
}

func (b *BaseIdModel) GetAll(t schema.Tabler, fields map[string]interface{}, notFields map[string]interface{}) (interface{}, error) {
	query := DB().Table(t.TableName())
	if fields != nil {
		for key := range fields {
			value := fields[key]
			switch value.(type) {
			case []string, []int, []int64, []interface{}:
				query = query.Where(key+" in (?)", value)
			default:
				query = query.Where(key+" = ?", value)
			}
		}
	}
	if notFields != nil {
		for key := range notFields {
			value := notFields[key]
			if items, ok := value.([]interface{}); ok {
				if len(items) > 0 {
					query = query.Where(key+" not in (?)", items)
				} else {
					query = query.Where(key+" <> ?", items[0])
				}
			} else {
				query = query.Where(key+" <> ?", value)
			}
		}
		//query = query.Where(fields)
	}
	return b.Handler.FindResult(query)
}

// IN db.Where("name in (?)", []string{"jinzhu", "jinzhu 2"}).Find(&users)
func (b *BaseIdModel) Page(t schema.Tabler, page *PageConfig, fields map[string]interface{}) (interface{}, error) {
	query := DB()
	if fields != nil {
		//query = query.Where(fields)
		for key := range fields {
			value := fields[key]
			switch value.(type) {
			case []string, []int, []int64, []interface{}:
				query = query.Where(key+" in (?)", value)
			default:
				query = query.Where(key+" = ?", value)
			}
		}
	}
	return b.Handler.FindResult(page.SelectPages(t, query))
}

func (b *BaseIdModel) GenerateId() {
	if b.Id == "" {
		id, _ := uuid.NewUUID()
		b.Id = strings.ReplaceAll(id.String(), "-", "")
	}
}

type BaseDbModel struct {
	BaseIdModel
	CreateTimeMillis int64 `gorm:"column:create_time_millis" json:"createTimeMillis"` //type:timestamptz   comment:数据创建时间    version:2024-02-12 14:22
	ModifyTimeMillis int64 `gorm:"column:modify_time_millis" json:"modifyTimeMillis"` //type:timestamptz   comment:数据修改时间    version:2024-02-12 14:22
}

func (b *BaseDbModel) Create(t schema.Tabler) (int64, error) {
	b.GenerateTime()
	return b.BaseIdModel.Create(t)
}

func (b *BaseDbModel) Update(t schema.Tabler, column []string) (int64, error) {
	b.GenerateModifyTime()
	return b.BaseIdModel.Update(t, column)
}

func (b *BaseDbModel) GenerateTime() {
	t := time.Now().UnixMilli()
	b.CreateTimeMillis = t
	b.ModifyTimeMillis = t
}

func (b *BaseDbModel) GenerateModifyTime() {
	b.ModifyTimeMillis = time.Now().UnixMilli()
}

type BaseUserModifyDbModel struct {
	BaseDbModel
	CreateUser string `gorm:"column:create_user" json:"createUser"`
	ModifyUser string `gorm:"column:modify_user" json:"modifyUser"`
}

func (b *BaseUserModifyDbModel) SetUserName(userName string) {
	b.CreateUser = userName
	b.ModifyUser = userName
}

func (b *BaseUserModifyDbModel) SetModifyUserName(userName string) {
	b.ModifyUser = userName
}

type BaseWorkspaceModel struct {
	BaseUserModifyDbModel
	WorkspaceId string `gorm:"column:workspace_id" json:"workspaceId"`
}

func (b *BaseWorkspaceModel) CountByWorkspaceId(t schema.Tabler) (int64, error) {
	if b.WorkspaceId == "" {
		return 0, errors.New("id cannot be null")
	}
	var count int64
	tx := DB().Table(t.TableName()).Where("workspace_id = ?", b.WorkspaceId).Count(&count)
	return count, tx.Error
}

func (b *BaseWorkspaceModel) Global() bool {
	return strings.EqualFold(b.WorkspaceId, "GLOBAL")
}

type BaseNodeModel struct {
	BaseWorkspaceModel
	NodeId        string `gorm:"column:node_id" json:"nodeId"`
	NodeName      string `gorm:"column:node_name" json:"nodeName"`
	WorkspaceName string `gorm:"column:workspace_name" json:"workspaceName"`
}

type BaseGroupModel struct {
	BaseWorkspaceModel
	Group string `gorm:"column:group" json:"group"`
}

type BaseMachineModel struct {
	BaseGroupModel
	MachineId string `gorm:"column:machine_id" json:"machineId"`
}

type BaseModel struct {
	ID         string    `gorm:"column:id;not null;primarykey" json:"id"`
	CreateTime time.Time `gorm:"column:create_time;type:timestamp;<-:create" json:"createTime"`
	UpdateTime time.Time `gorm:"column:update_time;type:timestamp" json:"updateTime"`
	CreatorID  string    `gorm:"column:creator_id;type:varchar(64);not null;<-:create" json:"creatorID"`
	Modifier   string    `gorm:"column:modifier;type:varchar(64);not null;" json:"modifier"`
}

func (model *BaseModel) DB() *gorm.DB {
	return DB()
}

type ContainsDeleteBaseModel struct {
	BaseModel
	DeletedAt soft_delete.DeletedAt `gorm:"column:deleted_at;type:int(11) unsigned;not null;default:0;index" json:"-"`
}

func DB() *gorm.DB {
	if c.Config.DatabaseConfig.Type == "sqlite" {
		return data.SqliteDB
	} else {
		return data.PostgreSqlDB["data"]
	}
}

//func DBAuth() *gorm.DB {
//	return data.PostgreSqlDB["auth"]
//}

type Page[T any] struct {
	CurrentPage int64  `json:"currentPage"`
	PageSize    int64  `json:"pageSize"`
	Total       int64  `json:"total"`
	Pages       int64  `json:"pages"`
	Order       string `json:"order"` //db.Order("name DESC")
	Data        []T    `json:"data"`
}

func (page *Page[T]) SelectPages(query *gorm.DB) (e error) {
	var model T
	query.Model(&model).Count(&page.Total)
	if page.Total == 0 {
		page.Data = []T{}
		return
	}
	e = query.Model(&model).Scopes(Paginate(page)).Find(&page.Data).Error
	return
}

func (page *Page[T]) ScanPages(query *gorm.DB) (e error) {
	var model T
	query.Model(&model).Count(&page.Total)
	if page.Total == 0 {
		page.Data = []T{}
		return
	}
	e = query.Model(&model).Scopes(Paginate(page)).Scan(&page.Data).Error
	return
}

func Paginate[T any](page *Page[T]) func(db *gorm.DB) *gorm.DB {
	return func(db *gorm.DB) *gorm.DB {
		if page.CurrentPage <= 0 {
			page.CurrentPage = 1
		}
		switch {
		case page.PageSize > 1000:
			page.PageSize = 1000 // 限制一下分页大小
		case page.PageSize <= 0:
			page.PageSize = 10
		}
		page.Pages = page.Total / page.PageSize
		if page.Total%page.PageSize != 0 {
			page.Pages++
		}
		size := page.PageSize
		offset := int((page.CurrentPage - 1) * size)
		return db.Order(page.Order).Offset(offset).Limit(int(size))
	}
}

func (page *Page[T]) Covert(pageInfo *request.PageInfo) {
	if pageInfo.CurrentPage <= 0 {
		pageInfo.CurrentPage = 1
	}
	switch {
	case pageInfo.PageSize > 1000:
		pageInfo.PageSize = 1000 // 限制一下分页大小
	case pageInfo.PageSize <= 0:
		pageInfo.PageSize = 10
	}
	page.CurrentPage = pageInfo.CurrentPage
	page.PageSize = pageInfo.PageSize
	page.Order = pageInfo.Order
}

// PageConfig 需要配套实现FindResult，Data需要回填。推荐使用Page[T any]
type PageConfig struct {
	CurrentPage int64  `json:"currentPage"`
	PageSize    int64  `json:"pageSize"`
	Total       int64  `json:"total"`
	Pages       int64  `json:"pages"`
	Order       string `json:"order"` //db.Order("name DESC")
	Data        any    `json:"data"`  // 需要回填，不好用
}

func (page *PageConfig) SelectPages(t schema.Tabler, query *gorm.DB) *gorm.DB {
	query.Table(t.TableName()).Count(&page.Total)
	if page.Total == 0 {
		return nil
	}
	return query.Table(t.TableName()).Scopes(PaginateConfig(page))
}

func PaginateConfig(page *PageConfig) func(db *gorm.DB) *gorm.DB {
	return func(db *gorm.DB) *gorm.DB {
		if page.CurrentPage <= 0 {
			page.CurrentPage = 1
		}
		switch {
		case page.PageSize > 1000:
			page.PageSize = 1000 // 限制一下分页大小
		case page.PageSize <= 0:
			page.PageSize = 10
		}
		page.Pages = page.Total / page.PageSize
		if page.Total%page.PageSize != 0 {
			page.Pages++
		}
		size := page.PageSize
		offset := int((page.CurrentPage - 1) * size)
		return db.Order(page.Order).Offset(offset).Limit(int(size))
	}
}

func (page *PageConfig) Covert(pageInfo *request.PageInfo) {
	if pageInfo.CurrentPage <= 0 {
		pageInfo.CurrentPage = 1
	}
	switch {
	case pageInfo.PageSize > 1000:
		pageInfo.PageSize = 1000 // 限制一下分页大小
	case pageInfo.PageSize <= 0:
		pageInfo.PageSize = 10
	}
	page.CurrentPage = pageInfo.CurrentPage
	page.PageSize = pageInfo.PageSize
	page.Order = pageInfo.Order
}