package service

import (
	"context"
	"log/slog"

	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/global"
	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/dto"
	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/mysqldao"
	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/mysqlmodel"
	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/redisdao"
	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/pkg/errcode"
	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/pkg/upload"
)

// ClosetShareService 衣柜分享业务服务。
type ClosetShareService struct {
	shareDao     *mysqldao.ClosetShareDao
	shareItemDao *mysqldao.ClosetShareItemDao
	receiverDao  *mysqldao.ClosetShareReceiverDao
	clothesDao   *mysqldao.ClothesDao
	userDao      *mysqldao.UserDao
	auditLogDao  *mysqldao.ClosetAuditLogDao
}

// NewClosetShareService 创建衣柜分享服务。
func NewClosetShareService() *ClosetShareService {
	return &ClosetShareService{
		shareDao:     mysqldao.NewClosetShareDao(),
		shareItemDao: mysqldao.NewClosetShareItemDao(),
		receiverDao:  mysqldao.NewClosetShareReceiverDao(),
		clothesDao:   mysqldao.NewClothesDao(),
		userDao:      mysqldao.NewUserDao(),
		auditLogDao:  mysqldao.NewClosetAuditLogDao(),
	}
}

// Create 创建衣柜分享。部分分享需指定衣物；全量快照分享快照当前全部衣物。创建即自动审核通过。
func (s *ClosetShareService) Create(ctx context.Context, userID int64, request *dto.ClosetShareCreateRequest) (*dto.ClosetShareCreateResponse, *errcode.Error) {
	ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareCreate")
	defer span.End()

	// 校验过期时间：必须晚于当前时间（0 表示不设置过期时间）。
	if request.ExpireTime > 0 && request.ExpireTime <= nowUnix() {
		return nil, errcode.InvalidParams.WithDetails("过期时间必须晚于当前时间")
	}

	// 1. 确定分享的衣物 ID 集合。
	var clothesIDs []int64
	switch request.ShareType {
	case ShareTypePartial:
		if len(request.ClothesUUIDs) == 0 {
			return nil, errcode.InvalidParams.WithDetails("部分分享需选择衣物")
		}
		ids, cerr := s.resolveOwnedClothesIDs(ctx, userID, request.ClothesUUIDs)
		if cerr != nil {
			return nil, cerr
		}
		clothesIDs = ids
	case ShareTypeSnapshot:
		ids, err := s.allUserClothesIDs(ctx, userID)
		if err != nil {
			return nil, errcode.DatabaseError
		}
		clothesIDs = ids
	default:
		return nil, errcode.InvalidParams
	}

	// 2. 消耗衣柜分享每日额度。
	if qerr := consumeDailyQuota(ctx, userID, QuotaTypeClosetShare, 1, "衣柜分享消耗"); qerr != nil {
		return nil, qerr
	}

	// 3. 创建分享。
	shareUUID := genUUID()
	share := &mysqlmodel.ClosetShare{
		ShareUUID:  shareUUID,
		UserID:     userID,
		ShareType:  request.ShareType,
		ExpireTime: request.ExpireTime,
		Status:     ShareStatusNormal,
	}
	if err := s.shareDao.ClosetShareCreate(ctx, share); err != nil {
		refundDailyQuota(ctx, userID, QuotaTypeClosetShare, 1)
		return nil, errcode.DatabaseError
	}

	// 4. 快照衣物明细（明细是分享核心数据，失败则回退额度并报错，避免产生空分享）。
	items := make([]mysqlmodel.ClosetShareItem, 0, len(clothesIDs))
	for _, cid := range clothesIDs {
		items = append(items, mysqlmodel.ClosetShareItem{ShareUUID: shareUUID, ClothesID: cid})
	}
	if err := s.shareItemDao.ClosetShareItemCreateBatch(ctx, items); err != nil {
		refundDailyQuota(ctx, userID, QuotaTypeClosetShare, 1)
		return nil, errcode.DatabaseError
	}

	// 5. 自动审核通过，写审核日志（best-effort：失败仅告警不阻断创建）。
	if err := s.auditLogDao.ClosetAuditLogCreate(ctx, &mysqlmodel.ClosetAuditLog{
		TargetID:    share.ID,
		AuditResult: AuditResultPass,
		AuditTime:   nowUnix(),
	}); err != nil {
		slog.WarnContext(ctx, "write closet audit log failed", "share_id", share.ID, "error", err)
	}

	recordDailyUsage(ctx, userID, QuotaTypeClosetShare)

	return &dto.ClosetShareCreateResponse{ShareUUID: shareUUID}, nil
}

// Detail 查看分享详情（访客/属主视角）。
func (s *ClosetShareService) Detail(ctx context.Context, userID int64, shareUUID string) (*dto.ClosetShareDetailResponse, *errcode.Error) {
	ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareDetail")
	defer span.End()

	share, err := s.shareDao.ClosetShareGetByUUID(ctx, shareUUID)
	if err != nil {
		if isNotFound(err) {
			return nil, errcode.ShareNotFound
		}
		return nil, errcode.DatabaseError
	}

	// 状态校验。
	switch share.Status {
	case ShareStatusCancelled:
		return nil, errcode.ShareCancelled
	case ShareStatusBanned:
		return nil, errcode.ShareNotFound
	case ShareStatusExpired:
		return nil, errcode.ShareExpired
	}
	// 时间过期校验。
	if share.ExpireTime > 0 && nowUnix() > share.ExpireTime {
		_ = s.shareDao.ClosetShareUpdateStatus(ctx, shareUUID, ShareStatusExpired)
		return nil, errcode.ShareExpired
	}

	isOwner := share.UserID == userID

	// 访问计数（访客计入）。
	if !isOwner {
		_, _ = redisdao.ClosetShareViewIncr(ctx, shareUUID)
	}

	// 加载分享的衣物。
	shareItems, ierr := s.shareItemDao.ClosetShareItemListByShareUUID(ctx, shareUUID)
	if ierr != nil {
		return nil, errcode.DatabaseError
	}
	clothesIDs := make([]int64, 0, len(shareItems))
	for _, it := range shareItems {
		clothesIDs = append(clothesIDs, it.ClothesID)
	}
	clothesList, cerr := s.clothesDao.ClothesGetByIDs(ctx, clothesIDs)
	if cerr != nil {
		return nil, errcode.DatabaseError
	}
	clothesResp := make([]dto.ClothesGetByUUIDResponse, 0, len(clothesList))
	for i := range clothesList {
		clothesResp = append(clothesResp, buildClothesResponse(&clothesList[i]))
	}

	// 记录接收关系：登录且非属主用户成功访问即视为收到，幂等，失败不阻断详情返回。
	if userID > 0 && !isOwner {
		if rerr := s.receiverDao.ClosetShareReceiverUpsert(ctx, shareUUID, userID); rerr != nil {
			slog.WarnContext(ctx, "record closet share receiver failed", "share_uuid", shareUUID, "user_id", userID, "error", rerr)
		}
	}

	// 分享者信息。
	ownerName, ownerAvatar := "", ""
	if owner, oerr := s.userDao.UserGetByID(ctx, share.UserID); oerr == nil {
		ownerName = owner.Username
		ownerAvatar = upload.AvatarURL(owner.Avatar)
	}

	return &dto.ClosetShareDetailResponse{
		ShareUUID:   shareUUID,
		OwnerName:   ownerName,
		OwnerAvatar: ownerAvatar,
		Clothes:     clothesResp,
		ExpireTime:  share.ExpireTime,
		Status:      share.Status,
		IsOwner:     isOwner,
	}, nil
}

// List 分页查询我的分享。
func (s *ClosetShareService) List(ctx context.Context, userID int64, request *dto.ClosetShareListRequest) (*dto.ShareListResponse, *errcode.Error) {
	ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareList")
	defer span.End()

	page, pageSize := normalizePage(request.Page, request.PageSize)

	list, total, err := s.shareDao.ClosetShareListByUserID(ctx, userID, request.Status, page, pageSize)
	if err != nil {
		return nil, errcode.DatabaseError
	}

	// 批量统计各分享的衣物数量。
	shareUUIDs := make([]string, 0, len(list))
	for _, sh := range list {
		shareUUIDs = append(shareUUIDs, sh.ShareUUID)
	}
	countByShare := make(map[string]int, len(list))
	if allItems, ierr := s.shareItemDao.ClosetShareItemListByShareUUIDs(ctx, shareUUIDs); ierr == nil {
		for _, it := range allItems {
			countByShare[it.ShareUUID]++
		}
	}

	items := make([]dto.ClosetShareItemResponse, 0, len(list))
	for _, sh := range list {
		items = append(items, dto.ClosetShareItemResponse{
			ShareUUID:    sh.ShareUUID,
			ShareType:    sh.ShareType,
			ClothesCount: countByShare[sh.ShareUUID],
			ExpireTime:   sh.ExpireTime,
			Status:       sh.Status,
		})
	}

	return &dto.ShareListResponse{
		PageResponse: dto.PageResponse{Total: total, Page: page, PageSize: pageSize},
		List:         items,
	}, nil
}

// ListReceived 分页查询"分享给我的"分享。
func (s *ClosetShareService) ListReceived(ctx context.Context, userID int64, request *dto.ClosetShareListRequest) (*dto.ShareListResponse, *errcode.Error) {
	ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareReceivedList")
	defer span.End()

	page, pageSize := normalizePage(request.Page, request.PageSize)

	list, total, err := s.receiverDao.ClosetShareReceivedList(ctx, userID, request.Status, page, pageSize)
	if err != nil {
		return nil, errcode.DatabaseError
	}

	// 批量统计各分享的衣物数量。
	shareUUIDs := make([]string, 0, len(list))
	ownerIDs := make([]int64, 0, len(list))
	for _, sh := range list {
		shareUUIDs = append(shareUUIDs, sh.ShareUUID)
		ownerIDs = append(ownerIDs, sh.UserID)
	}
	countByShare := make(map[string]int, len(list))
	if allItems, ierr := s.shareItemDao.ClosetShareItemListByShareUUIDs(ctx, shareUUIDs); ierr == nil {
		for _, it := range allItems {
			countByShare[it.ShareUUID]++
		}
	}

	// 批量查询分享者信息。
	ownerByID := make(map[int64]mysqlmodel.User, len(ownerIDs))
	if owners, oerr := s.userDao.UserGetByIDs(ctx, ownerIDs); oerr == nil {
		for _, u := range owners {
			ownerByID[u.ID] = u
		}
	}

	items := make([]dto.ClosetShareItemResponse, 0, len(list))
	for _, sh := range list {
		ownerName, ownerAvatar := "", ""
		if owner, ok := ownerByID[sh.UserID]; ok {
			ownerName = owner.Username
			ownerAvatar = upload.AvatarURL(owner.Avatar)
		}
		items = append(items, dto.ClosetShareItemResponse{
			ShareUUID:    sh.ShareUUID,
			ShareType:    sh.ShareType,
			ClothesCount: countByShare[sh.ShareUUID],
			ExpireTime:   sh.ExpireTime,
			Status:       sh.Status,
			OwnerName:    ownerName,
			OwnerAvatar:  ownerAvatar,
		})
	}

	return &dto.ShareListResponse{
		PageResponse: dto.PageResponse{Total: total, Page: page, PageSize: pageSize},
		List:         items,
	}, nil
}

// Cancel 取消分享（校验归属）。
func (s *ClosetShareService) Cancel(ctx context.Context, userID int64, request *dto.ClosetShareCancelRequest) (*dto.CollectResponse, *errcode.Error) {
	ctx, span := global.Tracer.Start(ctx, "svc.ClosetShareCancel")
	defer span.End()

	share, err := s.shareDao.ClosetShareGetByUUID(ctx, request.ShareUUID)
	if err != nil {
		if isNotFound(err) {
			return nil, errcode.ShareNotFound
		}
		return nil, errcode.DatabaseError
	}
	if share.UserID != userID {
		return nil, errcode.Forbidden
	}
	if err := s.shareDao.ClosetShareUpdateStatus(ctx, request.ShareUUID, ShareStatusCancelled); err != nil {
		return nil, errcode.DatabaseError
	}
	return &dto.CollectResponse{}, nil
}

// ---- 内部辅助 ----

// resolveOwnedClothesIDs 校验衣物均属于用户，返回有序去重的 clothesID 列表。
func (s *ClosetShareService) resolveOwnedClothesIDs(ctx context.Context, userID int64, uuids []string) ([]int64, *errcode.Error) {
	dedup := make([]string, 0, len(uuids))
	seen := make(map[string]struct{}, len(uuids))
	for _, u := range uuids {
		if _, ok := seen[u]; ok {
			continue
		}
		seen[u] = struct{}{}
		dedup = append(dedup, u)
	}

	clothesList, err := s.clothesDao.ClothesGetByUUIDs(ctx, dedup)
	if err != nil {
		return nil, errcode.DatabaseError
	}
	byUUID := make(map[string]mysqlmodel.Clothes, len(clothesList))
	for _, c := range clothesList {
		byUUID[c.ClothesUUID] = c
	}

	ids := make([]int64, 0, len(dedup))
	for _, u := range dedup {
		c, ok := byUUID[u]
		if !ok {
			return nil, errcode.ClothesNotFound
		}
		if c.UserID != userID {
			return nil, errcode.ClothesNoPermission
		}
		ids = append(ids, c.ID)
	}
	return ids, nil
}

// allUserClothesIDs 获取用户当前全部衣物 ID（分页遍历）。
func (s *ClosetShareService) allUserClothesIDs(ctx context.Context, userID int64) ([]int64, error) {
	var ids []int64
	page, pageSize := 1, 200
	for {
		list, total, err := s.clothesDao.ClothesListByUserID(ctx, userID, "", "", page, pageSize)
		if err != nil {
			return nil, err
		}
		for _, c := range list {
			ids = append(ids, c.ID)
		}
		if len(list) == 0 || int64(page*pageSize) >= total {
			break
		}
		page++
	}
	return ids, nil
}