package widget

import (
	"context"
	"donat-widget/internal/model"
	"log/slog"
)

func New(
	widgetRepo model.WidgetRepo,
	donatRepo model.DonatRepo,
) *ServiceWidget {
	return &ServiceWidget{
		widgetRepo: widgetRepo,
		donatRepo:  donatRepo,
	}
}

type ServiceWidget struct {
	widgetRepo model.WidgetRepo
	donatRepo  model.DonatRepo
}

func (widgetService *ServiceWidget) CreateWidget(
	ctx context.Context,
	streamerID model.StreamerID,
	templateID model.TemplateID,
	duration model.Duration,
	minAmount model.DonatAmount,
) (model.WidgetID, error) {
	widgetID, err := widgetService.widgetRepo.CreateWidget(
		ctx,
		streamerID,
		templateID,
		duration,
		minAmount,
	)
	if err != nil {
		slog.Error("widgetService.widgetRepo.CreateWidget: " + err.Error())
		return 0, err
	}
	return widgetID, nil
}

func (widgetService *ServiceWidget) DeleteWidget(
	ctx context.Context,
	widgetID model.WidgetID,
) error {
	err := widgetService.widgetRepo.DeleteWidget(ctx, widgetID)
	if err != nil {
		slog.Error("widgetService.widgetRepo.DeleteWidget: " + err.Error())
		return err
	}
	return nil
}

func (widgetService *ServiceWidget) UpdateDuration(
	ctx context.Context,
	widgetID model.WidgetID,
	duration model.Duration,
) error {
	err := widgetService.widgetRepo.UpdateDuration(ctx, widgetID, duration)
	if err != nil {
		slog.Error("widgetService.widgetRepo.UpdateDuration: " + err.Error())
		return err
	}

	return nil
}

func (widgetService *ServiceWidget) GetWidgetHTML(
	ctx context.Context,
	widgetID model.WidgetID,
) (model.WidgetHTML, error) {
	var widgetHTML model.WidgetHTML

	widget, err := widgetService.widgetRepo.GetWidget(ctx, widgetID)
	if err != nil {
		slog.Error("widgetService.widgetRepo.GetWidget: " + err.Error())
		return widgetHTML, err
	}

	if widget.TemplateID == 1 {
		widgetHTML = model.GetTemplate1(
			widgetID,
			widget.BackgroundUrl,
		)
	}
	return widgetHTML, nil
}

func (widgetService *ServiceWidget) GetWidgetInfo(
	ctx context.Context,
	widgetID model.WidgetID,
) (*model.DonatAndWidget, error) {

	widget, err := widgetService.widgetRepo.GetWidget(ctx, widgetID)
	if err != nil {
		slog.Error("widgetService.widgetRepo.GetWidget: " + err.Error())
		return nil, err
	}

	donats, err := widgetService.donatRepo.GetDonat(ctx, widgetID)
	if err != nil {
		slog.Error("widgetService.donatRepo.GetDonat: " + err.Error())
		return nil, err
	}

	var donatAndWidget model.DonatAndWidget
	if len(donats) == 0 {
		donatAndWidget = model.DonatAndWidget{
			Display: false,
		}
	} else {
		donatAndWidget = model.DonatAndWidget{
			Widget:  widget,
			Donat:   donats[0],
			Display: true,
		}
	}

	return &donatAndWidget, nil
}

func (widgetService *ServiceWidget) SetMediaFile(
	ctx context.Context,
	mediaType model.MediaType,
	widgetID model.WidgetID,
	file model.UploadFile,
	filename string,
	size int64,
	collection string,
) error {
	fileID, err := widgetService.widgetRepo.SetMediaFile(
		file,
		filename,
		size,
		collection,
	)
	if err != nil {
		slog.Error("mediaService.mediaRepo.SetMediaFile: " + err.Error())
		return err
	}

	err = widgetService.SetMediaUrl(
		ctx,
		mediaType,
		widgetID,
		model.MediaUrl(fileID),
	)
	if err != nil {
		slog.Error("mediaService.SetMediaUrl: " + err.Error())
		return err
	}

	return nil
}

func (widgetService *ServiceWidget) GetMediaFile(
	ctx context.Context,
	widgetID model.WidgetID,
	mediaType model.MediaType,
) (model.DownloadFile, error) {
	fileID, err := widgetService.widgetRepo.GetMediaUrl(
		ctx,
		widgetID,
		mediaType,
	)
	if err != nil {
		slog.Error("mediaService.mediaRepo.GetMediaUrl: " + err.Error())
		return nil, err
	}

	file, err := widgetService.widgetRepo.GetMediaFile(
		model.FileID(fileID),
	)
	if err != nil {
		slog.Error("mediaService.mediaRepo.GetMediaFile: " + err.Error())
		return nil, err
	}
	return file, nil
}

func (widgetService *ServiceWidget) UpdateMediaFile(
	ctx context.Context,
	widgetID model.WidgetID,
	mediaType model.MediaType,
	file model.UploadFile,
	filename string,
	size int64,
	collection string,
) error {
	fileID, err := widgetService.widgetRepo.GetMediaUrl(
		ctx,
		widgetID,
		mediaType,
	)
	if err != nil {
		slog.Error("mediaService.mediaRepo.GetMediaUrl: " + err.Error())
		return err
	}

	err = widgetService.widgetRepo.UpdateMediaFile(
		ctx,
		widgetID,
		file,
		model.FileID(fileID),
		filename,
		size,
		collection,
		mediaType,
	)
	if err != nil {
		slog.Error("mediaService.mediaRepo.UpdateMediaFile: " + err.Error())
		return err
	}
	return nil
}

func (widgetService *ServiceWidget) SetMediaUrl(
	ctx context.Context,
	mediaType model.MediaType,
	widgetID model.WidgetID,
	mediaUrl model.MediaUrl,
) error {
	err := widgetService.widgetRepo.SetMediaUrl(
		ctx,
		widgetID,
		mediaUrl,
		mediaType,
	)
	if err != nil {
		slog.Error("mediaService.mediaRepo.SetMediaUrl: " + err.Error())
		return err
	}
	return nil
}