package services

import (
	"context"
	"fmt"
	"git.dynamicdiscord.de/malobeo/portal/internal"
	"git.dynamicdiscord.de/malobeo/portal/openapi"
	"github.com/gin-gonic/gin"
	"os"
)

var (
	Users UserService = UserService{}
)

type UserService struct{}

// return jwt tokenstring on success
func (u *UserService) Login(username string, password string) (*openapi.Token, error) {
	//grantType := "grantType_example"       // string |  (optional)
	//scope := "scope_example"               // string |  (optional) (default to "")
	//clientId := "clientId_example"         // string |  (optional)
	//clientSecret := "clientSecret_example" // string |  (optional)

	fmt.Fprintf(os.Stdout, "Try login with username: %s, password: %s", username, password)

	apiClient := internal.GetApiClient(nil)
	resp, r, err := apiClient.TokenAPI.LoginForAccessTokenApiV1TokenPost(context.Background()).Username(username).Password(password).Execute()
	//configuration := openapi.NewConfiguration()
	//configuration.Host = "localhost:8000"
	//configuration.Scheme = "http"
	//apiClient := openapi.NewAPIClient(configuration)
	//resp, r, err := apiClient.TokenAPI.LoginForAccessTokenTokenPost(context.Background()).Username(username).Password(password).Execute()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `TokenAPI.LoginForAccessTokenTokenPost``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
		return nil, err
	}
	// response from `LoginForAccessTokenTokenPost`: Token
	fmt.Fprintf(os.Stdout, "Response from `TokenAPI.LoginForAccessTokenTokenPost`: %v\n", resp)
	return resp, nil
}

func (u *UserService) GetById(c *gin.Context, userId int32) (*openapi.UserResponse, error) {
	apiClient := internal.GetApiClient(c)
	resp, r, err := apiClient.UsersAPI.ReadUserApiV1UsersUserIdGet(context.Background(), userId).Execute()

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `UserApi.GetById``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
		return nil, err
	}
	// response from `LoginForAccessTokenTokenPost`: Token
	fmt.Fprintf(os.Stdout, "Response from `UserApi.GetById`: %v\n", resp)
	return resp, nil
}

func (u *UserService) GetAll(c *gin.Context) ([]openapi.UserResponse, error) {
	apiClient := internal.GetApiClient(c)
	resp, r, err := apiClient.UsersAPI.ReadUsersApiV1UsersGet(context.Background()).Execute()

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `UserApi.GetAll``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
		return nil, err
	}
	// response from `LoginForAccessTokenTokenPost`: Token
	fmt.Fprintf(os.Stdout, "Response from `UserApi.GetAll`: %v\n", resp)
	return resp, nil
}

func (u *UserService) GetByName(c *gin.Context, username string) (openapi.UserResponse, error) {
	users, err := u.GetAll(c)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `GetByName``: %v\n", err)
		return openapi.UserResponse{}, err
	}

	for _, user := range users {
		if user.Name == username {
			return user, nil
		}
	}

	return openapi.UserResponse{}, fmt.Errorf("Not found")
}

func (u *UserService) GetByAuthHeader(c *gin.Context) (openapi.UserResponse, error) {
	apiClient := internal.GetApiClient(c)
	resp, r, err := apiClient.UsersAPI.GetCurrentUserApiV1UsersCurrentGet(context.Background()).Execute()

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `UserApi.GetById``: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
		return openapi.UserResponse{}, err
	}
	// response from `LoginForAccessTokenTokenPost`: Token
	fmt.Fprintf(os.Stdout, "Response from `UserApi.GetById`: %v\n", resp)
	return *resp, nil
}