nightsky.gno

  1// Package nightsky holds the shared types and single-telescope logic for the
  2// GnoNightSky telescope network.
  3//
  4// Note on panics: although this lives under p/, it is application-specific
  5// logic for the NightSky realms rather than a general-purpose reusable
  6// library. It deliberately panics on invalid input / failed preconditions
  7// (the assert-like style described in effective-gno) so the wrapping realms
  8// don't have to re-check every error. Callers that want softer handling
  9// should validate before calling.
 10package nightsky
 11
 12import (
 13	"time"
 14
 15	"gno.land/p/nt/avl/v0"
 16)
 17
 18// TelescopeConfig contains the settings and configuration for a telescope
 19type TelescopeConfig struct {
 20	Name       string    // Name of the telescope
 21	Model      string    // Telescope model (e.g., "Seestar S50")
 22	Latitude   float64   // Geographic location
 23	Longitude  float64   // Geographic location
 24	Owner      string    // Owner's gno address
 25	RealmPath  string    // Path to the telescope's realm (e.g., "/r/username/telescope")
 26	Status     string    // Current status: "online", "offline", "busy", "error"
 27	LastUpdate time.Time // Last status update
 28}
 29
 30// AccessRule defines who can access a telescope
 31type AccessRule struct {
 32	AllowedAddress string    // Gno address allowed to access
 33	GrantedBy      string    // Who granted access
 34	GrantedAt      time.Time // When access was granted
 35	ExpiresAt      time.Time // When access expires (zero time = never)
 36}
 37
 38// TelescopeCommand represents a command sent to a telescope
 39type TelescopeCommand struct {
 40	CommandType string    // "capture" or "stop"
 41	TargetRA    float64   // Right Ascension (for pointing/tracking)
 42	TargetDec   float64   // Declination (for pointing/tracking)
 43	Exposure    int       // Exposure time in seconds (for capture)
 44	RequestedBy string    // Who requested the command
 45	RequestedAt time.Time // When the command was requested
 46}
 47
 48// CaptureResult represents the result of an image capture
 49type CaptureResult struct {
 50	ImageURL    string    // URL to the captured image (e.g., Imgur)
 51	TargetRA    float64   // Right Ascension of target
 52	TargetDec   float64   // Declination of target
 53	Exposure    int       // Exposure time in seconds
 54	CapturedBy  string    // Who captured the image
 55	CapturedAt  time.Time // When the image was captured
 56	TelescopeID string    // Which telescope captured it
 57}
 58
 59// NewTelescopeConfig creates a new telescope configuration
 60func NewTelescopeConfig(name, model string, lat, lon float64, owner, realmPath string) TelescopeConfig {
 61	return TelescopeConfig{
 62		Name:       name,
 63		Model:      model,
 64		Latitude:   lat,
 65		Longitude:  lon,
 66		Owner:      owner,
 67		RealmPath:  realmPath,
 68		Status:     "offline",
 69		LastUpdate: time.Now(),
 70	}
 71}
 72
 73// UpdateStatus updates the telescope status
 74func (t *TelescopeConfig) UpdateStatus(status string) {
 75	t.Status = status
 76	t.LastUpdate = time.Now()
 77}
 78
 79// IsAccessAllowed checks if an address has a current (non-expired) access rule.
 80// rules is an avl.Tree keyed by allowed address holding AccessRule values.
 81func IsAccessAllowed(address string, rules *avl.Tree) bool {
 82	if !rules.Has(address) {
 83		return false
 84	}
 85	rule := rules.Get(address).(AccessRule)
 86	return rule.ExpiresAt.IsZero() || time.Now().Before(rule.ExpiresAt)
 87}
 88
 89// ValidateCommand validates a telescope command
 90func ValidateCommand(cmd TelescopeCommand, config TelescopeConfig) {
 91	switch cmd.CommandType {
 92	case "capture", "stop":
 93	default:
 94		panic("invalid command type: must be capture or stop")
 95	}
 96
 97	if cmd.CommandType == "capture" {
 98		if cmd.TargetRA < 0 || cmd.TargetRA >= 24 {
 99			panic("invalid RA: must be between 0 and 24 hours")
100		}
101		if cmd.TargetDec < -90 || cmd.TargetDec > 90 {
102			panic("invalid Dec: must be between -90 and 90 degrees")
103		}
104		if cmd.Exposure < 1 || cmd.Exposure > 300 {
105			panic("invalid exposure time: must be between 1 and 300 seconds")
106		}
107	}
108}
109
110// maxCaptureHistory is the number of captures a single telescope keeps locally.
111const maxCaptureHistory = 100
112
113// TelescopeRealm manages a single telescope's state and operations
114type TelescopeRealm struct {
115	Config       *TelescopeConfig
116	AccessRules  *avl.Tree // key: allowed address -> AccessRule
117	CommandQueue []TelescopeCommand
118	Captures     *CaptureFeed
119	OwnerAddress string
120}
121
122// NewTelescopeRealm creates a new telescope realm instance
123func NewTelescopeRealm(config *TelescopeConfig) *TelescopeRealm {
124	return &TelescopeRealm{
125		Config:       config,
126		AccessRules:  avl.NewTree(),
127		CommandQueue: []TelescopeCommand{},
128		Captures:     NewCaptureFeed(maxCaptureHistory),
129		OwnerAddress: config.Owner,
130	}
131}
132
133// GrantAccess allows the owner to grant access to another user. Re-granting to
134// an existing address overwrites the previous rule.
135func (r *TelescopeRealm) GrantAccess(caller, address string, durationDays int) {
136	r.checkOwner(caller)
137
138	if address == "" {
139		panic("address cannot be empty")
140	}
141
142	expiresAt := time.Time{} // Never expires by default
143	if durationDays > 0 {
144		expiresAt = time.Now().Add(time.Duration(durationDays) * 24 * time.Hour)
145	}
146
147	rule := AccessRule{
148		AllowedAddress: address,
149		GrantedBy:      r.OwnerAddress,
150		GrantedAt:      time.Now(),
151		ExpiresAt:      expiresAt,
152	}
153
154	r.AccessRules.Set(address, rule)
155}
156
157// RevokeAccess removes access for a specific address
158func (r *TelescopeRealm) RevokeAccess(caller, address string) {
159	r.checkOwner(caller)
160	r.AccessRules.Remove(address)
161}
162
163// SubmitCommand allows authorized users to submit telescope commands
164func (r *TelescopeRealm) SubmitCommand(caller, commandType string, targetRA, targetDec float64, exposure int) {
165	// Check if caller has access (owner always has access)
166	if caller != r.OwnerAddress {
167		if !IsAccessAllowed(caller, r.AccessRules) {
168			panic("access denied: you don't have permission to use this telescope")
169		}
170	}
171
172	// Create command
173	cmd := TelescopeCommand{
174		CommandType: commandType,
175		TargetRA:    targetRA,
176		TargetDec:   targetDec,
177		Exposure:    exposure,
178		RequestedBy: caller,
179		RequestedAt: time.Now(),
180	}
181
182	// Validate command
183	ValidateCommand(cmd, *r.Config)
184
185	// Add to queue
186	r.CommandQueue = append(r.CommandQueue, cmd)
187
188	// Update telescope status to busy
189	r.Config.UpdateStatus("busy")
190}
191
192// GetNextCommand returns the next command in the queue (for telescope controller)
193func (r *TelescopeRealm) GetNextCommand(caller string) TelescopeCommand {
194	r.checkOwner(caller)
195
196	if len(r.CommandQueue) == 0 {
197		panic("no commands in queue")
198	}
199
200	cmd := r.CommandQueue[0]
201	r.CommandQueue = r.CommandQueue[1:]
202
203	return cmd
204}
205
206// UpdateStatus allows the owner to update telescope status
207func (r *TelescopeRealm) UpdateStatus(caller string, status string) {
208	r.checkOwner(caller)
209	r.Config.UpdateStatus(status)
210}
211
212// RecordCapture allows the owner to record a capture result
213func (r *TelescopeRealm) RecordCapture(caller, imageURL string, targetRA, targetDec float64, exposure int, capturedBy string) {
214	r.checkOwner(caller)
215
216	if imageURL == "" {
217		panic("image URL cannot be empty")
218	}
219
220	capture := CaptureResult{
221		ImageURL:    imageURL,
222		TargetRA:    targetRA,
223		TargetDec:   targetDec,
224		Exposure:    exposure,
225		CapturedBy:  capturedBy,
226		CapturedAt:  time.Now(),
227		TelescopeID: r.Config.Name,
228	}
229
230	r.Captures.Add(capture)
231
232	// Update status back to online
233	r.Config.UpdateStatus("online")
234}
235
236// ClearCommandQueue clears all pending commands (emergency stop)
237func (r *TelescopeRealm) ClearCommandQueue(caller string) {
238	r.checkOwner(caller)
239	r.CommandQueue = []TelescopeCommand{}
240	r.Config.UpdateStatus("online")
241}
242
243// GetCommandCount returns the number of pending commands
244func (r *TelescopeRealm) GetCommandCount() int {
245	return len(r.CommandQueue)
246}
247
248// GetCaptureCount returns the number of stored captures
249func (r *TelescopeRealm) GetCaptureCount() int {
250	return r.Captures.Len()
251}
252
253// GetAccessRuleCount returns the number of access rules
254func (r *TelescopeRealm) GetAccessRuleCount() int {
255	return r.AccessRules.Size()
256}
257
258// checkOwner verifies the caller is the owner
259func (r *TelescopeRealm) checkOwner(caller string) {
260	if caller != r.OwnerAddress {
261		panic("access restricted: owner only")
262	}
263}