package steamreq

import (
	"context"
	"log/slog"
	"os"
	"steam_analyzer/internal/domain"
	"steam_analyzer/internal/utils/slogutils"
	"strconv"
	"time"
)

type IRequester interface {
	GetItem(query string, itemType string) ([]SteamMarketItem, error)
}

type ItemService interface {
	AddItemWithHistory(ctx context.Context, item domain.SteamItem) error
}

type SteamReqWorker struct {
	logger      *slog.Logger
	requester   IRequester
	itemService ItemService
	reqPer      time.Duration
}

func NewSteamWorker(logger *slog.Logger, requester IRequester, itemService ItemService, reqPer time.Duration) *SteamReqWorker {
	return &SteamReqWorker{
		logger:      logger,
		requester:   requester,
		itemService: itemService,
		reqPer:      reqPer,
	}
}

type SteamItems struct {
	Query    string
	ItemType string
}

func (w SteamReqWorker) Start(ctx context.Context, items []SteamItems) {
	for {
		for _, item := range items {
			items, err := w.requester.GetItem(item.Query, item.ItemType)
			if err != nil {
				w.logger.Error("Error while request item from steam", slogutils.Error(err))

				os.Exit(1)
			}
			w.logger.Info("Succesfully get items", slog.String("items count is", strconv.Itoa(len(items))))

			domainItems := CreateItemsFromRequest(items)
			for _, domainItem := range domainItems {
				err := w.itemService.AddItemWithHistory(ctx, domainItem)
				if err != nil {
					w.logger.Error("Error while adding item with history", slogutils.Error(err))
				}
			}
		}

		time.Sleep(w.reqPer)
	}
}

func CreateItemsFromRequest(smi []SteamMarketItem) []domain.SteamItem {
	steamItem := make([]domain.SteamItem, 0, len(smi))

	for _, item := range smi {
		steamItem = append(steamItem, domain.SteamItem{
			Name:    item.Name,
			ClassID: item.AssetDescription.Classid,
			GameID:  item.AssetDescription.Appid,
			Price:   item.SellPrice,
			Count:   item.SellListings,
		})
	}

	return steamItem
}