package tenant

import (
	"SciencesServer/app/api/admin/model"
	"SciencesServer/app/basic/config"
	"SciencesServer/app/basic/controller"
	model2 "SciencesServer/app/common/model"
	"SciencesServer/app/service"
	"SciencesServer/app/session"
	config2 "SciencesServer/config"
	"SciencesServer/serve/logger"
	"SciencesServer/serve/orm"
	"SciencesServer/utils"
	"errors"
	"fmt"
	"gorm.io/gorm"
)

type Instance struct {
	session *session.Admin
}

type InstanceHandle func(session *session.Admin) *Instance

type (
	// InstanceInfo 租户信息
	InstanceInfo struct {
		ID string `json:"id"`
		*model2.SysTenant
	}
	// InstanceParams 参数信息
	InstanceParams struct {
		ID                     uint64
		Name, Domain, Remark   string
		Area                   config.Area
		Contact, ContactMobile string
	}
)

// Index 首页列表信息
func (c *Instance) Index(name string, page, pageSize int) (*controller.ReturnPages, error) {
	mSysTenant := model.NewSysTenant()
	out := make([]*model2.SysTenant, 0)

	where := []*model2.ModelWhereOrder{
		&model2.ModelWhereOrder{Order: model2.NewOrder("id", model2.OrderModeToDesc)},
	}
	if name != "" {
		where = append(where, &model2.ModelWhereOrder{Where: model2.NewWhereLike("name", name)})
	}
	var count int64

	if err := model2.Pages(mSysTenant.SysTenant, &out, page, pageSize, &count, where...); err != nil {
		return nil, err
	}
	list := make([]*InstanceInfo, 0)

	for _, v := range out {
		list = append(list, &InstanceInfo{
			ID:        v.GetEncodeID(),
			SysTenant: v,
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

// Form 数据操作
func (c *Instance) Form(params *InstanceParams) error {
	mSysTenant := model.NewSysTenant()

	if params.ID > 0 {
		mSysTenant.ID = params.ID

		isExist, err := model2.First(mSysTenant.SysTenant)

		if err != nil {
			return err
		} else if !isExist {
			return errors.New("操作错误，平台信息不存在或已被删除")
		}
	}
	mSysTenant.Name = params.Name
	mSysTenant.Area = model2.Area{
		Province: params.Area.Province,
		City:     params.Area.City,
	}
	mSysTenant.Contact = params.Contact
	mSysTenant.ContactMobile = params.ContactMobile
	mSysTenant.Remark = params.Remark

	if mSysTenant.ID > 0 {
		return model2.Updates(mSysTenant.SysTenant, mSysTenant.SysTenant)
	}
	mSysTenant.Key = utils.GetRandomString(12)
	mSysTenant.Domain = params.Domain

	if err := model2.Create(mSysTenant.SysTenant); err != nil {
		return err
	}
	_session := session.NewTenant()
	_session.ID = mSysTenant.ID
	_session.Name = mSysTenant.Name
	_session.Domain = mSysTenant.Domain

	service.Publish(config2.EventForRedisHashProduce, config2.RedisKeyForTenant, _session.Domain, _session)

	return nil
}

// Delete 删除操作
func (c *Instance) Delete(id uint64) error {
	mSysTenant := model.NewSysTenant()
	mSysTenant.ID = id

	isExist, err := model2.FirstField(mSysTenant.SysTenant, []string{"id", "name", "domain"})

	if err != nil {
		return err
	} else if !isExist {
		return errors.New("操作错误，平台信息不存在或已被删除")
	}
	if err = orm.GetDB().Transaction(func(tx *gorm.DB) error {
		if err = model2.Delete(mSysTenant.SysTenant); err != nil {
			return err
		}
		if _, err = service.NewPermission(
			service.WithAuthTenant(fmt.Sprintf("%d", id)),
		).RemoveFilteredGroupingPolicy(); err != nil {
			logger.ErrorF("Casbin 删除租户【%d】下权限信息错误：%v", id, err)
			return err
		}
		return nil
	}); err != nil {
		return nil
	}
	service.Publish(config2.EventForRedisHashDestroy, config2.RedisKeyForTenant, mSysTenant.Domain)
	return nil
}

func NewInstance() InstanceHandle {
	return func(session *session.Admin) *Instance {
		return &Instance{
			session: session,
		}
	}
}