package model

import (
	"context"
	"time"

	"quyun/app/requests"
	"quyun/database/conds"
	"quyun/database/table"

	. "github.com/go-jet/jet/v2/postgres"
	"github.com/samber/lo"
	log "github.com/sirupsen/logrus"
)

func (m *Posts) log() *log.Entry {
	return log.WithField("model", "PostsModel")
}

func (m *Posts) IncrViewCount(ctx context.Context) error {
	tbl := table.Posts

	stmt := tbl.UPDATE(tbl.Views).SET(tbl.Views.ADD(Int64(1))).WHERE(tbl.ID.EQ(Int64(m.ID)))
	m.log().Infof("sql: %s", stmt.DebugSql())

	var post Posts
	err := stmt.QueryContext(ctx, db, &post)
	if err != nil {
		m.log().Errorf("error updating post view count: %v", err)
		return err
	}
	return nil
}

// GetByID
func (m *Posts) GetByID(ctx context.Context, id int64, cond ...conds.Cond) (*Posts, error) {
	tbl := table.Posts

	var combinedCond BoolExpression = tbl.ID.EQ(Int64(id))
	for _, c := range cond {
		combinedCond = c(combinedCond)
	}
	stmt := tbl.SELECT(tbl.AllColumns).WHERE(combinedCond)
	m.log().Infof("sql: %s", stmt.DebugSql())

	var post Posts
	err := stmt.QueryContext(ctx, db, &post)
	if err != nil {
		m.log().Errorf("error getting post: %v", err)
		return nil, err
	}
	return &post, nil
}

// Create
func (m *Posts) Create(ctx context.Context) error {
	m.CreatedAt = time.Now()
	m.UpdatedAt = time.Now()

	tbl := table.Posts
	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(m).RETURNING(tbl.AllColumns)
	m.log().Infof("sql: %s", stmt.DebugSql())

	if err := stmt.QueryContext(ctx, db, m); err != nil {
		m.log().Errorf("error creating post: %v", err)
		return err
	}
	return nil
}

// Update
func (m *Posts) Update(ctx context.Context) error {
	m.UpdatedAt = time.Now()

	tbl := table.Posts
	stmt := tbl.
		UPDATE(
			tbl.MutableColumns.Except(
				tbl.CreatedAt,
				tbl.DeletedAt,
				tbl.Views,
				tbl.Likes,
			),
		).
		MODEL(m).
		WHERE(tbl.ID.EQ(Int64(m.ID)))
	m.log().Infof("sql: %s", stmt.DebugSql())

	if _, err := stmt.ExecContext(ctx, db); err != nil {
		m.log().Errorf("error updating post: %v", err)
		return err
	}
	return nil
}

// countByCond
func (m *Posts) countByCondition(ctx context.Context, expr BoolExpression) (int64, error) {
	var cnt struct {
		Cnt int64
	}

	tbl := table.Posts
	stmt := SELECT(COUNT(tbl.ID).AS("cnt")).FROM(tbl).WHERE(expr)
	m.log().Infof("sql: %s", stmt.DebugSql())

	err := stmt.QueryContext(ctx, db, &cnt)
	if err != nil {
		m.log().Errorf("error counting post items: %v", err)
		return 0, err
	}

	return cnt.Cnt, nil
}

func (m *Posts) List(ctx context.Context, pagination *requests.Pagination, cond ...conds.Cond) (*requests.Pager, error) {
	pagination.Format()

	combinedCond := table.Posts.DeletedAt.IS_NULL()
	for _, c := range cond {
		combinedCond = c(combinedCond)
	}

	tbl := table.Posts
	stmt := tbl.
		SELECT(tbl.AllColumns).
		WHERE(combinedCond).
		ORDER_BY(tbl.ID.DESC()).
		LIMIT(pagination.Limit).
		OFFSET(pagination.Offset)
	m.log().Infof("sql: %s", stmt.DebugSql())

	var posts []Posts = make([]Posts, 0)
	err := stmt.QueryContext(ctx, db, &posts)
	if err != nil {
		m.log().Errorf("error querying post items: %v", err)
		return nil, err
	}

	count, err := m.countByCondition(ctx, combinedCond)
	if err != nil {
		m.log().Errorf("error getting post count: %v", err)
		return nil, err
	}

	return &requests.Pager{
		Items:      posts,
		Total:      count,
		Pagination: *pagination,
	}, nil
}

// DeleteByID soft delete item
func (m *Posts) Delete(ctx context.Context) error {
	tbl := table.Posts
	stmt := tbl.
		UPDATE(tbl.DeletedAt).
		SET(TimestampT(time.Now())).
		WHERE(
			tbl.ID.EQ(Int64(m.ID)),
		)
	m.log().Infof("sql: %s", stmt.DebugSql())

	if _, err := stmt.ExecContext(ctx, db); err != nil {
		m.log().Errorf("error deleting post: %v", err)
		return err
	}
	return nil
}

// SendTo
func (m *Posts) SendTo(ctx context.Context, userId int64) error {
	// add record to user_posts
	tbl := table.UserPosts
	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(UserPosts{
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
		UserID:    userId,
		PostID:    m.ID,
		Price:     -1,
	})
	m.log().Infof("sql: %s", stmt.DebugSql())
	if _, err := stmt.ExecContext(ctx, db); err != nil {
		m.log().Errorf("error sending post to user: %v", err)
		return err
	}
	return nil
}

// PostBoughtStatistics 获取指定文件 ID 的购买次数
func (m *Posts) BoughtStatistics(ctx context.Context, postIds []int64) (map[int64]int64, error) {
	tbl := table.UserPosts

	// select count(user_id), post_id from user_posts up  where post_id in (1, 2,3,4,5,6,7,8,9,10) group by post_id
	stmt := tbl.
		SELECT(
			COUNT(tbl.UserID).AS("cnt"),
			tbl.PostID.AS("post_id"),
		).
		WHERE(
			tbl.PostID.IN(lo.Map(postIds, func(id int64, _ int) Expression { return Int64(id) })...),
		).
		GROUP_BY(
			tbl.PostID,
		)
	m.log().Infof("sql: %s", stmt.DebugSql())

	var result []struct {
		Cnt    int64
		PostId int64
	}

	if err := stmt.QueryContext(ctx, db, &result); err != nil {
		m.log().Errorf("error getting post bought statistics: %v", err)
		return nil, err
	}

	// convert to map
	resultMap := make(map[int64]int64)
	for _, item := range result {
		resultMap[item.PostId] = item.Cnt
	}

	return resultMap, nil
}

// Bought
func (m *Posts) Bought(ctx context.Context, userId int64, pagination *requests.Pagination) (*requests.Pager, error) {
	pagination.Format()

	// select up.price,up.created_at,p.* from user_posts up  left join posts p on up.post_id = p.id where up.user_id =1
	tbl := table.UserPosts
	stmt := tbl.
		SELECT(
			tbl.Price.AS("price"),
			tbl.CreatedAt.AS("bought_at"),
			table.Posts.Title.AS("title"),
		).
		FROM(
			tbl.INNER_JOIN(table.Posts, table.Posts.ID.EQ(tbl.PostID)),
		).
		WHERE(
			tbl.UserID.EQ(Int64(userId)),
		).
		ORDER_BY(tbl.ID.DESC()).
		LIMIT(pagination.Limit).
		OFFSET(pagination.Offset)

	m.log().Infof("sql: %s", stmt.DebugSql())

	var items []struct {
		Title    string    `json:"title"`
		Price    int64     `json:"price"`
		BoughtAt time.Time `json:"bought_at"`
	}

	if err := stmt.QueryContext(ctx, db, &items); err != nil {
		m.log().Errorf("error getting bought posts: %v", err)
		return nil, err
	}

	// convert to Posts
	var cnt struct {
		Cnt int64
	}
	stmtCnt := tbl.
		SELECT(COUNT(tbl.ID).AS("cnt")).
		WHERE(
			tbl.UserID.EQ(Int64(userId)),
		)

	if err := stmtCnt.QueryContext(ctx, db, &cnt); err != nil {
		m.log().Errorf("error getting bought posts count: %v", err)
		return nil, err
	}

	return &requests.Pager{
		Items:      items,
		Total:      cnt.Cnt,
		Pagination: *pagination,
	}, nil
}

// GetPostsMapByIDs
func (m *Posts) GetPostsMapByIDs(ctx context.Context, ids []int64) (map[int64]Posts, error) {
	if len(ids) == 0 {
		return nil, nil
	}

	tbl := table.Posts
	stmt := tbl.
		SELECT(tbl.AllColumns).
		WHERE(
			tbl.ID.IN(lo.Map(ids, func(id int64, _ int) Expression { return Int64(id) })...),
		)

	m.log().Infof("sql: %s", stmt.DebugSql())

	var posts []Posts = make([]Posts, 0)
	err := stmt.QueryContext(ctx, db, &posts)
	if err != nil {
		m.log().Errorf("error querying posts: %v", err)
		return nil, err
	}

	return lo.SliceToMap(posts, func(item Posts) (int64, Posts) {
		return item.ID, item
	}), nil
}

// GetMediaByIds
func (m *Posts) GetMediaByIds(ctx context.Context, ids []int64) ([]Medias, error) {
	if len(ids) == 0 {
		return nil, nil
	}

	tbl := table.Medias
	stmt := tbl.
		SELECT(tbl.AllColumns).
		WHERE(
			tbl.ID.IN(lo.Map(ids, func(id int64, _ int) Expression { return Int64(id) })...),
		)

	m.log().Infof("sql: %s", stmt.DebugSql())

	var medias []Medias

	if err := stmt.QueryContext(ctx, db, &medias); err != nil {
		m.log().Errorf("error querying media: %v", err)
		return nil, err
	}

	return medias, nil
}

// Count
func (m *Posts) Count(ctx context.Context, cond BoolExpression) (int64, error) {
	tbl := table.Posts
	stmt := tbl.
		SELECT(COUNT(tbl.ID).AS("count")).
		WHERE(cond)

	var count struct {
		Count int64
	}
	if err := stmt.QueryContext(ctx, db, &count); err != nil {
		m.log().Errorf("error counting posts: %v", err)
		return 0, err
	}

	return count.Count, nil
}