package product

import (
	"context"
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"regexp"
	"time"

	"perms-system-server/internal/consts"
	authHelper "perms-system-server/internal/logic/auth"
	productModel "perms-system-server/internal/model/product"
	"perms-system-server/internal/model/productmember"
	userModel "perms-system-server/internal/model/user"
	"perms-system-server/internal/response"
	"perms-system-server/internal/svc"
	"perms-system-server/internal/types"
	"perms-system-server/internal/util"

	"github.com/zeromicro/go-zero/core/logx"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
	"golang.org/x/crypto/bcrypt"
)

// 审计 M-4：CreateProduct 不再把 adminPassword/appSecret 明文写入响应体；改为把"真正的初始凭证"
// 暂存 Redis，并只把一次性消费票据放进响应。票据本身是短期（5 分钟）+ 一次性，即使被上游日志/APM
// 错误记录，也只能换一次而无法长期复用。
const (
	initialCredentialsTTL       = 5 * time.Minute
	initialCredentialsKeyPrefix = "pm:initcred:"
)

// initialCredentialsPayload 实际落 Redis 的凭证载荷。放在内部文件以避免跨包暴露结构。
type initialCredentialsPayload struct {
	AppKey        string `json:"appKey"`
	AppSecret     string `json:"appSecret"`
	AdminUser     string `json:"adminUser"`
	AdminPassword string `json:"adminPassword"`
}

var productCodeRegexp = regexp.MustCompile(`^[a-zA-Z][a-zA-Z0-9_-]{1,63}$`)

type CreateProductLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewCreateProductLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateProductLogic {
	return &CreateProductLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

// CreateProduct 创建产品。仅超管可调用，自动生成 appKey/appSecret 和产品专属管理员账号，用于接入新的业务产品。
func (l *CreateProductLogic) CreateProduct(req *types.CreateProductReq) (resp *types.CreateProductResp, err error) {
	if err := authHelper.RequireSuperAdmin(l.ctx); err != nil {
		return nil, err
	}

	if !productCodeRegexp.MatchString(req.Code) {
		return nil, response.ErrBadRequest("产品编码只能包含字母、数字、下划线和中划线，须以字母开头，长度2-64")
	}
	if len(req.Name) > 64 {
		return nil, response.ErrBadRequest("产品名称长度不能超过64个字符")
	}
	if len(req.Remark) > 255 {
		return nil, response.ErrBadRequest("备注长度不能超过255个字符")
	}
	// 审计 L-R10-1：必须显式携带 adminDeptId，并在入库前核实部门存在 + 启用状态。否则产出的
	// admin_<code> 账号 DeptId=0 / DeptPath="" 时，
	//   - CheckAddMemberAccess 要求 caller 有 DeptPath → AddMember 直接 403；
	//   - CreateUser 非超管分支要求 caller 有 DeptPath 且新 dept 在其前缀下 → CreateUser 直接 403；
	//   - UpdateUser 禁止改自己部门 → admin 自救也走不通；
	// 必须由超管在创建阶段就把归属定清楚，避免把后续自助接入流程悬挂。
	if req.AdminDeptId <= 0 {
		return nil, response.ErrBadRequest("必须指定管理员账号的初始部门（adminDeptId）")
	}
	adminDept, err := l.svcCtx.SysDeptModel.FindOne(l.ctx, req.AdminDeptId)
	if err != nil {
		return nil, response.ErrBadRequest("管理员部门不存在")
	}
	if adminDept.Status != consts.StatusEnabled {
		return nil, response.ErrBadRequest("管理员部门已停用")
	}

	_, findErr := l.svcCtx.SysProductModel.FindOneByCode(l.ctx, req.Code)
	if findErr == nil {
		return nil, response.ErrConflict("产品编码已存在")
	}

	appKey, err := generateRandomHex(16)
	if err != nil {
		return nil, err
	}
	rawAppSecret, err := generateRandomHex(32)
	if err != nil {
		return nil, err
	}
	appSecretHash, err := bcrypt.GenerateFromPassword([]byte(rawAppSecret), bcrypt.DefaultCost)
	if err != nil {
		return nil, err
	}
	now := time.Now().Unix()

	adminUsername := fmt.Sprintf("admin_%s", req.Code)
	if _, err := l.svcCtx.SysUserModel.FindOneByUsername(l.ctx, adminUsername); err == nil {
		return nil, response.ErrConflict(fmt.Sprintf("用户名 %s 已存在，无法自动创建管理员账号", adminUsername))
	}
	// 审计 L-R10-2：改用混合字符集强密码（大小写 + 数字 + 符号），确保通过 util.ValidatePassword
	// 的"同时包含大写、小写、数字"规则。旧的 generateRandomHex(12) 只产生 0-9a-f，首登被强制
	// 改密时本身不影响，但若将来合规/风控链路接入"现有密码强度复核"，初始密码会被判定为不合规。
	adminPassword, err := generateStrongInitialPassword(16)
	if err != nil {
		return nil, err
	}
	hashedPwd, err := bcrypt.GenerateFromPassword([]byte(adminPassword), bcrypt.DefaultCost)
	if err != nil {
		return nil, err
	}

	var (
		productId int64
		adminId   int64
		memberId  int64
	)

	err = l.svcCtx.SysProductModel.TransactCtx(l.ctx, func(ctx context.Context, session sqlx.Session) error {
		result, err := l.svcCtx.SysProductModel.InsertWithTx(ctx, session, &productModel.SysProduct{
			Code:       req.Code,
			Name:       req.Name,
			AppKey:     appKey,
			AppSecret:  string(appSecretHash),
			Remark:     req.Remark,
			Status:     consts.StatusEnabled,
			CreateTime: now,
			UpdateTime: now,
		})
		if err != nil {
			return err
		}
		productId, _ = result.LastInsertId()

		userResult, err := l.svcCtx.SysUserModel.InsertWithTx(ctx, session, &userModel.SysUser{
			Username:           adminUsername,
			Password:           string(hashedPwd),
			Nickname:           fmt.Sprintf("%s管理员", req.Name),
			DeptId:             req.AdminDeptId,
			IsSuperAdmin:       consts.IsSuperAdminNo,
			MustChangePassword: consts.MustChangePasswordYes,
			Status:             consts.StatusEnabled,
			CreateTime:         now,
			UpdateTime:         now,
		})
		if err != nil {
			return err
		}
		adminId, _ = userResult.LastInsertId()

		memberResult, err := l.svcCtx.SysProductMemberModel.InsertWithTx(ctx, session, &productmember.SysProductMember{
			ProductCode: req.Code,
			UserId:      adminId,
			MemberType:  consts.MemberTypeAdmin,
			Status:      consts.StatusEnabled,
			CreateTime:  now,
			UpdateTime:  now,
		})
		if err != nil {
			return err
		}
		memberId, _ = memberResult.LastInsertId()
		return nil
	})

	if err != nil {
		// 前置的 FindOneByCode / FindOneByUsername 已经在大多数合法请求里把"产品码/用户名已存在"
		// 分辨清楚并返回具体文案。落到这里的 1062 基本都是同秒并发创建的稀有竞态，按审计 M-5 的
		// 建议不再用 strings.Contains 匹配 MySQL 错误消息中的索引名（不同版本的文案不稳定，
		// 改索引名会导致静默降级成通用冲突）；直接统一回通用冲突让前端重试，由 pre-check 负责语义。
		if util.IsDuplicateEntryErr(err) {
			return nil, response.ErrConflict("数据冲突，请稍后重试")
		}
		return nil, err
	}

	// 生成一次性凭证票据（32 字节随机，hex 编码）。
	// 审计 M-1：DB 事务已成功提交，下面任一失败路径都必须把 product / user / product_member 三行
	// 一并补偿删除，否则新产生的 admin 明文密码只存在于本次内存里，一旦响应返回 500，账号就成了
	// 永久孤儿（仓库里没有 Delete/ResetInitCred 接口，只能手工改库）。补偿事务本身也可能失败，
	// 所以必须同步打一条 audit=create_product_orphan_cleanup 的 ERROR 日志把 productId/adminId/
	// memberId 落盘，作为告警与人工回捞的最后兜底。
	ticket, err := generateRandomHex(32)
	if err != nil {
		logx.WithContext(l.ctx).Errorf("CreateProduct: generate credentials ticket failed: %v", err)
		l.compensateCreatedRows(productId, adminId, memberId, req.Code, adminUsername, "generate_ticket_failed", err)
		return nil, response.NewCodeError(500, "生成初始凭证票据失败，请稍后重试")
	}
	payload := initialCredentialsPayload{
		AppKey:        appKey,
		AppSecret:     rawAppSecret,
		AdminUser:     adminUsername,
		AdminPassword: adminPassword,
	}
	buf, mErr := json.Marshal(&payload)
	if mErr != nil {
		logx.WithContext(l.ctx).Errorf("CreateProduct: marshal credentials payload failed: %v", mErr)
		l.compensateCreatedRows(productId, adminId, memberId, req.Code, adminUsername, "marshal_payload_failed", mErr)
		return nil, response.NewCodeError(500, "封装初始凭证失败，请稍后重试")
	}
	ticketKey := initialCredentialsKeyPrefix + ticket
	if setErr := l.svcCtx.Redis.SetexCtx(l.ctx, ticketKey, string(buf), int(initialCredentialsTTL/time.Second)); setErr != nil {
		logx.WithContext(l.ctx).Errorf("CreateProduct: stash credentials to redis failed: %v", setErr)
		l.compensateCreatedRows(productId, adminId, memberId, req.Code, adminUsername, "redis_setex_failed", setErr)
		return nil, response.NewCodeError(503, "暂存初始凭证失败，请稍后重试")
	}

	// 仅脱敏字段 + ticket 落响应体。productCode / adminUser 属于可公开的管理信息。
	logx.WithContext(l.ctx).Infof("CreateProduct: product=%s admin=%s credentialsTicketIssued ttl=%s",
		req.Code, adminUsername, initialCredentialsTTL)

	return &types.CreateProductResp{
		Id:                   productId,
		Code:                 req.Code,
		AppKey:               appKey,
		AdminUser:            adminUsername,
		CredentialsTicket:    ticket,
		CredentialsExpiresAt: time.Now().Add(initialCredentialsTTL).Unix(),
	}, nil
}

func generateRandomHex(byteLen int) (string, error) {
	b := make([]byte, byteLen)
	if _, err := rand.Read(b); err != nil {
		return "", fmt.Errorf("generate random bytes failed: %w", err)
	}
	return hex.EncodeToString(b), nil
}

// generateStrongInitialPassword 为产品 admin 初始账号生成强密码：大写+小写+数字+少量符号混合，
// 并通过 util.ValidatePassword 断言，确保任何后续合规复核都不会卡住（见审计 L-R10-2）。
// 长度要求 n >= 8；实际生成 n 个字符，混合字符集字面量已刻意去掉易混淆的 I/l/O/0/1。
func generateStrongInitialPassword(n int) (string, error) {
	if n < 8 {
		n = 8
	}
	const (
		upper   = "ABCDEFGHJKMNPQRSTUVWXYZ"
		lower   = "abcdefghjkmnpqrstuvwxyz"
		digits  = "23456789"
		symbols = "!@#$%^&*"
	)
	alphabet := upper + lower + digits + symbols
	// 把每个字符类至少各取 1 个放在随机位置，保证强度检查一定通过；其余位从总字母表随机。
	classes := []string{upper, lower, digits, symbols}
	pwd := make([]byte, n)
	used := 0
	for _, cls := range classes {
		c, err := randomCharFrom(cls)
		if err != nil {
			return "", err
		}
		pwd[used] = c
		used++
	}
	for i := used; i < n; i++ {
		c, err := randomCharFrom(alphabet)
		if err != nil {
			return "", err
		}
		pwd[i] = c
	}
	if err := shuffleBytes(pwd); err != nil {
		return "", err
	}
	out := string(pwd)
	if msg := util.ValidatePassword(out); msg != "" {
		// 理论上不可达：上面已按字符类强制填充，保留断言避免字符集未来被人修改后静默失效。
		return "", fmt.Errorf("generated password failed strength check: %s", msg)
	}
	return out, nil
}

// randomCharFrom 用 crypto/rand 无偏地从字符集中取一个字节。循环直到命中模长内，避免简单取模偏置。
func randomCharFrom(alphabet string) (byte, error) {
	max := len(alphabet)
	bucket := 256 - (256 % max)
	buf := make([]byte, 1)
	for {
		if _, err := rand.Read(buf); err != nil {
			return 0, err
		}
		if int(buf[0]) < bucket {
			return alphabet[int(buf[0])%max], nil
		}
	}
}

// shuffleBytes Fisher-Yates 洗牌，随机索引基于 crypto/rand；用于打散 generateStrongInitialPassword
// 里"前 4 个字符恰好是各字符类"的固定前缀，避免格式可预测。
func shuffleBytes(buf []byte) error {
	for i := len(buf) - 1; i > 0; i-- {
		bucket := byte(i + 1)
		// 与 randomCharFrom 相同的无偏采样策略，上限很小直接 mod 即可（i<=63）。
		b := make([]byte, 1)
		if _, err := rand.Read(b); err != nil {
			return err
		}
		j := int(b[0] % bucket)
		buf[i], buf[j] = buf[j], buf[i]
	}
	return nil
}

// compensateCreatedRows 是审计 M-1 要求的失败补偿：事务已提交后 ticket/Redis 环节失败时，
// 把刚刚落盘的 sys_product_member / sys_user / sys_product 三行按"子 → 父"顺序全部删掉，
// 把副作用回到"从未创建"状态。补偿事务本身失败的概率不为 0（DB 再抖一次），因此我们：
//  1. 不让补偿失败吞掉原始响应（原始响应已经是 500/503，用户已知失败，继续返就行）；
//  2. 把三个主键落一条 audit=create_product_orphan_cleanup 的 ERROR 日志，带原始错误原因，
//     让告警侧能在第一时间拉出孤儿行做人工处理；
//  3. 补偿成功也打一条 INFO，让回归/测试能观测到补偿路径确实走到。
func (l *CreateProductLogic) compensateCreatedRows(productId, adminId, memberId int64, productCode, adminUsername, reason string, cause error) {
	if productId == 0 && adminId == 0 && memberId == 0 {
		return
	}
	// 用独立 context：l.ctx 走到这里有可能已经带了客户端取消/超时语义，但补偿是"一次尝试"
	// 的后端动作，不应被请求链路取消；5s 超时保证不阻塞响应返回。
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	compErr := l.svcCtx.SysProductModel.TransactCtx(ctx, func(txCtx context.Context, session sqlx.Session) error {
		if memberId > 0 {
			if err := l.svcCtx.SysProductMemberModel.DeleteWithTx(txCtx, session, memberId); err != nil {
				return fmt.Errorf("delete product_member: %w", err)
			}
		}
		if adminId > 0 {
			if err := l.svcCtx.SysUserModel.DeleteWithTx(txCtx, session, adminId); err != nil {
				return fmt.Errorf("delete user: %w", err)
			}
		}
		if productId > 0 {
			if err := l.svcCtx.SysProductModel.DeleteWithTx(txCtx, session, productId); err != nil {
				return fmt.Errorf("delete product: %w", err)
			}
		}
		return nil
	})
	if compErr != nil {
		logx.WithContext(l.ctx).Errorw("create product compensation failed",
			logx.Field("audit", "create_product_orphan_cleanup"),
			logx.Field("result", "compensate_failed"),
			logx.Field("reason", reason),
			logx.Field("cause", fmt.Sprintf("%v", cause)),
			logx.Field("productId", productId),
			logx.Field("productCode", productCode),
			logx.Field("adminId", adminId),
			logx.Field("adminUsername", adminUsername),
			logx.Field("memberId", memberId),
			logx.Field("compensationErr", compErr.Error()),
		)
		return
	}
	logx.WithContext(l.ctx).Infow("create product compensated after post-commit failure",
		logx.Field("audit", "create_product_orphan_cleanup"),
		logx.Field("result", "compensated"),
		logx.Field("reason", reason),
		logx.Field("cause", fmt.Sprintf("%v", cause)),
		logx.Field("productId", productId),
		logx.Field("productCode", productCode),
		logx.Field("adminId", adminId),
		logx.Field("adminUsername", adminUsername),
		logx.Field("memberId", memberId),
	)
}