package db

import (
	"context"
	"database/sql"

	"github.com/pkg/errors"
	"github.com/uptrace/bun"
)

type listgetter[T any] struct {
	q     *bun.SelectQuery
	items *[]*T
}

type List[T any] struct {
	Items    []*T
	Total    int
	PageOpts PageOpts
}

type Filter struct {
	Field string
	Value any
}

type ListFilter struct {
	filters []Filter
}

func NewListFilter() *ListFilter {
	return &ListFilter{[]Filter{}}
}

func (f *ListFilter) Add(field string, value any) {
	f.filters = append(f.filters, Filter{field, value})
}

func GetList[T any](tx bun.Tx) *listgetter[T] {
	l := &listgetter[T]{
		items: new([]*T),
	}
	l.q = tx.NewSelect().
		Model(l.items)
	return l
}

func (l *listgetter[T]) Join(join string, args ...any) *listgetter[T] {
	l.q = l.q.Join(join, args...)
	return l
}

func (l *listgetter[T]) Where(query string, args ...any) *listgetter[T] {
	l.q = l.q.Where(query, args...)
	return l
}

func (l *listgetter[T]) Relation(name string, apply ...func(*bun.SelectQuery) *bun.SelectQuery) *listgetter[T] {
	l.q = l.q.Relation(name, apply...)
	return l
}

func (l *listgetter[T]) Filter(filters ...Filter) *listgetter[T] {
	for _, filter := range filters {
		l.q = l.q.Where("? = ?", bun.Ident(filter.Field), filter.Value)
	}
	return l
}

func (l *listgetter[T]) GetPaged(ctx context.Context, pageOpts, defaults *PageOpts) (*List[T], error) {
	if defaults == nil {
		return nil, errors.New("default pageopts is nil")
	}
	total, err := l.q.Count(ctx)
	if err != nil {
		return nil, errors.Wrap(err, "query.Count")
	}
	l.q, pageOpts = setPageOpts(l.q, pageOpts, defaults, total)
	err = l.q.Scan(ctx)
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.Wrap(err, "query.Scan")
	}
	list := &List[T]{
		Items:    *l.items,
		Total:    total,
		PageOpts: *pageOpts,
	}
	return list, nil
}

func (l *listgetter[T]) GetAll(ctx context.Context) ([]*T, error) {
	err := l.q.Scan(ctx)
	if err != nil && errors.Is(err, sql.ErrNoRows) {
		return nil, errors.Wrap(err, "query.Scan")
	}
	return *l.items, nil
}