package model

import (
	"context"
	"errors"
	"time"

	"gorm.io/gorm"

	"spark-server/internal/module/friend/entity"
	"spark-server/internal/pkg/errs"
)

// FriendRemark maps table friend_remarks.
type FriendRemark struct {
	UserID    int64     `gorm:"column:user_id;primaryKey;comment:备注所属用户"`
	FriendID  int64     `gorm:"column:friend_id;primaryKey;comment:被备注的用户"`
	Remark    string    `gorm:"column:remark;comment:备注名，仅对备注者可见"`
	UpdatedAt time.Time `gorm:"column:updated_at;comment:更新时间"`
}

func (FriendRemark) TableName() string { return "friend_remarks" }

func (m *Repo) GetRemark(ctx context.Context, userID, friendID int64) (string, error) {
	db, err := m.session(ctx)
	if err != nil {
		return "", err
	}
	var row FriendRemark
	if err := db.Where("user_id = ? AND friend_id = ?", userID, friendID).Take(&row).Error; err != nil {
		mapped := mapDBErr(err)
		if errors.Is(mapped, errs.ErrNotFound) {
			return "", nil
		}
		return "", mapped
	}
	return row.Remark, nil
}

func (m *Repo) ListRemarks(ctx context.Context, userID int64, friendIDs []int64) (map[int64]string, error) {
	out := make(map[int64]string, len(friendIDs))
	if len(friendIDs) == 0 {
		return out, nil
	}
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var rows []FriendRemark
	if err := db.Where("user_id = ? AND friend_id IN ?", userID, friendIDs).Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	for i := range rows {
		out[rows[i].FriendID] = rows[i].Remark
	}
	return out, nil
}

func (m *Repo) SetRemark(ctx context.Context, userID, friendID int64, remark string) error {
	if userID <= 0 || friendID <= 0 {
		return errs.ErrInvalidArgument
	}
	db, err := m.session(ctx)
	if err != nil {
		return err
	}
	row := FriendRemark{UserID: userID, FriendID: friendID, Remark: remark, UpdatedAt: time.Now()}
	return mapDBErr(db.Save(&row).Error)
}

func upsertRemarks(tx *gorm.DB, remarks []entity.Remark) error {
	for i := range remarks {
		r := remarks[i]
		if r.UserID <= 0 || r.FriendID <= 0 || r.Text == "" {
			continue
		}
		row := FriendRemark{UserID: r.UserID, FriendID: r.FriendID, Remark: r.Text, UpdatedAt: r.UpdatedAt}
		if err := tx.Save(&row).Error; err != nil {
			return mapDBErr(err)
		}
	}
	return nil
}

func deleteRemarksBetween(tx *gorm.DB, a, b int64) error {
	err := tx.Where("(user_id = ? AND friend_id = ?) OR (user_id = ? AND friend_id = ?)", a, b, b, a).
		Delete(&FriendRemark{}).Error
	return mapDBErr(err)
}