package user

import (
	"context"
	"qnc-server/app/main/model"
	"qnc-server/common/ctxdata"
	"qnc-server/common/xerr"

	"github.com/zeromicro/go-zero/core/mr"

	"github.com/pkg/errors"
	"github.com/zeromicro/go-zero/core/stores/sqlx"

	"qnc-server/app/main/api/internal/svc"

	"github.com/zeromicro/go-zero/core/logx"
)

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

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

func (l *CancelOutLogic) CancelOut() error {
	userID, getUserIdErr := ctxdata.GetUidFromCtx(l.ctx)
	if getUserIdErr != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "用户信息, %v", getUserIdErr)
	}

	// 1. 先检查用户是否是代理
	agentModel, err := l.svcCtx.AgentModel.FindOneByUserId(l.ctx, userID)
	if err != nil && !errors.Is(err, model.ErrNotFound) {
		return errors.Wrapf(err, "查询代理信息失败, userId: %d", userID)
	}

	// 如果用户是代理，进行额外检查
	if agentModel != nil {
		// 1.1 检查代理等级是否为黄金或钻石（新系统）
		levelName := ""
		switch agentModel.Level {
		case 2:
			levelName = "黄金"
		case 3:
			levelName = "钻石"
		}
		if agentModel.Level == 2 || agentModel.Level == 3 {
			return errors.Wrapf(xerr.NewErrMsg("您是"+levelName+"代理，请联系客服进行注销"), "用户是高级代理，不能注销")
		}

		// 1.2 检查代理钱包是否有余额或冻结金额
		wallet, err := l.svcCtx.AgentWalletModel.FindOneByAgentId(l.ctx, agentModel.Id)
		if err != nil && !errors.Is(err, model.ErrNotFound) {
			return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "查询代理钱包失败, agentId: %d", agentModel.Id)
		}

		if wallet != nil && (wallet.Balance > 0 || wallet.FrozenBalance > 0) {
			if wallet.Balance > 0 {
				return errors.Wrapf(xerr.NewErrMsg("您的钱包还有余额%.2f元，请先提现后再注销账号"), "用户钱包有余额，不能注销: %.2f", wallet.Balance)
			}
			if wallet.FrozenBalance > 0 {
				return errors.Wrapf(xerr.NewErrMsg("您的钱包还有冻结金额%.2f元，请等待解冻后再注销账号"), "用户钱包有冻结金额，不能注销: %.2f", wallet.FrozenBalance)
			}
		}
	}

	// 在事务中处理用户注销相关操作
	err = l.svcCtx.UserModel.Trans(l.ctx, func(tranCtx context.Context, session sqlx.Session) error {
		// 1. 删除用户基本信息
		if err := l.svcCtx.UserModel.Delete(tranCtx, session, userID); err != nil {
			return errors.Wrapf(err, "删除用户基本信息失败, userId: %d", userID)
		}

		// 2. 查询并删除用户授权信息
		UserAuthModelBuilder := l.svcCtx.UserAuthModel.SelectBuilder().Where("user_id = ?", userID)
		userAuths, err := l.svcCtx.UserAuthModel.FindAll(tranCtx, UserAuthModelBuilder, "")
		if err != nil && !errors.Is(err, model.ErrNotFound) {
			return errors.Wrapf(err, "查询用户授权信息失败, userId: %d", userID)
		}

		// 并发删除用户授权信息
		if len(userAuths) > 0 {
			funcs := make([]func() error, len(userAuths))
			for i, userAuth := range userAuths {
				authID := userAuth.Id
				funcs[i] = func() error {
					return l.svcCtx.UserAuthModel.Delete(tranCtx, session, authID)
				}
			}

			if err := mr.Finish(funcs...); err != nil {
				return errors.Wrapf(err, "删除用户授权信息失败")
			}
		}

		// 3. 处理代理相关信息
		if agentModel != nil {
			// 3.1 删除代理信息
			if err := l.svcCtx.AgentModel.Delete(tranCtx, session, agentModel.Id); err != nil {
				return errors.Wrapf(err, "删除代理信息失败, agentId: %d", agentModel.Id)
			}

			// 3.2 删除代理关系信息（新系统使用AgentRelation）
			relationBuilder := l.svcCtx.AgentRelationModel.SelectBuilder().
				Where("parent_id = ? OR child_id = ?", agentModel.Id, agentModel.Id)
			relations, err := l.svcCtx.AgentRelationModel.FindAll(tranCtx, relationBuilder, "")
			if err != nil && !errors.Is(err, model.ErrNotFound) {
				return errors.Wrapf(err, "查询代理关系信息失败, agentId: %d", agentModel.Id)
			}

			// 并发删除代理关系信息
			if len(relations) > 0 {
				relationFuncs := make([]func() error, len(relations))
				for i, relation := range relations {
					relationId := relation.Id
					relationFuncs[i] = func() error {
						return l.svcCtx.AgentRelationModel.Delete(tranCtx, session, relationId)
					}
				}

				if err := mr.Finish(relationFuncs...); err != nil {
					return errors.Wrapf(err, "删除代理关系信息失败")
				}
			}

			// 3.3 删除代理钱包信息
			wallet, err := l.svcCtx.AgentWalletModel.FindOneByAgentId(tranCtx, agentModel.Id)
			if err != nil && !errors.Is(err, model.ErrNotFound) {
				return errors.Wrapf(err, "查询代理钱包信息失败, agentId: %d", agentModel.Id)
			}

			if wallet != nil {
				if err := l.svcCtx.AgentWalletModel.Delete(tranCtx, session, wallet.Id); err != nil {
					return errors.Wrapf(err, "删除代理钱包信息失败, walletId: %d", wallet.Id)
				}
			}

		// 3.3 已在上一步处理，删除代理关系信息
	}

	// 4. 代理审核表已废弃，无需删除审核信息

		// 5. 删除用户查询记录
		queryBuilder := l.svcCtx.QueryModel.SelectBuilder().Where("user_id = ?", userID)
		queries, err := l.svcCtx.QueryModel.FindAll(tranCtx, queryBuilder, "")
		if err != nil && !errors.Is(err, model.ErrNotFound) {
			return errors.Wrapf(err, "查询用户查询记录失败, userId: %d", userID)
		}

		if len(queries) > 0 {
			queryFuncs := make([]func() error, len(queries))
			for i, query := range queries {
				queryId := query.Id
				queryFuncs[i] = func() error {
					return l.svcCtx.QueryModel.Delete(tranCtx, session, queryId)
				}
			}

			if err := mr.Finish(queryFuncs...); err != nil {
				return errors.Wrapf(err, "删除用户查询记录失败")
			}
		}

		// 6. 删除用户订单记录
		orderBuilder := l.svcCtx.OrderModel.SelectBuilder().Where("user_id = ?", userID)
		orders, err := l.svcCtx.OrderModel.FindAll(tranCtx, orderBuilder, "")
		if err != nil && !errors.Is(err, model.ErrNotFound) {
			return errors.Wrapf(err, "查询用户订单记录失败, userId: %d", userID)
		}

		if len(orders) > 0 {
			orderFuncs := make([]func() error, len(orders))
			for i, order := range orders {
				orderId := order.Id
				orderFuncs[i] = func() error {
					return l.svcCtx.OrderModel.Delete(tranCtx, session, orderId)
				}
			}

			if err := mr.Finish(orderFuncs...); err != nil {
				return errors.Wrapf(err, "删除用户订单记录失败")
			}
		}

		// 7. 删除代理订单信息
		agentOrderBuilder := l.svcCtx.AgentOrderModel.SelectBuilder().Where("agent_id = ?", agentModel.Id)
		agentOrders, err := l.svcCtx.AgentOrderModel.FindAll(tranCtx, agentOrderBuilder, "")
		if err != nil && !errors.Is(err, model.ErrNotFound) {
			return errors.Wrapf(err, "查询代理订单信息失败, agentId: %d, err: %v", agentModel.Id, err)
		}

		if len(agentOrders) > 0 {
			agentOrderFuncs := make([]func() error, len(agentOrders))
			for i, agentOrder := range agentOrders {
				agentOrderId := agentOrder.Id
				agentOrderFuncs[i] = func() error {
					return l.svcCtx.AgentOrderModel.Delete(tranCtx, session, agentOrderId)
				}
			}

			if err := mr.Finish(agentOrderFuncs...); err != nil {
				return errors.Wrapf(err, "删除代理订单信息失败")
			}
		}
		return nil
	})

	if err != nil {
		return errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "用户注销失败%v", err)
	}

	return nil
}
