package mysqldao

import (
	"context"

	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/global"
	"git.lzcwy.cn/zhengchiliu/zt-closet-backend/internal/mysqlmodel"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

// ClosetShareDao 衣柜分享数据访问
type ClosetShareDao struct {
	db *gorm.DB
}

// NewClosetShareDao 创建衣柜分享 DAO
func NewClosetShareDao() *ClosetShareDao {
	return &ClosetShareDao{db: global.MysqlEngine}
}

// ClosetShareCreate 创建分享
func (d *ClosetShareDao) ClosetShareCreate(ctx context.Context, share *mysqlmodel.ClosetShare) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareCreate")
	defer span.End()

	if err := d.db.WithContext(ctx).Create(share).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// ClosetShareUpdateStatus 更新分享状态（取消/封禁）
func (d *ClosetShareDao) ClosetShareUpdateStatus(ctx context.Context, shareUUID string, status int8) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareUpdateStatus")
	defer span.End()

	if err := d.db.WithContext(ctx).Model(&mysqlmodel.ClosetShare{}).Where("share_uuid = ?", shareUUID).UpdateColumn("status", status).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// ClosetShareGetByUUID 按 UUID 查询分享
func (d *ClosetShareDao) ClosetShareGetByUUID(ctx context.Context, shareUUID string) (*mysqlmodel.ClosetShare, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareGetByUUID")
	defer span.End()

	var share mysqlmodel.ClosetShare
	if err := d.db.WithContext(ctx).Where("share_uuid = ?", shareUUID).First(&share).Error; err != nil {
		span.RecordError(err)
		return nil, err
	}
	return &share, nil
}

// ClosetShareListByUserID 分页查询我的分享（status 为 0 不筛选）
func (d *ClosetShareDao) ClosetShareListByUserID(ctx context.Context, userID int64, status int8, page, pageSize int) ([]mysqlmodel.ClosetShare, int64, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareListByUserID")
	defer span.End()

	var list []mysqlmodel.ClosetShare
	var total int64
	q := d.db.WithContext(ctx).Model(&mysqlmodel.ClosetShare{}).Where("user_id = ?", userID)
	if status != 0 {
		q = q.Where("status = ?", status)
	}
	if err := q.Count(&total).Error; err != nil {
		span.RecordError(err)
		return nil, 0, err
	}
	if err := q.Offset((page - 1) * pageSize).Limit(pageSize).Order("id DESC").Find(&list).Error; err != nil {
		span.RecordError(err)
		return nil, 0, err
	}
	return list, total, nil
}

// ClosetShareItemDao 分享明细数据访问
type ClosetShareItemDao struct {
	db *gorm.DB
}

// NewClosetShareItemDao 创建分享明细 DAO
func NewClosetShareItemDao() *ClosetShareItemDao {
	return &ClosetShareItemDao{db: global.MysqlEngine}
}

// ClosetShareItemCreateBatch 批量创建分享明细
func (d *ClosetShareItemDao) ClosetShareItemCreateBatch(ctx context.Context, items []mysqlmodel.ClosetShareItem) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareItemCreateBatch")
	defer span.End()

	if len(items) == 0 {
		return nil
	}
	if err := d.db.WithContext(ctx).Create(&items).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// ClosetShareItemDeleteByShareUUID 删除分享明细
func (d *ClosetShareItemDao) ClosetShareItemDeleteByShareUUID(ctx context.Context, shareUUID string) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareItemDeleteByShareUUID")
	defer span.End()

	if err := d.db.WithContext(ctx).Where("share_uuid = ?", shareUUID).Delete(&mysqlmodel.ClosetShareItem{}).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// ClosetShareItemListByShareUUID 查询分享明细
func (d *ClosetShareItemDao) ClosetShareItemListByShareUUID(ctx context.Context, shareUUID string) ([]mysqlmodel.ClosetShareItem, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareItemListByShareUUID")
	defer span.End()

	var list []mysqlmodel.ClosetShareItem
	if err := d.db.WithContext(ctx).Where("share_uuid = ?", shareUUID).Find(&list).Error; err != nil {
		span.RecordError(err)
		return nil, err
	}
	return list, nil
}

// ClosetShareItemListByShareUUIDs 批量查询分享明细
func (d *ClosetShareItemDao) ClosetShareItemListByShareUUIDs(ctx context.Context, shareUUIDs []string) ([]mysqlmodel.ClosetShareItem, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareItemListByShareUUIDs")
	defer span.End()

	var list []mysqlmodel.ClosetShareItem
	if len(shareUUIDs) == 0 {
		return list, nil
	}
	if err := d.db.WithContext(ctx).Where("share_uuid IN ?", shareUUIDs).Find(&list).Error; err != nil {
		span.RecordError(err)
		return nil, err
	}
	return list, nil
}

// ClosetShareReceiverDao 衣柜分享接收人数据访问
type ClosetShareReceiverDao struct {
	db *gorm.DB
}

// NewClosetShareReceiverDao 创建衣柜分享接收人 DAO
func NewClosetShareReceiverDao() *ClosetShareReceiverDao {
	return &ClosetShareReceiverDao{db: global.MysqlEngine}
}

// ClosetShareReceiverUpsert 幂等记录接收关系：唯一索引冲突时不做任何事，避免重复记录。
func (d *ClosetShareReceiverDao) ClosetShareReceiverUpsert(ctx context.Context, shareUUID string, receiverUserID int64) error {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareReceiverUpsert")
	defer span.End()

	receiver := &mysqlmodel.ClosetShareReceiver{
		ShareUUID:      shareUUID,
		ReceiverUserID: receiverUserID,
	}
	if err := d.db.WithContext(ctx).Clauses(clause.OnConflict{DoNothing: true}).Create(receiver).Error; err != nil {
		span.RecordError(err)
		return err
	}
	return nil
}

// ClosetShareReceivedList 联表分页查询某接收人收到的分享（status 为 0 不筛选）。
func (d *ClosetShareReceiverDao) ClosetShareReceivedList(ctx context.Context, receiverUserID int64, status int8, page, pageSize int) ([]mysqlmodel.ClosetShare, int64, error) {
	ctx, span := global.Tracer.Start(ctx, "mysqldao.ClosetShareReceivedList")
	defer span.End()

	var list []mysqlmodel.ClosetShare
	var total int64

	q := d.db.WithContext(ctx).
		Model(&mysqlmodel.ClosetShare{}).
		Joins("JOIN closet_share_receivers r ON r.share_uuid = closet_shares.share_uuid").
		Where("r.receiver_user_id = ?", receiverUserID)
	if status != 0 {
		q = q.Where("closet_shares.status = ?", status)
	}
	if err := q.Count(&total).Error; err != nil {
		span.RecordError(err)
		return nil, 0, err
	}
	if err := q.Select("closet_shares.*").
		Order("r.id DESC").
		Offset((page - 1) * pageSize).
		Limit(pageSize).
		Find(&list).Error; err != nil {
		span.RecordError(err)
		return nil, 0, err
	}
	return list, total, nil
}