// Package sys
// @Link  https://github.com/bufanyun/hotgo
// @Copyright  Copyright (c) 2026 HotGo
// @Author  Ms <133814250@qq.com>
// @License  https://github.com/bufanyun/hotgo/blob/master/LICENSE
package sys

import (
	"context"
	"fmt"
	"hotgo/internal/consts"
	"hotgo/internal/dao"
	"hotgo/internal/library/contexts"
	"hotgo/internal/library/hgorm/handler"
	"hotgo/internal/library/hgorm/hook"
	"hotgo/internal/library/imtenant"
	"hotgo/internal/model/entity"
	"hotgo/internal/model/input/sysin"
	"hotgo/internal/service"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
)

type sSysImTenant struct{}

const (
	tenantConfigAliyunModerationEnabled = "aliyun_moderation_enabled"
	tenantConfigLocalModerationEnabled  = "local_moderation_enabled"
)

type imTenantConfigModeration struct {
	Id                      int64  `json:"id"`
	TenantId                int64  `json:"tenant_id"`
	MaxUsers                uint64 `json:"max_users"`
	MaxGroups               uint64 `json:"max_groups"`
	MaxGroupMembers         uint   `json:"max_group_members"`
	AliyunModerationEnabled int    `json:"aliyun_moderation_enabled"`
	LocalModerationEnabled  int    `json:"local_moderation_enabled"`
}

func NewSysImTenant() *sSysImTenant {
	return &sSysImTenant{}
}

func init() {
	service.RegisterSysImTenant(NewSysImTenant())
}

// Model IM租户ORM模型
func (s *sSysImTenant) Model(ctx context.Context, option ...*handler.Option) *gdb.Model {
	return handler.Model(imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx), option...)
}

func (s *sSysImTenant) configModel(ctx context.Context) *gdb.Model {
	return imtenant.RegistryDB().Model(dao.ImTenantConfig.Table()).Safe().Ctx(ctx)
}

// List 获取IM租户列表
func (s *sSysImTenant) List(ctx context.Context, in *sysin.ImTenantListInp) (list []*sysin.ImTenantListModel, totalCount int, err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}

	mod := s.Model(ctx).Fields(
		dao.ImTenant.Columns().Id,
		dao.ImTenant.Columns().Code,
		dao.ImTenant.Columns().Name,
		dao.ImTenant.Columns().TenantDesc,
		dao.ImTenant.Columns().DbName,
		dao.ImTenant.Columns().State,
		dao.ImTenant.Columns().CreatedBy,
		dao.ImTenant.Columns().UpdatedBy,
		dao.ImTenant.Columns().CreatedAt,
		dao.ImTenant.Columns().UpdatedAt,
	)

	if !isImPlatformAdmin(ctx, contexts.GetUserId(ctx)) {
		tenantId := contexts.GetTenantId(ctx)
		if tenantId <= 0 {
			err = gerror.New("当前管理员未关联IM租户")
			return
		}
		mod = mod.Where(dao.ImTenant.Columns().Id, tenantId)
	}
	if in.Id > 0 {
		mod = mod.Where(dao.ImTenant.Columns().Id, in.Id)
	}
	if in.Code != "" {
		mod = mod.WhereLike(dao.ImTenant.Columns().Code, "%"+in.Code+"%")
	}
	if in.Name != "" {
		mod = mod.WhereLike(dao.ImTenant.Columns().Name, "%"+in.Name+"%")
	}
	if in.DbName != "" {
		mod = mod.WhereLike(dao.ImTenant.Columns().DbName, "%"+in.DbName+"%")
	}
	if in.State != nil {
		mod = mod.Where(dao.ImTenant.Columns().State, *in.State)
	}
	if len(in.CreatedAt) == 2 {
		mod = mod.WhereBetween(dao.ImTenant.Columns().CreatedAt, in.CreatedAt[0], in.CreatedAt[1])
	}

	mod = mod.Page(in.Page, in.PerPage).
		OrderDesc(dao.ImTenant.Columns().Id).
		Hook(hook.MemberSummary)

	if err = mod.ScanAndCount(&list, &totalCount, false); err != nil {
		err = gerror.Wrap(err, "获取IM租户列表失败，请稍后重试！")
		return
	}
	if len(list) == 0 {
		return
	}

	if err = s.fillListConfig(ctx, list); err != nil {
		return
	}
	return
}

func (s *sSysImTenant) fillListConfig(ctx context.Context, list []*sysin.ImTenantListModel) (err error) {
	ids := make([]int64, 0, len(list))
	for _, item := range list {
		ids = append(ids, item.Id)
	}

	var configs []*imTenantConfigModeration
	if err = s.configModel(ctx).
		WhereIn(dao.ImTenantConfig.Columns().TenantId, ids).
		Scan(&configs); err != nil {
		return gerror.Wrap(err, "获取IM租户配置失败，请稍后重试！")
	}
	configMap := make(map[int64]*imTenantConfigModeration, len(configs))
	for _, item := range configs {
		configMap[item.TenantId] = item
	}

	var tenants []*entity.ImTenant
	if err = s.Model(ctx).
		Fields(dao.ImTenant.Columns().Id, dao.ImTenant.Columns().DbDsn).
		WhereIn(dao.ImTenant.Columns().Id, ids).
		Scan(&tenants); err != nil {
		return gerror.Wrap(err, "获取IM租户连接配置失败，请稍后重试！")
	}
	dsnMap := make(map[int64]string, len(tenants))
	for _, item := range tenants {
		dsnMap[item.Id] = item.DbDsn
	}

	for _, item := range list {
		if conf, ok := configMap[item.Id]; ok {
			item.MaxUsers = conf.MaxUsers
			item.MaxGroups = conf.MaxGroups
			item.MaxGroupMembers = conf.MaxGroupMembers
			item.AliyunModerationEnabled = conf.AliyunModerationEnabled
			item.LocalModerationEnabled = conf.LocalModerationEnabled
		}
		item.DbDsnConfigured = dsnMap[item.Id] != ""
	}
	return
}

// Add 新增IM租户
func (s *sSysImTenant) Add(ctx context.Context, in *sysin.ImTenantEditInp) (err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}
	if !isImPlatformAdmin(ctx, contexts.GetUserId(ctx)) {
		return gerror.New("只有平台管理员可以新增商户")
	}
	in.Id = 0
	return s.saveTenant(ctx, in)
}

// Edit 修改IM租户
func (s *sSysImTenant) Edit(ctx context.Context, in *sysin.ImTenantEditInp) (err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}
	if in.Id <= 0 {
		return gerror.New("商户ID不能为空")
	}
	if !isImPlatformAdmin(ctx, contexts.GetUserId(ctx)) {
		tenantId := contexts.GetTenantId(ctx)
		if tenantId <= 0 {
			return gerror.New("当前管理员未关联IM租户")
		}
		if in.Id != tenantId {
			return gerror.New("无权编辑其它商户")
		}
	}
	return s.saveTenant(ctx, in)
}

func (s *sSysImTenant) saveTenant(ctx context.Context, in *sysin.ImTenantEditInp) (err error) {
	tenantID := in.Id
	err = imtenant.RegistryDB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) (err error) {
		if err = s.checkCodeUnique(ctx, in.Id, in.Code); err != nil {
			return
		}

		userId := contexts.GetUserId(ctx)
		if in.Id > 0 {
			in.UpdatedBy = userId
			if _, err = s.Model(ctx).
				Fields(sysin.ImTenantUpdateFields{}).
				WherePri(in.Id).Data(in).Update(); err != nil {
				return gerror.Wrap(err, "修改IM租户失败，请稍后重试！")
			}
			return s.saveConfig(ctx, in.Id, in.MaxUsers, in.MaxGroups, in.MaxGroupMembers, in.AliyunModerationEnabled, in.LocalModerationEnabled, userId)
		}

		in.CreatedBy = userId
		in.UpdatedBy = userId
		id, err := s.Model(ctx, &handler.Option{FilterAuth: false}).
			Fields(sysin.ImTenantInsertFields{}).
			Data(in).InsertAndGetId()
		if err != nil {
			return gerror.Wrap(err, "新增IM租户失败，请稍后重试！")
		}
		tenantID = id
		return s.saveConfig(ctx, id, in.MaxUsers, in.MaxGroups, in.MaxGroupMembers, in.AliyunModerationEnabled, in.LocalModerationEnabled, userId)
	})
	if err != nil {
		return err
	}
	_ = publishImPolicyEvent(ctx, tenantID, in.Code, "tenant.features.updated", "moderation", 0)
	return nil
}

func (s *sSysImTenant) checkCodeUnique(ctx context.Context, id int64, code string) (err error) {
	mod := s.Model(ctx).Where(dao.ImTenant.Columns().Code, code)
	if id > 0 {
		mod = mod.Where(dao.ImTenant.Columns().Id+"<>?", id)
	}
	count, err := mod.Count()
	if err != nil {
		return gerror.Wrap(err, "检查IM租户编码失败，请稍后重试！")
	}
	if count > 0 {
		return gerror.New("租户编码已存在")
	}
	return
}

func (s *sSysImTenant) saveConfig(ctx context.Context, tenantId int64, maxUsers uint64, maxGroups uint64, maxGroupMembers uint, aliyunModerationEnabled, localModerationEnabled int, userId int64) (err error) {
	var conf *entity.ImTenantConfig
	if err = s.configModel(ctx).
		Where(dao.ImTenantConfig.Columns().TenantId, tenantId).
		Scan(&conf); err != nil {
		return gerror.Wrap(err, "获取IM租户配置失败，请稍后重试！")
	}

	data := g.Map{
		dao.ImTenantConfig.Columns().MaxUsers:        maxUsers,
		dao.ImTenantConfig.Columns().MaxGroups:       maxGroups,
		dao.ImTenantConfig.Columns().MaxGroupMembers: maxGroupMembers,
		tenantConfigAliyunModerationEnabled:          aliyunModerationEnabled,
		tenantConfigLocalModerationEnabled:           localModerationEnabled,
	}
	if conf != nil && conf.Id > 0 {
		data[dao.ImTenantConfig.Columns().UpdatedBy] = userId
		if _, err = s.configModel(ctx).
			Fields(
				dao.ImTenantConfig.Columns().MaxUsers,
				dao.ImTenantConfig.Columns().MaxGroups,
				dao.ImTenantConfig.Columns().MaxGroupMembers,
				tenantConfigAliyunModerationEnabled,
				tenantConfigLocalModerationEnabled,
				dao.ImTenantConfig.Columns().UpdatedBy,
			).
			WherePri(conf.Id).Data(data).Update(); err != nil {
			return gerror.Wrap(err, "修改IM租户配置失败，请稍后重试！")
		}
		return
	}

	data[dao.ImTenantConfig.Columns().TenantId] = tenantId
	data[dao.ImTenantConfig.Columns().CreatedBy] = userId
	data[dao.ImTenantConfig.Columns().UpdatedBy] = userId
	if _, err = s.configModel(ctx).
		Fields(
			dao.ImTenantConfig.Columns().TenantId,
			dao.ImTenantConfig.Columns().MaxUsers,
			dao.ImTenantConfig.Columns().MaxGroups,
			dao.ImTenantConfig.Columns().MaxGroupMembers,
			tenantConfigAliyunModerationEnabled,
			tenantConfigLocalModerationEnabled,
			dao.ImTenantConfig.Columns().CreatedBy,
			dao.ImTenantConfig.Columns().UpdatedBy,
		).
		Data(data).Insert(); err != nil {
		return gerror.Wrap(err, "新增IM租户配置失败，请稍后重试！")
	}
	return
}

// View 获取IM租户指定信息
func (s *sSysImTenant) View(ctx context.Context, in *sysin.ImTenantViewInp) (res *sysin.ImTenantViewModel, err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}
	if err = s.Model(ctx).WherePri(in.Id).Hook(hook.MemberSummary).Scan(&res); err != nil {
		err = gerror.Wrap(err, "获取IM租户信息失败，请稍后重试！")
		return
	}
	if res == nil {
		return
	}

	var conf *imTenantConfigModeration
	if err = s.configModel(ctx).
		Where(dao.ImTenantConfig.Columns().TenantId, in.Id).
		Scan(&conf); err != nil {
		err = gerror.Wrap(err, "获取IM租户配置失败，请稍后重试！")
		return
	}
	if conf != nil {
		res.MaxUsers = conf.MaxUsers
		res.MaxGroups = conf.MaxGroups
		res.MaxGroupMembers = conf.MaxGroupMembers
		res.AliyunModerationEnabled = conf.AliyunModerationEnabled
		res.LocalModerationEnabled = conf.LocalModerationEnabled
	}
	res.DbDsnConfigured = res.DbDsn != ""
	return
}

// Status 更新IM租户状态
func (s *sSysImTenant) Status(ctx context.Context, in *sysin.ImTenantStatusInp) (err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}
	if _, err = s.Model(ctx).WherePri(in.Id).Data(g.Map{
		dao.ImTenant.Columns().State:     in.State,
		dao.ImTenant.Columns().UpdatedBy: contexts.GetUserId(ctx),
	}).Update(); err != nil {
		err = gerror.Wrap(err, "更新IM租户状态失败，请稍后重试！")
		return
	}
	return
}

func (s *sSysImTenant) Usage(ctx context.Context, in *sysin.ImTenantUsageInp) (res *sysin.ImTenantUsageModel, err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}

	var tenant *entity.ImTenant
	if err = s.Model(ctx).WherePri(in.Id).Scan(&tenant); err != nil {
		return nil, gerror.Wrap(err, "获取IM租户信息失败，请稍后重试！")
	}
	if tenant == nil || tenant.Id <= 0 {
		return nil, gerror.New("IM租户不存在")
	}

	res = &sysin.ImTenantUsageModel{
		Id:              tenant.Id,
		Code:            tenant.Code,
		Name:            tenant.Name,
		DbName:          tenant.DbName,
		DbDsnConfigured: tenant.DbDsn != "",
		Warnings:        []string{},
	}

	db, _, dbErr := imtenant.DB(ctx, tenant.Id)
	if dbErr != nil {
		res.DbReachable = false
		res.DbCheckError = dbErr.Error()
		return res, nil
	}
	if _, pingErr := db.GetValue(ctx, "SELECT 1"); pingErr != nil {
		res.DbReachable = false
		res.DbCheckError = pingErr.Error()
		return res, nil
	}
	res.DbReachable = true

	res.SchemaVersion = s.queryScalarString(ctx, db, "kvmeta.version", "SELECT value FROM kvmeta WHERE key_='version' LIMIT 1", &res.Warnings)
	res.UserCount = s.queryScalarInt64(ctx, db, "im_users.total", "SELECT COUNT(*) FROM im_users", &res.Warnings)
	res.ActiveUserCount = s.queryScalarInt64(ctx, db, "im_users.active", "SELECT COUNT(*) FROM im_users WHERE state=0", &res.Warnings)
	res.GroupCount = s.queryScalarInt64(ctx, db, "im_group_settings", "SELECT COUNT(*) FROM im_group_settings WHERE group_status<>'dissolved'", &res.Warnings)
	res.DeviceCount = s.queryScalarInt64(ctx, db, "im_devices", "SELECT COUNT(*) FROM im_devices", &res.Warnings)
	res.PushTokenCount = s.queryScalarInt64(ctx, db, "im_device_push_tokens", "SELECT COUNT(*) FROM im_device_push_tokens", &res.Warnings)
	res.InviteUseCount = s.queryScalarInt64(ctx, db, "im_registration_invite_uses", "SELECT COUNT(*) FROM im_registration_invite_uses", &res.Warnings)
	res.OutboxPendingCount = s.queryScalarInt64(ctx, db, "im_business_events_outbox", "SELECT COUNT(*) FROM im_business_events_outbox WHERE status='pending'", &res.Warnings)
	return
}

func (s *sSysImTenant) queryScalarInt64(ctx context.Context, db gdb.DB, label, sql string, warnings *[]string) int64 {
	value, err := db.GetValue(ctx, sql)
	if err != nil {
		*warnings = append(*warnings, label+": "+err.Error())
		return 0
	}
	return value.Int64()
}

func (s *sSysImTenant) queryScalarString(ctx context.Context, db gdb.DB, label, sql string, warnings *[]string) string {
	value, err := db.GetValue(ctx, sql)
	if err != nil {
		*warnings = append(*warnings, label+": "+err.Error())
		return ""
	}
	return value.String()
}

func (s *sSysImTenant) DeletionCheck(ctx context.Context, in *sysin.ImTenantDeletionCheckInp) (res *sysin.ImTenantDeletionCheckModel, err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}
	usage, err := s.Usage(ctx, &sysin.ImTenantUsageInp{Id: in.Id})
	if err != nil {
		return nil, err
	}
	res = &sysin.ImTenantDeletionCheckModel{
		Id:            usage.Id,
		Code:          usage.Code,
		Name:          usage.Name,
		Blockers:      []string{},
		Warnings:      usage.Warnings,
		UserCount:     usage.UserCount,
		GroupCount:    usage.GroupCount,
		PendingOutbox: usage.OutboxPendingCount,
	}
	if !usage.DbReachable {
		res.Blockers = append(res.Blockers, "租户业务库不可达："+usage.DbCheckError)
	}
	if usage.UserCount > 0 {
		res.Blockers = append(res.Blockers, fmt.Sprintf("租户仍有 %d 个用户", usage.UserCount))
	}
	if usage.GroupCount > 0 {
		res.Blockers = append(res.Blockers, fmt.Sprintf("租户仍有 %d 个群", usage.GroupCount))
	}
	if usage.OutboxPendingCount > 0 {
		res.Blockers = append(res.Blockers, fmt.Sprintf("租户仍有 %d 条待处理 Outbox", usage.OutboxPendingCount))
	}
	res.CanEnterDeleting = len(res.Blockers) == 0
	return
}

func (s *sSysImTenant) EnterDeleting(ctx context.Context, in *sysin.ImTenantLifecycleInp) (err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}
	check, err := s.DeletionCheck(ctx, &sysin.ImTenantDeletionCheckInp{Id: in.Id})
	if err != nil {
		return err
	}
	if !check.CanEnterDeleting {
		return gerror.New("租户未通过删除前检查，不能进入删除流程")
	}
	if _, err = s.Model(ctx).WherePri(in.Id).Data(g.Map{
		dao.ImTenant.Columns().State:     consts.ImTenantStateDeleting,
		dao.ImTenant.Columns().UpdatedBy: contexts.GetUserId(ctx),
	}).Update(); err != nil {
		return gerror.Wrap(err, "设置IM租户删除流程失败，请稍后重试！")
	}
	return
}

func (s *sSysImTenant) Restore(ctx context.Context, in *sysin.ImTenantLifecycleInp) (err error) {
	if err = in.Filter(ctx); err != nil {
		return
	}
	if _, err = s.Model(ctx).
		WherePri(in.Id).
		WhereIn(dao.ImTenant.Columns().State, []int{consts.ImTenantStateSuspended, consts.ImTenantStateDeleting}).
		Data(g.Map{
			dao.ImTenant.Columns().State:     consts.ImTenantStateActive,
			dao.ImTenant.Columns().UpdatedBy: contexts.GetUserId(ctx),
		}).Update(); err != nil {
		return gerror.Wrap(err, "恢复IM租户失败，请稍后重试！")
	}
	return
}