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
		Area string `json:"area"`
	}
	// InstanceSelectInfo 租户筛选信息
	InstanceSelectInfo struct {
		ID       string                `json:"id"`
		Code     string                `json:"code"`
		Name     string                `json:"name"`
		Children []*InstanceSelectInfo `json:"children"`
	}
	// InstanceParams 参数信息
	InstanceParams struct {
		ID                       uint64
		Name, Domain, IP, Remark string
		Area                     config.Area
		Contact, ContactMobile   string
	}
)

func (c *Instance) checkIsExist(iModel model2.IModel, where ...*model2.ModelWhere) (bool, error) {
	var count int64
	err := model2.Count(iModel, &count, where...)
	return count > 0, err
}

// 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,
			Area:      v.FormatBasic(),
		})
	}
	return &controller.ReturnPages{Data: list, Count: count}, nil
}

func (c *Instance) Select() (map[string]*InstanceSelectInfo, error) {
	mSysTenant := model.NewSysTenant()
	out := make([]*model2.SysTenant, 0)

	if err := model2.ScanFields(mSysTenant.SysTenant, &out, []string{"id", "name", "province", "city"}, &model2.ModelWhereOrder{
		Order: model2.NewOrder("province", model2.OrderModeToAsc),
	}, &model2.ModelWhereOrder{
		Order: model2.NewOrder("city", model2.OrderModeToAsc),
	}); err != nil {
		return nil, err
	}
	res := make(map[string]*InstanceSelectInfo, 0)

	for _, v := range out {
		data := &InstanceSelectInfo{
			ID:       v.GetEncodeID(),
			Code:     v.City,
			Name:     config.MemoryForAreaInfo[v.Province][v.City],
			Children: nil,
		}
		if _, has := res[v.Province]; !has {
			res[v.Province] = &InstanceSelectInfo{
				Code:     v.Province,
				Name:     config.MemoryForAreaInfo[config2.DefaultChinaAreaCode][v.Province],
				Children: []*InstanceSelectInfo{data},
			}
			continue
		}
		res[v.Province].Children = append(res[v.Province].Children, data)
	}
	return res, nil
}

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

	isExist := false

	if !utils.ValidateIP(params.IP) {
		return errors.New("操作错误，IP地址异常")
	}
	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("操作错误，平台信息不存在或已被删除")
		}

		if mSysTenant.Province != params.Area.Province || mSysTenant.City != params.Area.City {
			if isExist, err = c.checkIsExist(mSysTenant.SysTenant, model2.NewWhere("province", params.Area.Province),
				model2.NewWhere("city", params.Area.City)); 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.IP = params.IP
	mSysTenant.Contact = params.Contact
	mSysTenant.ContactMobile = params.ContactMobile
	mSysTenant.Remark = params.Remark

	if mSysTenant.ID > 0 {
		return model2.Updates(mSysTenant.SysTenant, mSysTenant.SysTenant)
	}
	if !utils.ValidateUrl(params.Domain) {
		return errors.New("操作错误，域名地址信息错误")
	}
	mSysTenant.Key = utils.GetRandomString(12)
	mSysTenant.Domain = params.Domain

	var err error

	if isExist, err = c.checkIsExist(mSysTenant.SysTenant, model2.NewWhere("province", params.Area.Province),
		model2.NewWhere("city", params.Area.City)); err != nil {
		return err
	} else if isExist {
		return errors.New("操作错误，该区域下已存在平台信息")
	}
	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,
		}
	}
}