models.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"
	"time"
)

// Activity ID constants for common Allow2 activities.
const (
	// ActivityInternet is the Internet activity ID.
	ActivityInternet = 1
	// ActivityGaming is the Gaming activity ID.
	ActivityGaming = 3
	// ActivitySocial is the Social Media activity ID.
	ActivitySocial = 6
	// ActivityScreenTime is the Screen Time activity ID (master device-level switch).
	ActivityScreenTime = 8
)

// Activity represents the permission state of a single activity from a check result.
type Activity struct {
	ID               int    `json:"id"`
	Name             string `json:"name"`
	Allowed          bool   `json:"allowed"`
	Remaining        int    `json:"remaining"`
	Banned           bool   `json:"banned"`
	TimeBlockAllowed bool   `json:"timeBlockAllowed"`
}

// ActivityFromMap creates an Activity from a map (API response data).
func ActivityFromMap(data map[string]interface{}) *Activity {
	a := &Activity{
		TimeBlockAllowed: true, // default
	}

	if v, ok := data["id"]; ok {
		a.ID = toInt(v)
	}
	if v, ok := data["activity"]; ok {
		a.Name = fmt.Sprintf("%v", v)
	} else if v, ok := data["name"]; ok {
		a.Name = fmt.Sprintf("%v", v)
	}
	if v, ok := data["allowed"]; ok {
		a.Allowed = toBool(v)
	}
	if v, ok := data["remaining"]; ok {
		a.Remaining = toInt(v)
	}
	if v, ok := data["banned"]; ok {
		a.Banned = toBool(v)
	}
	if v, ok := data["timeblock"]; ok {
		a.TimeBlockAllowed = toBool(v)
	} else if v, ok := data["timeBlockAllowed"]; ok {
		a.TimeBlockAllowed = toBool(v)
	}

	return a
}

// DayType represents a day type in the Allow2 system (e.g., School Day, Weekend, Holiday).
type DayType struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

// DayTypeFromMap creates a DayType from a map.
func DayTypeFromMap(data map[string]interface{}) *DayType {
	d := &DayType{}
	if v, ok := data["id"]; ok {
		d.ID = toInt(v)
	}
	if v, ok := data["name"]; ok {
		d.Name = fmt.Sprintf("%v", v)
	}
	return d
}

// CheckResult is the result of a permission check from the Allow2 Service API.
type CheckResult struct {
	Allowed         bool        `json:"allowed"`
	Activities      []*Activity `json:"activities"`
	TodayDayType    *DayType    `json:"todayDayType,omitempty"`
	TomorrowDayType *DayType    `json:"tomorrowDayType,omitempty"`
	Raw             map[string]interface{}
}

// GetActivity returns a specific activity by ID, or nil if not present.
func (r *CheckResult) GetActivity(activityID int) *Activity {
	for _, a := range r.Activities {
		if a.ID == activityID {
			return a
		}
	}
	return nil
}

// IsActivityAllowed checks whether a specific activity is allowed.
func (r *CheckResult) IsActivityAllowed(activityID int) bool {
	a := r.GetActivity(activityID)
	return a != nil && a.Allowed
}

// GetRemainingSeconds returns the remaining seconds for a specific activity.
func (r *CheckResult) GetRemainingSeconds(activityID int) int {
	a := r.GetActivity(activityID)
	if a != nil {
		return a.Remaining
	}
	return 0
}

// CheckResultFromAPIResponse builds a CheckResult from the raw API response.
func CheckResultFromAPIResponse(response map[string]interface{}) *CheckResult {
	var activities []*Activity
	if rawActs, ok := response["activities"]; ok {
		if actSlice, ok := rawActs.([]interface{}); ok {
			for _, item := range actSlice {
				if actMap, ok := item.(map[string]interface{}); ok {
					activities = append(activities, ActivityFromMap(actMap))
				}
			}
		}
	}

	var todayDayType *DayType
	if dt, ok := response["dayType"].(map[string]interface{}); ok {
		todayDayType = DayTypeFromMap(dt)
	} else if dt, ok := response["today"].(map[string]interface{}); ok {
		todayDayType = DayTypeFromMap(dt)
	}

	var tomorrowDayType *DayType
	if dt, ok := response["tomorrowDayType"].(map[string]interface{}); ok {
		tomorrowDayType = DayTypeFromMap(dt)
	} else if dt, ok := response["tomorrow"].(map[string]interface{}); ok {
		tomorrowDayType = DayTypeFromMap(dt)
	}

	// Global "allowed" is true only if ALL activities are allowed
	allowed := true
	for _, act := range activities {
		if !act.Allowed {
			allowed = false
			break
		}
	}

	// Override with explicit server value if present
	if v, ok := response["allowed"]; ok {
		allowed = toBool(v)
	}

	return &CheckResult{
		Allowed:         allowed,
		Activities:      activities,
		TodayDayType:    todayDayType,
		TomorrowDayType: tomorrowDayType,
		Raw:             response,
	}
}

// OAuthTokens is a value object representing an OAuth2 token set.
type OAuthTokens struct {
	AccessToken  string `json:"access_token"`
	RefreshToken string `json:"refresh_token"`
	ExpiresAt    int64  `json:"expires_at"`
}

// IsExpired checks whether the access token has expired or is about to expire.
func (t *OAuthTokens) IsExpired(bufferSeconds int) bool {
	return time.Now().Unix() >= (t.ExpiresAt - int64(bufferSeconds))
}

// ToMap serializes the tokens to a map for storage.
func (t *OAuthTokens) ToMap() map[string]interface{} {
	return map[string]interface{}{
		"access_token":  t.AccessToken,
		"refresh_token": t.RefreshToken,
		"expires_at":    t.ExpiresAt,
	}
}

// OAuthTokensFromAPIResponse creates OAuthTokens from an API token response.
func OAuthTokensFromAPIResponse(response map[string]interface{}) *OAuthTokens {
	accessToken := ""
	if v, ok := response["access_token"].(string); ok {
		accessToken = v
	}

	refreshToken := ""
	if v, ok := response["refresh_token"].(string); ok {
		refreshToken = v
	}

	var expiresIn int64
	if v, ok := response["expires_in"]; ok {
		expiresIn = toInt64(v)
	}

	return &OAuthTokens{
		AccessToken:  accessToken,
		RefreshToken: refreshToken,
		ExpiresAt:    time.Now().Unix() + expiresIn,
	}
}

// OAuthTokensFromMap reconstitutes OAuthTokens from a stored map.
func OAuthTokensFromMap(data map[string]interface{}) *OAuthTokens {
	t := &OAuthTokens{}
	if v, ok := data["access_token"].(string); ok {
		t.AccessToken = v
	}
	if v, ok := data["refresh_token"].(string); ok {
		t.RefreshToken = v
	}
	if v, ok := data["expires_at"]; ok {
		t.ExpiresAt = toInt64(v)
	}
	return t
}

// RequestResult is the result of creating a request (more time, day type change, or ban lift).
type RequestResult struct {
	RequestID    string `json:"requestId"`
	StatusSecret string `json:"statusSecret"`
	Status       string `json:"status"`
}

// IsPending returns true if the request is still pending.
func (r *RequestResult) IsPending() bool {
	return r.Status == "pending"
}

// IsApproved returns true if the request was approved.
func (r *RequestResult) IsApproved() bool {
	return r.Status == "approved"
}

// IsDenied returns true if the request was denied.
func (r *RequestResult) IsDenied() bool {
	return r.Status == "denied"
}

// RequestResultFromAPIResponse creates a RequestResult from API response data.
func RequestResultFromAPIResponse(response map[string]interface{}) *RequestResult {
	r := &RequestResult{Status: "pending"}

	if v, ok := response["requestId"]; ok {
		r.RequestID = fmt.Sprintf("%v", v)
	}
	if v, ok := response["statusSecret"]; ok {
		r.StatusSecret = fmt.Sprintf("%v", v)
	}
	if v, ok := response["status"].(string); ok {
		r.Status = v
	}

	return r
}

// VoiceCodePair is a challenge-response pair for offline voice code approval.
type VoiceCodePair struct {
	Challenge        string `json:"challenge"`
	ExpectedResponse string `json:"expectedResponse"`
}

// toInt converts an interface{} to int.
func toInt(v interface{}) int {
	switch val := v.(type) {
	case int:
		return val
	case int64:
		return int(val)
	case float64:
		return int(val)
	case string:
		// ignore error, return 0
		return 0
	default:
		return 0
	}
}

// toInt64 converts an interface{} to int64.
func toInt64(v interface{}) int64 {
	switch val := v.(type) {
	case int:
		return int64(val)
	case int64:
		return val
	case float64:
		return int64(val)
	case string:
		return 0
	default:
		return 0
	}
}