package model

import (
	"context"
	"errors"

	"gorm.io/gorm"

	"spark-server/internal/module/moment/entity"
)

func (m *Repo) GetPost(ctx context.Context, id int64) (*entity.Post, error) {
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var row Post
	if err := db.Where("id = ?", id).Take(&row).Error; err != nil {
		return nil, mapDBErr(err)
	}
	return row.Entity(), nil
}

func (m *Repo) ListByAuthors(ctx context.Context, authorIDs []int64, cursor int64, limit int) ([]*entity.Post, error) {
	if len(authorIDs) == 0 {
		return []*entity.Post{}, nil
	}
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	q := db.Where("user_id IN ? AND status = ?", authorIDs, entity.StatusNormal)
	if cursor > 0 {
		q = q.Where("id < ?", cursor)
	}
	var rows []Post
	if err := q.Order("id DESC").Limit(limit).Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	return collectPosts(rows), nil
}

func (m *Repo) ListByAuthor(ctx context.Context, authorID, cursor int64, limit int) ([]*entity.Post, error) {
	return m.ListByAuthors(ctx, []int64{authorID}, cursor, limit)
}

func (m *Repo) ListAudience(ctx context.Context, postIDs []int64) (map[int64][]int64, error) {
	out := make(map[int64][]int64)
	if len(postIDs) == 0 {
		return out, nil
	}
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var rows []Audience
	if err := db.Where("post_id IN ?", postIDs).Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	for _, row := range rows {
		out[row.PostID] = append(out[row.PostID], row.PeerID)
	}
	return out, nil
}

func (m *Repo) ListLikes(ctx context.Context, postIDs []int64) (map[int64][]*entity.Like, error) {
	out := make(map[int64][]*entity.Like)
	if len(postIDs) == 0 {
		return out, nil
	}
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var rows []Like
	if err := db.Where("post_id IN ?", postIDs).Order("created_at ASC").Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	for i := range rows {
		like := rows[i].Entity()
		out[like.PostID] = append(out[like.PostID], like)
	}
	return out, nil
}

func (m *Repo) ListComments(ctx context.Context, postIDs []int64) (map[int64][]*entity.Comment, error) {
	out := make(map[int64][]*entity.Comment)
	if len(postIDs) == 0 {
		return out, nil
	}
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var rows []Comment
	if err := db.Where("post_id IN ?", postIDs).Order("id ASC").Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	for i := range rows {
		c := rows[i].Entity()
		out[c.PostID] = append(out[c.PostID], c)
	}
	return out, nil
}

func (m *Repo) GetComment(ctx context.Context, id int64) (*entity.Comment, error) {
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var row Comment
	if err := db.Where("id = ?", id).Take(&row).Error; err != nil {
		return nil, mapDBErr(err)
	}
	return row.Entity(), nil
}

func (m *Repo) GetSettings(ctx context.Context, userID int64) (*entity.Settings, error) {
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var row Setting
	if err := db.Where("user_id = ?", userID).Take(&row).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return entity.DefaultSettings(userID), nil
		}
		return nil, mapDBErr(err)
	}
	return row.Entity(), nil
}

func (m *Repo) ListSettings(ctx context.Context, userIDs []int64) (map[int64]*entity.Settings, error) {
	out := make(map[int64]*entity.Settings)
	if len(userIDs) == 0 {
		return out, nil
	}
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var rows []Setting
	if err := db.Where("user_id IN ?", userIDs).Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	for i := range rows {
		out[rows[i].UserID] = rows[i].Entity()
	}
	return out, nil
}

func (m *Repo) ListHides(ctx context.Context, userID int64) ([]*entity.Hide, error) {
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var rows []Hide
	if err := db.Where("user_id = ?", userID).Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	out := make([]*entity.Hide, 0, len(rows))
	for i := range rows {
		out = append(out, rows[i].Entity())
	}
	return out, nil
}

func (m *Repo) HideHimIDs(ctx context.Context, userID int64) ([]int64, error) {
	return m.pluckHideIDs(ctx, "user_id = ? AND hide_him = ?", userID, true, "peer_id")
}

func (m *Repo) HideMeFromIDs(ctx context.Context, viewerID int64) ([]int64, error) {
	return m.pluckHideIDs(ctx, "peer_id = ? AND hide_me = ?", viewerID, true, "user_id")
}

func (m *Repo) pluckHideIDs(ctx context.Context, cond string, id int64, flag bool, col string) ([]int64, error) {
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var ids []int64
	if err := db.Model(&Hide{}).Where(cond, id, flag).Pluck(col, &ids).Error; err != nil {
		return nil, mapDBErr(err)
	}
	return ids, nil
}

func (m *Repo) ListNotices(ctx context.Context, userID, cursor int64, limit int) ([]*entity.Notice, error) {
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	q := db.Where("to_user_id = ?", userID)
	if cursor > 0 {
		q = q.Where("id < ?", cursor)
	}
	var rows []Notice
	if err := q.Order("id DESC").Limit(limit).Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	out := make([]*entity.Notice, 0, len(rows))
	for i := range rows {
		out = append(out, rows[i].Entity())
	}
	return out, nil
}

func collectPosts(rows []Post) []*entity.Post {
	out := make([]*entity.Post, 0, len(rows))
	for i := range rows {
		out = append(out, rows[i].Entity())
	}
	return out
}