package storage

import (
	"context"
	"fmt"
	cmap "github.com/orcaman/concurrent-map/v2"
	"github.com/uptrace/bun"
	"relynolli-server/internal"
	"relynolli-server/models/catalog"
	filters2 "relynolli-server/models/filters"
	"slices"
)

type StorageCatalog interface {
	GetCatalogItem(ctx context.Context, id *int64) (*catalog.DBCatalog, error)
	GetCatalogItems(ctx context.Context, filters cmap.ConcurrentMap[string, []string], limit int, offset int) (int, *[]catalog.DBCatalog, error)
	GetFilters(ctx context.Context) (int, *[]filters2.DBFilter, error)
}

func NewStorageCatalog() StorageCatalog {
	if instance == nil {
		instance = &storage{
			db: internal.InitDatabase().GetInstance(),
		}
	}
	return instance
}

func (s *storage) GetCatalogItem(ctx context.Context, id *int64) (*catalog.DBCatalog, error) {
	db := internal.InitDatabase().GetInstance()
	model := new(catalog.DBCatalog)

	err := db.NewSelect().Model(model).Where("id = ?", id).Where("available_quantity > 0").Where("is_available = 1").Scan(ctx)

	if err != nil {
		return nil, err
	}
	return model, nil
}

func buildFilterGroup(ctx context.Context, q *bun.SelectQuery, filters *cmap.ConcurrentMap[string, []string]) *bun.SelectQuery {
	db := internal.InitDatabase().GetInstance()
	availableFilters := new([]filters2.DBFilter)

	//Get filters
	db.NewSelect().Model(availableFilters).Where("code in (?)", bun.In(filters.Keys())).Scan(ctx)

	for _, filter := range filters.Keys() {
		if !slices.ContainsFunc(*availableFilters, func(elem filters2.DBFilter) bool {
			return elem.Code == filter
		}) {
			continue
		}
		q = q.WhereGroup(" AND ", func(query *bun.SelectQuery) *bun.SelectQuery {
			values, _ := filters.Get(filter)
			for _, val := range values {
				query = q.WhereOr(fmt.Sprintf("properties->>'$.%s' = ?", filter), val)
			}
			return query
		})
	}
	return q

}

func (s *storage) GetCatalogItems(ctx context.Context, filters cmap.ConcurrentMap[string, []string], limit int, offset int) (int, *[]catalog.DBCatalog, error) {
	db := internal.InitDatabase().GetInstance()
	model := new([]catalog.DBCatalog)
	filterQuery := db.NewSelect().Model(model).Where("is_active = 1").Where("available_quantity > 0")
	count, _ := buildFilterGroup(ctx, filterQuery, &filters).Limit(limit).Offset(offset).ScanAndCount(ctx)

	return count, model, nil
}

func (s *storage) GetFilters(ctx context.Context) (int, *[]filters2.DBFilter, error) {
	models := new([]filters2.DBFilter)
	db := internal.InitDatabase().GetInstance()
	count, err := db.NewSelect().Model(models).ScanAndCount(ctx)
	if err != nil {
		return 0, nil, err
	}
	return count, models, nil
}