package model

import (
	"context"

	"gorm.io/gorm"

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

func (m *Repo) ListAllByAuthor(ctx context.Context, authorID int64) ([]*entity.Post, error) {
	if authorID <= 0 {
		return nil, errs.ErrInvalidArgument
	}
	db, err := m.session(ctx)
	if err != nil {
		return nil, err
	}
	var rows []Post
	if err := db.Where("user_id = ?", authorID).Find(&rows).Error; err != nil {
		return nil, mapDBErr(err)
	}
	return collectPosts(rows), nil
}

func (m *Repo) PurgeUser(ctx context.Context, userID int64) error {
	if userID <= 0 {
		return errs.ErrInvalidArgument
	}
	db, err := m.session(ctx)
	if err != nil {
		return err
	}
	return db.Transaction(func(tx *gorm.DB) error {
		return purgeSquareUser(tx, userID)
	})
}

func purgeSquareUser(tx *gorm.DB, userID int64) error {
	if err := bumpOffUserLikes(tx, userID); err != nil {
		return err
	}
	if err := bumpOffUserComments(tx, userID); err != nil {
		return err
	}
	if err := mapDBErr(tx.Where("user_id = ?", userID).Delete(&Like{}).Error); err != nil {
		return err
	}
	if err := mapDBErr(tx.Where("user_id = ?", userID).Delete(&Comment{}).Error); err != nil {
		return err
	}
	if err := mapDBErr(tx.Where("to_user_id = ? OR from_user_id = ?", userID, userID).Delete(&Notice{}).Error); err != nil {
		return err
	}
	if err := mapDBErr(tx.Where("peer_id = ?", userID).Delete(&Audience{}).Error); err != nil {
		return err
	}
	if err := mapDBErr(tx.Where("user_id = ?", userID).Delete(&NoticeState{}).Error); err != nil {
		return err
	}
	return deleteAuthoredPosts(tx, userID)
}

func bumpOffUserLikes(tx *gorm.DB, userID int64) error {
	sql := `UPDATE t_square_posts p
INNER JOIN (SELECT post_id, COUNT(*) AS n FROM t_square_likes WHERE user_id = ? GROUP BY post_id) x ON p.id = x.post_id
SET p.like_count = CASE WHEN p.like_count < x.n THEN 0 ELSE p.like_count - x.n END
WHERE p.user_id <> ?`
	return mapDBErr(tx.Exec(sql, userID, userID).Error)
}

func bumpOffUserComments(tx *gorm.DB, userID int64) error {
	sql := `UPDATE t_square_posts p
INNER JOIN (SELECT post_id, COUNT(*) AS n FROM t_square_comments WHERE user_id = ? AND status = ? GROUP BY post_id) x ON p.id = x.post_id
SET p.comment_count = CASE WHEN p.comment_count < x.n THEN 0 ELSE p.comment_count - x.n END
WHERE p.user_id <> ?`
	return mapDBErr(tx.Exec(sql, userID, entity.StatusNormal, userID).Error)
}

func deleteAuthoredPosts(tx *gorm.DB, userID int64) error {
	var ids []int64
	if err := tx.Model(&Post{}).Where("user_id = ?", userID).Pluck("id", &ids).Error; err != nil {
		return mapDBErr(err)
	}
	if len(ids) == 0 {
		return nil
	}
	if err := mapDBErr(tx.Where("post_id IN ?", ids).Delete(&Audience{}).Error); err != nil {
		return err
	}
	if err := mapDBErr(tx.Where("post_id IN ?", ids).Delete(&Like{}).Error); err != nil {
		return err
	}
	if err := mapDBErr(tx.Where("post_id IN ?", ids).Delete(&Comment{}).Error); err != nil {
		return err
	}
	if err := mapDBErr(tx.Where("post_id IN ?", ids).Delete(&Notice{}).Error); err != nil {
		return err
	}
	return mapDBErr(tx.Where("id IN ?", ids).Delete(&Post{}).Error)
}