request.go

// Copyright 2017-2026 Allow2 Pty Ltd. All rights reserved.
// Use of this source code is governed by the Allow2 API and SDK Licence.

package allow2service

import (
	"fmt"
	"net/url"
)

// requestManager manages child requests (more time, day type change, ban lift)
// via the Allow2 Service API.
type requestManager struct {
	httpClient HTTPClient
	apiHost    string
}

// RequestMoreTime requests more time for an activity.
func (m *requestManager) RequestMoreTime(accessToken, userID string, activityID, minutes int, message string) (*RequestResult, error) {
	return m.createRequest(accessToken, userID, map[string]interface{}{
		"type":       RequestTypeMoreTime.Value(),
		"activityId": activityID,
		"minutes":    minutes,
		"message":    message,
	})
}

// RequestDayTypeChange requests a day type change.
func (m *requestManager) RequestDayTypeChange(accessToken, userID string, dayTypeID int, message string) (*RequestResult, error) {
	return m.createRequest(accessToken, userID, map[string]interface{}{
		"type":      RequestTypeDayTypeChange.Value(),
		"dayTypeId": dayTypeID,
		"message":   message,
	})
}

// RequestBanLift requests lifting a ban on an activity.
func (m *requestManager) RequestBanLift(accessToken, userID string, activityID int, message string) (*RequestResult, error) {
	return m.createRequest(accessToken, userID, map[string]interface{}{
		"type":       RequestTypeBanLift.Value(),
		"activityId": activityID,
		"message":    message,
	})
}

// GetRequestStatus polls the status of an existing request.
// Returns "pending", "approved", or "denied".
func (m *requestManager) GetRequestStatus(requestID, statusSecret string) (string, error) {
	response, err := m.httpClient.Get(
		m.apiHost+"/request/"+url.PathEscape(requestID)+"/status",
		map[string]string{"X-Status-Secret": statusSecret},
	)
	if err != nil {
		return "", &ApiError{
			Allow2Error: Allow2Error{Message: fmt.Sprintf("Failed to get request status: %v", err)},
		}
	}

	if !response.IsSuccess() {
		body := response.JSON()
		return "", &ApiError{
			Allow2Error:    Allow2Error{Message: fmt.Sprintf("Failed to get request status: HTTP %d", response.StatusCode)},
			HTTPStatusCode: response.StatusCode,
			ResponseBody:   body,
		}
	}

	data := response.JSON()
	if data == nil {
		return "pending", nil
	}

	if status, ok := data["status"].(string); ok {
		return status, nil
	}

	return "pending", nil
}

// GetTempToken obtains a temporary request token from /request/tempToken.
func (m *requestManager) GetTempToken(accessToken, nonce string) (map[string]interface{}, error) {
	payload := map[string]interface{}{
		"access_token": accessToken,
	}

	if nonce != "" {
		payload["nonce"] = nonce
	}

	response, err := m.httpClient.Post(
		m.apiHost+"/request/tempToken",
		payload,
		nil,
	)
	if err != nil {
		return nil, &ApiError{
			Allow2Error: Allow2Error{Message: fmt.Sprintf("Failed to obtain request token: %v", err)},
		}
	}

	if response.IsUnauthorized() {
		return nil, &UnpairedError{
			Allow2Error: Allow2Error{Message: "Service account is no longer linked. Re-pairing required."},
			UserID:      "",
		}
	}

	if !response.IsSuccess() {
		body := response.JSON()
		return nil, &ApiError{
			Allow2Error:    Allow2Error{Message: fmt.Sprintf("Failed to obtain request token: HTTP %d", response.StatusCode)},
			HTTPStatusCode: response.StatusCode,
			ResponseBody:   body,
		}
	}

	data := response.JSON()
	if data == nil {
		return nil, &ApiError{
			Allow2Error:    Allow2Error{Message: "Request token endpoint returned invalid JSON"},
			HTTPStatusCode: response.StatusCode,
		}
	}

	return data, nil
}

// createRequest obtains a temporary token then creates the request.
func (m *requestManager) createRequest(accessToken, userID string, payload map[string]interface{}) (*RequestResult, error) {
	// Step 1: Get a temporary request token
	tempData, err := m.GetTempToken(accessToken, "")
	if err != nil {
		return nil, err
	}

	// Extract temp token from response (API may use different key names)
	var tempToken string
	for _, key := range []string{"token", "requestToken", "tempToken"} {
		if v, ok := tempData[key].(string); ok && v != "" {
			tempToken = v
			break
		}
	}

	if tempToken == "" {
		return nil, &ApiError{
			Allow2Error:    Allow2Error{Message: "Temporary request token not found in API response"},
			HTTPStatusCode: 200,
			ResponseBody:   tempData,
		}
	}

	// Step 2: Create the request
	payload["requestToken"] = tempToken
	payload["access_token"] = accessToken

	response, err := m.httpClient.Post(
		m.apiHost+"/request/createRequest",
		payload,
		nil,
	)
	if err != nil {
		return nil, &ApiError{
			Allow2Error: Allow2Error{Message: fmt.Sprintf("Failed to create request: %v", err)},
		}
	}

	if response.IsUnauthorized() {
		return nil, &UnpairedError{
			Allow2Error: Allow2Error{Message: "Service account is no longer linked. Re-pairing required."},
			UserID:      userID,
		}
	}

	if !response.IsSuccess() {
		body := response.JSON()
		return nil, &ApiError{
			Allow2Error:    Allow2Error{Message: fmt.Sprintf("Failed to create request: HTTP %d", response.StatusCode)},
			HTTPStatusCode: response.StatusCode,
			ResponseBody:   body,
		}
	}

	data := response.JSON()
	if data == nil {
		return nil, &ApiError{
			Allow2Error:    Allow2Error{Message: "Create request returned invalid JSON"},
			HTTPStatusCode: response.StatusCode,
		}
	}

	return RequestResultFromAPIResponse(data), nil
}