package widget

import (
	"context"
	"donat-widget/internal/model"
	"donat-widget/internal/model/sql"
	"errors"
	"github.com/georgysavva/scany/v2/pgxscan"
	"github.com/jackc/pgx/v5"
	"log/slog"
)

func New(
	db model.Db,
	storage model.Storage,
) *RepoWidget {
	return &RepoWidget{
		db:      db,
		storage: storage,
	}
}

type RepoWidget struct {
	db      model.Db
	storage model.Storage
}

func (widgetRepo *RepoWidget) CreateWidget(
	ctx context.Context,
	streamerID model.StreamerID,
	templateID model.TemplateID,
	duration model.Duration,
	minAmount model.DonatAmount,
) (model.WidgetID, error) {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
		"template_id": templateID,
		"duration":    duration,
		"min_amount":  minAmount,
	}
	_, err := widgetRepo.db.Query(ctx, sql.CreateWidget, args)
	if err != nil {
		slog.Error("widgetRepo.db.Query: " + err.Error())
		return 0, err
	}

	widgetID := 9
	return model.WidgetID(widgetID), nil
}

func (widgetRepo *RepoWidget) GetWidget(
	ctx context.Context,
	widgetID model.WidgetID,
) (*model.Widget, error) {
	args := pgx.NamedArgs{
		"id": widgetID,
	}
	rows, err := widgetRepo.db.Query(ctx, sql.GetWidget, args)
	if err != nil {
		slog.Error("widgetRepo.db.Query: " + err.Error())
		return nil, err
	}

	var widgets []*model.Widget
	err = pgxscan.ScanAll(&widgets, rows)
	if err != nil {
		slog.Error(err.Error())
		return nil, err
	}

	if len(widgets) == 0 {
		slog.Error("Widget not found")
		return nil, errors.New("widget not found")
	}

	widget := widgets[0]
	widget.NormalizeUrl()

	return widget, nil
}

func (widgetRepo *RepoWidget) GetAllWidget(
	ctx context.Context,
	streamerID model.StreamerID,
) ([]*model.Widget, error) {
	args := pgx.NamedArgs{
		"streamer_id": streamerID,
	}
	rows, err := widgetRepo.db.Query(ctx, sql.GetAllWidget, args)
	if err != nil {
		slog.Error("widgetRepo.db.Query: " + err.Error())
		return nil, err
	}

	var widgets []*model.Widget
	err = pgxscan.ScanAll(&widgets, rows)
	if err != nil {
		slog.Error(err.Error())
		return nil, err
	}

	return widgets, nil
}

func (widgetRepo *RepoWidget) DeleteWidget(
	ctx context.Context,
	widgetID model.WidgetID,
) error {
	panic("implement me")
}

func (widgetRepo *RepoWidget) UpdateDuration(
	ctx context.Context,
	widgetID model.WidgetID,
	duration model.Duration,
) error {
	args := pgx.NamedArgs{
		"id":       widgetID,
		"duration": duration,
	}
	_, err := widgetRepo.db.Query(ctx, sql.UpdateDuration, args)
	if err != nil {
		slog.Error("widgetRepo.db.Query: " + err.Error())
		return err
	}

	return nil
}

func (widgetRepo *RepoWidget) SetMediaFile(
	file model.UploadFile,
	filename string,
	size int64,
	collection string,
) (model.FileID, error) {
	fileData, err := widgetRepo.storage.Upload(file, filename, size, collection)
	if err != nil {
		slog.Error("repoMedia.storage.Upload: " + err.Error())
		return "", err
	}

	return model.FileID(fileData.FileID), nil
}

func (widgetRepo *RepoWidget) GetMediaFile(
	fileID model.FileID,
) (model.DownloadFile, error) {
	file, err := widgetRepo.storage.Download(fileID)
	if err != nil {
		slog.Error("repoMedia.storage.Download: " + err.Error())
		return nil, err
	}

	return file, err
}

func (widgetRepo *RepoWidget) UpdateMediaFile(
	ctx context.Context,
	widgetID model.WidgetID,
	file model.UploadFile,
	fileID model.FileID,
	filename string,
	size int64,
	collection string,
	mediaType model.MediaType,
) error {
	err := widgetRepo.storage.Update(file, fileID, filename, size, collection)
	if err != nil {
		slog.Error("repoMedia.storage.Update: " + err.Error())
		return err
	}

	mediaType = mediaType + "_url"
	args := pgx.NamedArgs{
		string(mediaType): model.MediaUrl(fileID),
		"id":              widgetID,
	}
	_, err = widgetRepo.db.Query(ctx, sql.UpdateMediaUrl(mediaType), args)
	if err != nil {
		slog.Error("repoMedia.db.Query: " + err.Error())
		return err
	}

	return nil
}

func (widgetRepo *RepoWidget) SetMediaUrl(
	ctx context.Context,
	widgetID model.WidgetID,
	mediaUrl model.MediaUrl,
	mediaType model.MediaType,
) error {
	mediaType = mediaType + "_url"

	args := pgx.NamedArgs{
		string(mediaType): mediaUrl,
		"id":              widgetID,
	}
	_, err := widgetRepo.db.Query(ctx, sql.UpdateMediaUrl(mediaType), args)
	if err != nil {
		slog.Error("repoMedia.db.Query: " + err.Error())
		return err
	}
	return nil
}

func (widgetRepo *RepoWidget) GetMediaUrl(
	ctx context.Context,
	widgetID model.WidgetID,
	mediaType model.MediaType,
) (model.MediaUrl, error) {
	mediaType = mediaType + "_url"
	args := pgx.NamedArgs{
		"id": widgetID,
	}
	rows, err := widgetRepo.db.Query(ctx, sql.GetMediaUrl(mediaType), args)
	if err != nil {
		slog.Error("repoMedia.db.Query: " + err.Error())
		return "", err
	}

	var widgets []*model.Widget
	err = pgxscan.ScanAll(&widgets, rows)
	if err != nil {
		slog.Error("repoMedia.pgxscan.ScanAll: " + err.Error())
		return "", err
	}

	if len(widgets) == 0 {
		slog.Error("Widget does not exist")
		return "", errors.New("widget does not exist")
	}

	widget := widgets[0]
	mediaUrl := widget.GetMediaUrl(mediaType)

	return mediaUrl, nil
}