package mjolnirClient

import (
	"cybertron/configs"
	"cybertron/pkg/log"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
)

type MjolnirClient struct {
	baseUrl string
	realmId string
}

type MjolnirError struct {
	Code    string      `json:"code,omitempty"`
	Message string      `json:"message,omitempty"`
	Params  interface{} `json:"params,omitempty"`
}

type MjolnirSessionResponse struct {
	SessionToken      string         `json:"sessionToken,omitempty"`
	ClientId          string         `json:"clientId,omitempty"`
	EmailId           string         `json:"emailId,omitempty"`
	AccountId         string         `json:"accountId,omitempty"`
	PhoneNumber       string         `json:"phoneNumber,omitempty"`
	PreferredUsername string         `json:"preferred_username,omitempty"`
	Roles             []string       `json:"roles,omitempty"`
	Groups            []string       `json:"groups,omitempty"`
	Permissions       []string       `json:"permissions,omitempty"`
	StatusCode        int            `json:"statusCode,omitempty"`
	Errors            []MjolnirError `json:"errors"`
}

func NewMjolnirClient(mjolnirConfig configs.MjolnirClientConfig) *MjolnirClient {
	return &MjolnirClient{
		baseUrl: mjolnirConfig.GetMjolnirBaseUrl(),
		realmId: mjolnirConfig.GetMjolnirRealmId(),
	}
}

var logger = log.Log.GetLog()
var client = http.Client{}

const (
	SessionUrl = "%s/session/%s"
)

func (m *MjolnirClient) GetSessionResponse(sessionToken string) (*MjolnirSessionResponse, error) {
	if sessionToken == "null" {
		return nil, errors.New("unauthorized request")
	}

	req, _ := http.NewRequest("GET", fmt.Sprintf(SessionUrl, m.baseUrl, m.realmId), nil)
	req.Header.Add("X-Session-Token", sessionToken)
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	defer resp.Body.Close()
	responseBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}

	var response MjolnirSessionResponse
	err = json.Unmarshal(responseBody, &response)
	if err != nil {
		return nil, err
	}

	return &response, nil
}