package imconfig

import (
	"context"
	"encoding/json"
	api "hotgo/api/admin/imconfiginternal"
	"hotgo/internal/consts"
	"hotgo/internal/dao"
	"hotgo/internal/library/imtenant"
	"hotgo/internal/model/entity"
	"hotgo/internal/service"
	"strings"

	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/os/gtime"
	"github.com/gogf/gf/v2/util/gconv"
)

const defaultModerationTenantCode = "default"

var defaultModerationScenes = map[string]bool{
	"user_nickname": true, "user_signature": true, "group_name": true,
	"group_nickname": true, "private_message": true, "group_message": true,
	"group_announcement": true,
}

var defaultModerationRiskActions = map[string]string{
	"high": "block", "medium": "block", "low": "audit_only", "none": "allow",
}

var Config = cConfig{}

type cConfig struct{}

func (c *cConfig) Tenant(ctx context.Context, req *api.TenantReq) (res *api.TenantRes, err error) {
	tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, req.Code)
	if err != nil {
		return nil, err
	}
	return &api.TenantRes{TenantModel: tenantToModel(tenant)}, nil
}

func (c *cConfig) TenantByID(ctx context.Context, req *api.TenantByIDReq) (res *api.TenantRes, err error) {
	tenant, err := getTenant(ctx, dao.ImTenant.Columns().Id, req.Id)
	if err != nil {
		return nil, err
	}
	return &api.TenantRes{TenantModel: tenantToModel(tenant)}, nil
}

func (c *cConfig) TenantList(ctx context.Context, req *api.TenantListReq) (res *api.TenantListRes, err error) {
	limit := req.Limit
	if limit <= 0 || limit > 1000 {
		limit = 1000
	}
	mod := imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).Limit(limit)
	if req.State != "" {
		if req.State == "active" {
			mod = mod.Where(dao.ImTenant.Columns().State, 1)
		} else {
			mod = mod.Where(dao.ImTenant.Columns().State, req.State)
		}
	}
	var tenants []*entity.ImTenant
	if err = mod.OrderAsc(dao.ImTenant.Columns().Id).Scan(&tenants); err != nil {
		return nil, gerror.Wrap(err, "获取IM租户配置失败")
	}
	res = &api.TenantListRes{Items: make([]*api.TenantModel, 0, len(tenants))}
	for _, tenant := range tenants {
		res.Items = append(res.Items, tenantToModel(tenant))
	}
	return res, nil
}

func (c *cConfig) RegistrationSms(ctx context.Context, req *api.RegistrationSmsReq) (res *api.RegistrationSmsRes, err error) {
	var record *entity.SysConfig
	if err = dao.SysConfig.Ctx(ctx).
		Where(dao.SysConfig.Columns().Group, "im").
		Where(dao.SysConfig.Columns().Key, "register_sms_enabled").
		Where(dao.SysConfig.Columns().Status, 1).
		Scan(&record); err != nil {
		return nil, gerror.Wrap(err, "获取IM注册短信配置失败")
	}
	enabled := true
	if record != nil {
		enabled = gconv.String(record.Value) != "0"
	}
	return &api.RegistrationSmsRes{Enabled: enabled}, nil
}

func (c *cConfig) ThirdParty(ctx context.Context, req *api.ThirdPartyReq) (res *api.ThirdPartyRes, err error) {
	values := map[string]string{}
	keys := splitKeys(req.Keys)
	mod := dao.SysConfig.Ctx(ctx).Where(dao.SysConfig.Columns().Group, req.Group).Where(dao.SysConfig.Columns().Status, 1)
	if len(keys) > 0 {
		mod = mod.WhereIn(dao.SysConfig.Columns().Key, keys)
	}
	var rows []*entity.SysConfig
	if err = mod.Scan(&rows); err != nil {
		return nil, gerror.Wrap(err, "获取IM第三方配置失败")
	}
	for _, row := range rows {
		values[row.Key] = row.Value
	}
	return &api.ThirdPartyRes{Values: values}, nil
}

func (c *cConfig) ModerationProvider(ctx context.Context, req *api.ModerationProviderReq) (res *api.ModerationProviderRes, err error) {
	tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, defaultModerationTenantCode)
	if err != nil {
		return nil, err
	}
	var row struct {
		Provider   string `json:"provider"`
		Endpoint   string `json:"endpoint"`
		Enabled    int    `json:"enabled"`
		ConfigJSON string `json:"config_json"`
		SecretJSON string `json:"secret_json"`
	}
	if err = imtenant.RegistryDB().Model("im_external_config").Safe().Ctx(ctx).
		Fields("provider", "endpoint", "enabled", "CAST(config_json AS CHAR) config_json", "CAST(secret_json AS CHAR) secret_json").
		Where("tenant_id", tenant.Id).Where("service", consts.ImExternalServiceModeration).Scan(&row); err != nil {
		return nil, gerror.Wrap(err, "获取内容审核服务配置失败")
	}
	config := map[string]any{}
	secret := map[string]any{}
	_ = json.Unmarshal([]byte(row.ConfigJSON), &config)
	_ = json.Unmarshal([]byte(row.SecretJSON), &secret)
	res = &api.ModerationProviderRes{
		Provider: row.Provider, Endpoint: row.Endpoint, Enabled: row.Enabled == 1,
		RegionID:        stringValue(config, "region_id", "cn-shanghai"),
		NicknameService: stringValue(config, "nickname_service", "nickname_detection_pro"),
		ChatService:     stringValue(config, "chat_service", "chat_detection_pro"),
		TimeoutMS:       intValue(config, "timeout_ms", 1500),
		FailureMode:     moderationFailureMode(stringValue(config, "failure_mode", "allow")),
		AccessKeyID:     stringValue(secret, "access_key_id", ""),
		AccessKeySecret: stringValue(secret, "access_key_secret", ""),
	}
	return res, nil
}

func (c *cConfig) ModerationPolicy(ctx context.Context, req *api.ModerationPolicyReq) (res *api.ModerationPolicyRes, err error) {
	tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, strings.TrimSpace(req.Code))
	if err != nil {
		return nil, err
	}
	res = defaultModerationPolicy(tenant)
	var tenantConfig struct {
		AliyunModerationEnabled int `json:"aliyun_moderation_enabled"`
		LocalModerationEnabled  int `json:"local_moderation_enabled"`
	}
	if err = imtenant.RegistryDB().Model(dao.ImTenantConfig.Table()).Safe().Ctx(ctx).
		Fields("aliyun_moderation_enabled", "local_moderation_enabled").
		Where(dao.ImTenantConfig.Columns().TenantId, tenant.Id).Scan(&tenantConfig); err != nil {
		return nil, gerror.Wrap(err, "获取商户内容审核开关失败")
	}
	res.AliyunEnabled = tenantConfig.AliyunModerationEnabled == 1
	res.LocalWordsEnabled = tenantConfig.LocalModerationEnabled == 1
	res.Enabled = res.AliyunEnabled || res.LocalWordsEnabled
	columns := dao.ImSecurityPolicy.Columns()
	var row struct {
		PolicyVersion       uint   `json:"policy_version"`
		SensitiveWordPolicy string `json:"sensitive_word_policy"`
	}
	if err = imtenant.RegistryDB().Model(dao.ImSecurityPolicy.Table()).Safe().Ctx(ctx).
		Fields(columns.PolicyVersion, "CAST("+columns.SensitiveWordPolicy+" AS CHAR) sensitive_word_policy").
		Where(columns.TenantId, tenant.Id).Where(columns.PublishStatus, consts.ImSecurityPublishPublished).
		WhereNull(columns.DeletedAt).OrderDesc(columns.PolicyVersion).Limit(1).Scan(&row); err != nil {
		return nil, gerror.Wrap(err, "获取商户内容审核策略失败")
	}
	if row.PolicyVersion == 0 || strings.TrimSpace(row.SensitiveWordPolicy) == "" {
		return res, nil
	}
	var policy struct {
		Scenes       map[string]bool   `json:"scenes"`
		RiskActions  map[string]string `json:"risk_actions"`
		FailureMode  string            `json:"failure_mode"`
		BlockMessage string            `json:"block_message"`
	}
	if err = json.Unmarshal([]byte(row.SensitiveWordPolicy), &policy); err != nil {
		return nil, gerror.Wrap(err, "商户内容审核策略格式错误")
	}
	res.PolicyVersion = row.PolicyVersion
	for scene, enabled := range policy.Scenes {
		res.Scenes[scene] = enabled
	}
	for risk, action := range policy.RiskActions {
		if action == "allow" || action == "block" || action == "audit_only" {
			res.RiskActions[risk] = action
		}
	}
	res.FailureMode = moderationFailureMode(policy.FailureMode)
	if strings.TrimSpace(policy.BlockMessage) != "" {
		res.BlockMessage = strings.TrimSpace(policy.BlockMessage)
	}
	return res, nil
}

func (c *cConfig) SensitiveWords(ctx context.Context, req *api.SensitiveWordsReq) (res *api.SensitiveWordsRes, err error) {
	tenant, err := getTenant(ctx, dao.ImTenant.Columns().Code, strings.TrimSpace(req.Code))
	if err != nil {
		return nil, err
	}
	res = &api.SensitiveWordsRes{TenantID: tenant.Id, TenantCode: tenant.Code, Items: []*api.SensitiveWordModel{}}
	columns := dao.ImSensitiveWords.Columns()
	groupColumns := dao.ImSensitiveWordGroups.Columns()
	var rows []struct {
		ID          int64       `json:"id"`
		Word        string      `json:"word"`
		MatchType   string      `json:"match_type"`
		SceneJSON   string      `json:"scene_json"`
		Action      string      `json:"action"`
		Replacement string      `json:"replacement"`
		RiskLevel   string      `json:"risk_level"`
		Priority    int         `json:"priority"`
		UpdatedAt   *gtime.Time `json:"updated_at"`
	}
	err = imtenant.RegistryDB().Model(dao.ImSensitiveWords.Table()+" w").Safe().Ctx(ctx).
		LeftJoin(dao.ImSensitiveWordGroups.Table()+" g", "g."+groupColumns.Id+"=w."+columns.GroupId).
		Fields("w."+columns.Id, "w."+columns.Word, "w."+columns.MatchType, "CAST(w."+columns.SceneJson+" AS CHAR) scene_json", "w."+columns.Action, "w."+columns.Replacement, "w."+columns.RiskLevel, "w."+columns.Priority, "w."+columns.UpdatedAt).
		Where("w."+columns.TenantId, tenant.Id).Where("w."+columns.Status, consts.StatusEnabled).WhereNull("w."+columns.DeletedAt).
		Where("g."+groupColumns.Status, consts.StatusEnabled).WhereNull("g." + groupColumns.DeletedAt).
		OrderDesc("w." + columns.Priority).OrderAsc("w." + columns.Id).Scan(&rows)
	if err != nil {
		return nil, gerror.Wrap(err, "获取商户有效敏感词失败")
	}
	for _, row := range rows {
		var scenes []string
		_ = json.Unmarshal([]byte(row.SceneJSON), &scenes)
		res.Items = append(res.Items, &api.SensitiveWordModel{ID: row.ID, Word: row.Word, MatchType: row.MatchType, Scenes: scenes, Action: row.Action, Replacement: row.Replacement, RiskLevel: row.RiskLevel, Priority: row.Priority})
		if row.UpdatedAt != nil && row.UpdatedAt.TimestampMilli() > res.Version {
			res.Version = row.UpdatedAt.TimestampMilli()
		}
	}
	return res, nil
}

func defaultModerationPolicy(tenant *entity.ImTenant) *api.ModerationPolicyRes {
	return &api.ModerationPolicyRes{TenantID: tenant.Id, TenantCode: tenant.Code, Enabled: false,
		AliyunEnabled: false, LocalWordsEnabled: false, Scenes: cloneBoolMap(defaultModerationScenes),
		RiskActions: cloneStringMap(defaultModerationRiskActions), FailureMode: "allow",
		BlockMessage: "内容不符合平台规范，请修改后重试"}
}

func cloneBoolMap(src map[string]bool) map[string]bool {
	dst := make(map[string]bool, len(src))
	for k, v := range src {
		dst[k] = v
	}
	return dst
}
func cloneStringMap(src map[string]string) map[string]string {
	dst := make(map[string]string, len(src))
	for k, v := range src {
		dst[k] = v
	}
	return dst
}
func stringValue(values map[string]any, key, fallback string) string {
	if value, ok := values[key].(string); ok && strings.TrimSpace(value) != "" {
		return strings.TrimSpace(value)
	}
	return fallback
}
func intValue(values map[string]any, key string, fallback int) int {
	value := gconv.Int(values[key])
	if value <= 0 {
		return fallback
	}
	return value
}
func moderationFailureMode(value string) string {
	if strings.TrimSpace(value) == "block" {
		return "block"
	}
	return "allow"
}

func (c *cConfig) TenantLoginIPWhitelist(ctx context.Context, req *api.TenantLoginIPWhitelistReq) (res *api.TenantLoginIPWhitelistRes, err error) {
	if _, err = getTenant(ctx, dao.ImTenant.Columns().Id, req.Id); err != nil {
		return nil, err
	}
	data, err := service.SysImUserPolicyGroup().LoginIPWhitelistByTenant(ctx, req.Id)
	if err != nil {
		return nil, err
	}
	return &api.TenantLoginIPWhitelistRes{TenantId: data.TenantId, AppList: data.AppList, WebList: data.WebList}, nil
}

func (c *cConfig) AppReleaseLatest(ctx context.Context, req *api.AppReleaseLatestReq) (res *api.AppReleaseLatestRes, err error) {
	platform := strings.ToLower(strings.TrimSpace(req.Platform))
	channel := strings.ToLower(strings.TrimSpace(req.Channel))
	if platform != "ios" && platform != "android" {
		return nil, gerror.New("客户端平台不合法")
	}
	if channel == "" {
		channel = "stable"
	}
	if strings.ContainsAny(channel, " \t\r\n/") || len(channel) > 32 {
		return nil, gerror.New("客户端渠道不合法")
	}
	var row struct {
		ID                  int64       `json:"id"`
		Platform            string      `json:"platform"`
		Channel             string      `json:"channel"`
		LatestVersion       string      `json:"latest_version"`
		MinSupportedVersion string      `json:"min_supported_version"`
		UpdateType          string      `json:"update_type"`
		ReleaseNotes        string      `json:"release_notes"`
		StoreURL            string      `json:"store_url"`
		PackageURL          string      `json:"package_url"`
		Checksum            string      `json:"checksum"`
		RemindAfterSeconds  int         `json:"remind_after_seconds"`
		PublishedAt         *gtime.Time `json:"published_at"`
		CreatedAt           *gtime.Time `json:"created_at"`
		UpdatedAt           *gtime.Time `json:"updated_at"`
	}
	err = imtenant.RegistryDB().Model("im_app_releases").Safe().Ctx(ctx).
		Where("platform", platform).Where("channel", channel).Limit(1).Scan(&row)
	if err != nil {
		return nil, gerror.Wrap(err, "获取IM客户端版本策略失败")
	}
	if row.ID <= 0 {
		return nil, gerror.New("IM客户端版本策略不存在")
	}
	return &api.AppReleaseLatestRes{
		ID: row.ID, Platform: row.Platform, Channel: row.Channel,
		LatestVersion: row.LatestVersion, MinSupportedVersion: row.MinSupportedVersion,
		UpdateType: row.UpdateType, ReleaseNotes: row.ReleaseNotes, StoreURL: row.StoreURL,
		PackageURL: row.PackageURL, Checksum: row.Checksum, RemindAfterSeconds: row.RemindAfterSeconds,
		PublishedAt: gtimeToRFC3339(row.PublishedAt), CreatedAt: gtimeToRFC3339(row.CreatedAt), UpdatedAt: gtimeToRFC3339(row.UpdatedAt),
	}, nil
}

func getTenant(ctx context.Context, field string, value any) (*entity.ImTenant, error) {
	var tenant *entity.ImTenant
	if err := imtenant.RegistryDB().Model(dao.ImTenant.Table()).Safe().Ctx(ctx).Where(field, value).Scan(&tenant); err != nil {
		return nil, gerror.Wrap(err, "获取IM租户配置失败")
	}
	if tenant == nil || tenant.Id <= 0 {
		return nil, gerror.New("IM租户不存在")
	}
	return tenant, nil
}

func tenantToModel(tenant *entity.ImTenant) *api.TenantModel {
	if tenant == nil {
		return nil
	}
	desc := tenant.TenantDesc
	return &api.TenantModel{
		ID:         tenant.Id,
		Code:       tenant.Code,
		Name:       tenant.Name,
		TenantDesc: &desc,
		DBName:     tenant.DbName,
		DBDSN:      tenant.DbDsn,
		State:      tenant.State,
		CreatedAt:  gtimeToRFC3339(tenant.CreatedAt),
		CreatedBy:  tenant.CreatedBy,
		UpdatedAt:  gtimeToRFC3339(tenant.UpdatedAt),
		UpdatedBy:  tenant.UpdatedBy,
	}
}

func gtimeToRFC3339(t *gtime.Time) string {
	if t == nil {
		return ""
	}
	return t.Time.Format("2006-01-02T15:04:05Z07:00")
}

func splitKeys(raw string) []string {
	if raw == "" {
		return nil
	}
	parts := strings.Split(raw, ",")
	keys := make([]string, 0, len(parts))
	for _, part := range parts {
		if part = strings.TrimSpace(part); part != "" {
			keys = append(keys, part)
		}
	}
	return keys
}