package widget

import (
	"context"
	"donat-widget/internal/model"
	"donat-widget/internal/model/api"
	"errors"
	"github.com/labstack/echo/v4"
	"log/slog"
	"net/http"
)

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

type ServiceWidget struct {
	widgetRepo model.WidgetRepo
	authClient model.AuthClient
}

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(err.Error())
		return 0, err
	}
	return widgetID, nil
}

func (widgetService *ServiceWidget) GetWidgetHTML(
	ctx context.Context,
	streamerID model.StreamerID,
) (model.WidgetHTML, error) {

	widgets, err := widgetService.widgetRepo.GetWidgetByStreamerID(ctx, streamerID)
	if err != nil {
		slog.Error(err.Error())
		return "", err
	}

	if len(widgets) == 0 {
		return "", errors.New("widget not found")
	}
	widget := widgets[0]

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

func (widgetService *ServiceWidget) GetWidgetByID(
	ctx context.Context,
	widgetID model.WidgetID,
) ([]*model.Widget, error) {

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

	return widget, 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(err.Error())
		return err
	}

	err = widgetService.SetMediaUrl(
		ctx,
		mediaType,
		widgetID,
		model.MediaUrl(fileID),
	)
	if err != nil {
		slog.Error(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(err.Error())
		return nil, err
	}

	file, err := widgetService.widgetRepo.GetMediaFile(
		model.FileID(fileID),
	)
	if err != nil {
		slog.Error(err.Error())
		return nil, err
	}
	return file, 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(err.Error())
		return err
	}
	return nil
}

func (widgetService *ServiceWidget) CheckToken(
	request echo.Context,
) (api.CheckTokenResponse, error) {
	accessToken := model.Token(request.Request().Header.Get("Authorization"))

	checkTokenResponse, err := widgetService.authClient.CheckToken(accessToken)
	if err != nil {
		slog.Error("Failed to check token", "error", err.Error())
		return api.CheckTokenResponse{}, echo.NewHTTPError(http.StatusInternalServerError, err.Error())
	}

	if checkTokenResponse.AccountID == 0 {
		slog.Error("Unauthorized account")
		return api.CheckTokenResponse{}, echo.NewHTTPError(http.StatusUnauthorized, "Unauthorized account")
	}

	if checkTokenResponse.AccountID == -1 {
		slog.Error("Expired token")
		return api.CheckTokenResponse{}, echo.NewHTTPError(http.StatusUnauthorized, "Expired token")
	}

	return checkTokenResponse, nil
}