package models

import (
	"context"
	"errors"

	"quyun/app/requests"
	"quyun/database/fields"
	"quyun/database/schemas/public/model"
	"quyun/database/schemas/public/table"

	. "github.com/go-jet/jet/v2/postgres"
	"github.com/go-jet/jet/v2/qrm"
	"github.com/sirupsen/logrus"
)

// @provider
type postsModel struct {
	log *logrus.Entry `inject:"false"`
}

func (m *postsModel) Prepare() error {
	m.log = logrus.WithField("model", "postsModel")
	return nil
}

// BuildConditionWithKey
func (m *postsModel) BuildConditionWithKey(key *string) BoolExpression {
	tbl := table.Posts

	cond := tbl.DeletedAt.IS_NULL().AND(
		tbl.Status.EQ(Int32(int32(fields.PostStatusPublished))),
	)

	if key == nil || *key == "" {
		return cond
	}

	cond = tbl.Title.LIKE(String("%" + *key + "%")).
		OR(
			tbl.Content.LIKE(String("%" + *key + "%")),
		).
		OR(
			tbl.Description.LIKE(String("%" + *key + "%")),
		)

	return cond
}

// GetByID
func (m *postsModel) GetByID(ctx context.Context, id int64) (*model.Posts, error) {
	tbl := table.Posts
	stmt := tbl.
		SELECT(tbl.AllColumns).
		WHERE(
			tbl.ID.EQ(Int64(id)).AND(
				tbl.DeletedAt.IS_NULL(),
			).AND(
				tbl.Status.EQ(Int32(int32(fields.PostStatusPublished))),
			),
		)
	m.log.Infof("sql: %s", stmt.DebugSql())

	var post model.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 *postsModel) Create(ctx context.Context, model *model.Posts) error {
	tbl := table.Posts
	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(model)
	m.log.Infof("sql: %s", stmt.DebugSql())

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

// Update
func (m *postsModel) Update(ctx context.Context, id int64, model *model.Posts) error {
	tbl := table.Posts
	stmt := tbl.UPDATE(tbl.MutableColumns).SET(model).WHERE(tbl.ID.EQ(Int64(id)))
	m.log.Infof("sql: %s", stmt.DebugSql())

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

// countByCond
func (m *postsModel) 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 *postsModel) List(ctx context.Context, pagination *requests.Pagination, cond BoolExpression) (*requests.Pager, error) {
	limit := pagination.Limit
	offset := pagination.Offset()

	tbl := table.Posts
	stmt := tbl.
		SELECT(tbl.AllColumns).
		WHERE(cond).
		ORDER_BY(tbl.ID.DESC()).
		LIMIT(limit).
		OFFSET(offset)
	m.log.Infof("sql: %s", stmt.DebugSql())

	var posts []model.Posts
	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, cond)
	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
}

func (m *postsModel) IsUserBought(ctx context.Context, userId, postId int64) (bool, error) {
	tbl := table.UserPosts
	stmt := tbl.
		SELECT(tbl.ID).
		WHERE(
			tbl.UserID.EQ(Int64(userId)).AND(
				tbl.PostID.EQ(Int64(postId)),
			),
		)
	m.log.Infof("sql: %s", stmt.DebugSql())

	var userPost model.UserPosts
	err := stmt.QueryContext(ctx, db, &userPost)
	if err != nil {
		if errors.Is(err, qrm.ErrNoRows) {
			return false, nil
		}

		m.log.Errorf("error querying user post item: %v", err)
		return false, err
	}

	return userPost.ID > 0, nil
}

func (m *postsModel) Buy(ctx context.Context, userId, postId int64) error {
	tbl := table.UserPosts

	post, err := m.GetByID(ctx, postId)
	if err != nil {
		m.log.Errorf("error getting post by ID: %v", err)
		return err
	}

	user, err := Users.GetByID(ctx, userId)
	if err != nil {
		m.log.Errorf("error getting user by ID: %v", err)
		return err
	}

	record := model.UserPosts{
		UserID: user.ID,
		PostID: post.ID,
		Price:  post.Price * int64(post.Discount) / 100,
	}
	stmt := tbl.INSERT(tbl.MutableColumns).MODEL(record)
	m.log.Infof("sql: %s", stmt.DebugSql())

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