sim

type ACID string

type ATPAConfigOp int

type ATPAVolumeState struct {
	Disabled          bool
	Reduced25Disabled bool
}

type Aircraft struct {
	// This is ADS-B callsign of the aircraft. Just because different the
	// callsign in the flight plan can be different across multiple STARS
	// facilities, so two different facilities can show different
	// callsigns; however, the ADS-B callsign is transmitted from the
	// aircraft and would be the same to all facilities.
	ADSBCallsign av.ADSBCallsign

	Squawk av.Squawk
	Mode   av.TransponderMode

	IdentStartTime, IdentEndTime Time

	FlightPlan   av.FlightPlan
	TypeOfFlight av.TypeOfFlight
	// For departures, after we first see them in the departure acquisition
	// volume, we set a time a bit in the future for the flight plan to
	// actually acquire to simulate the delay in that.
	DepartureFPAcquisitionTime Time

	// State related to navigation.
	Nav nav.Nav

	// Departure-related state
	SID string

	// Arrival-related state
	STAR                  string
	STARRunwayWaypoints   map[string]av.WaypointArray
	GotContactTower       bool
	AskedAboutTowerSwitch bool

	NASFlightPlan *NASFlightPlan

	// ControllerFrequency is the controller position whose radio frequency
	// this aircraft is tuned to. Only this controller can issue ATC commands
	// to the aircraft. Empty means the aircraft is not on any controller's
	// frequency.
	ControllerFrequency ControlPosition

	HoldForRelease    bool
	Released          bool // only used for hold for release
	ReleaseTime       Time
	WaitingForLaunch  bool // for departures
	MissingFlightPlan bool

	GoAroundDistance *float32

	// Set when tower sends aircraft around for spacing; affects the contact message.
	SentAroundForSpacing bool
	// Set when a spacing check rolled "no go-around"; prevents re-rolling every tick.
	SpacingGoAroundDeclined bool
	// Set when going around on runway heading (vs a specific assigned heading).
	GoAroundOnRunwayHeading bool
	// Set when the aircraft has gone around; prevents the arrival drop
	// filter from dropping its flight plan.
	WentAround bool

	// Departure related state
	DepartureContactAltitude float32 // 0 = waiting for /tc point, -1 = already contacted departure
	ReportDepartureHeading   bool    // true if runway has multiple exit headings
	ReportDepartureSID       bool    // true if runway has multiple SIDs

	FirstSeen Time

	RequestedFlightFollowing bool
	// WaitingForGoAhead is set when a VFR aircraft has made an abbreviated
	// flight following request ("approach, N123AB, VFR request") and is
	// waiting for the controller to say "go ahead".
	WaitingForGoAhead bool

	EmergencyState *EmergencyState

	LastRadioTransmission Time

	// LastAddressingForm tracks how the controller last addressed this aircraft.
	// Used for readbacks to match the controller's style.
	LastAddressingForm CallsignAddressingForm

	// ATIS letter the aircraft reported during initial contact (e.g., "B").
	// Empty if the pilot did not report having ATIS.
	ReportedATIS string

	// SeenTraffic tracks traffic the pilot has reported in sight, ordered
	// from oldest to newest.
	SeenTraffic []SeenAircraft

	// FieldInSight is set when the pilot has confirmed the airport is in sight
	// (either via AP command response or spontaneous report).
	FieldInSight bool

	// RequestedVisualApproach is set when the pilot has spontaneously requested
	// the visual approach (field in sight). Prevents repeated requests.
	RequestedVisualApproach bool
	// WantsVisualApproach is decided at aircraft creation: whether this pilot spontaneously reports
	// field in sight when eligible.
	WantsVisualApproach bool
	// VisualApproachRequestDistance, if non-zero, is the distance (NM) from the arrival airport at
	// which the pilot will perform a single visibility check and request the visual approach if the
	// field is in sight. Set to zero after the check (requested or given up) to prevent retries.
	VisualApproachRequestDistance float32

	TouchAndGosRemaining int // >0 means pattern aircraft; decremented each lap

	// HoldingSince is when a VFR arrival started orbiting to wait for a slot
	// in the pattern; it orders the queue of aircraft waiting to get in.
	// Zero when the aircraft isn't holding.
	HoldingSince Time
}

type AircraftDisplayState struct {
	Spew        string // for debugging
	FlightState string // for display when paused
}

type AirspaceAwareness struct {
	Fix                 []string `json:"fixes"`
	AltitudeRange       [2]int   `json:"altitude_range"`
	ReceivingController string   `json:"receiving_controller"`
	AircraftType        []string `json:"aircraft_type"`
}

type ArrivalRunway struct {
	Airport  string             `json:"airport"`
	Runway   av.RunwayID        `json:"runway"`
	GoAround *GoAroundProcedure `json:"go_around,omitempty"`
}

type AutoHandoffInhibit struct {
	Intrafacility bool
	Interfacility bool
}

type AutoHandoffOp int

type AutoScratchpadRow struct {
	ConfigPlan   string `json:"config_plan"`   // config plan id, or "*" for any
	EntryFix     string `json:"entry_fix"`     // fix/airport/derived; "*" = any (incl unassigned); "" = only unassigned
	ExitFix      string `json:"exit_fix"`      // same convention as entry_fix
	FlightType   string `json:"flight_type"`   // exactly one of "A", "P", or "E"
	Altitude     string `json:"altitude"`      // hundreds of feet ("000".."999"); "VFR"; "*" or "" = any
	AltitudeType string `json:"altitude_type"` // "R" (equals) | "RA" (at or below); required for a numeric altitude
	GroupID      string `json:"group_id"`      // A-Z or ""; groups fix pairs for the supervisor scratchpad-group command
	Scratchpad1  string `json:"scratchpad1"`   // 1-3 chars; "^" -> delta symbol
	Scratchpad2  string `json:"scratchpad2"`
}

type CIDAllocator struct {
	List [7]map[string]any
}

type CallsignAddressingForm int

type CommonState struct {
	DynamicState

	Airports          map[string]*av.Airport
	Controllers       map[ControlPosition]*av.Controller
	DepartureAirports map[string]any
	ArrivalAirports   map[string]any
	Fixes             map[string]math.Point2LL
	VFRRunways        map[string]av.Runway // assume just one runway per airport

	ConfigurationId string // Short identifier for the configuration (from scenario's "configuration" field)

	Airspace map[ControlPosition]map[string][]av.ControllerAirspaceVolume // position -> vol name -> definition

	DepartureRunways []DepartureRunway
	ArrivalRunways   []ArrivalRunway
	InboundFlows     map[string]*av.InboundFlow
	Emergencies      []Emergency

	Center                    math.Point2LL
	Range                     float32
	ScenarioCenter            math.Point2LL
	ScenarioRange             float32
	ScenarioDefaultVideoMaps  []string
	ScenarioDefaultVideoGroup string

	FacilityAdaptation FacilityAdaptation
	// ERAMCoordination is the pseudo-ERAM adaptation this sim uses to derive
	// entry/exit fixes, resolved at load from the ERAM host (ARTCC) config for
	// this facility's TRACON computer id. Nil if none is adapted.
	ERAMCoordination *enroute.Coordination

	Facility          string
	MagneticVariation float32
	NmPerLongitude    float32

	SimDescription string
	ScenarioBrief  string

	TFRs []av.TFR

	HandoffIDs []HandoffID
}

type ConsolidationType int

type ControlCommandsResult struct {
	RemainingInput     string
	Error              error
	ReadbackSpokenText string          // Spoken text for TTS synthesis (if readback was generated)
	ReadbackCallsign   av.ADSBCallsign // Aircraft callsign for the readback
}

type ControlPosition = av.ControlPosition

type ControllerConfiguration struct {
	// DefaultConsolidation defines the consolidation tree. It is populated
	// during post-deserialization: a scenario may define its own
	// "default_consolidation", otherwise it falls back to the one on the
	// referenced facility configuration.
	DefaultConsolidation PositionConsolidation `json:"-"`

	// InboundAssignments maps inbound flow names to the TCP that handles them.
	// Populated from the referenced configuration during post-deserialization.
	InboundAssignments map[string]TCP

	// DepartureAssignments maps departure specifiers to the TCP that handles them.
	// Populated from the referenced configuration during post-deserialization.
	DepartureAssignments map[string]TCP

	// GoAroundAssignments maps airport or airport/runway to the TCP that handles go-arounds.
	// This is populated from the referenced configuration during post-deserialization.
	GoAroundAssignments map[string]TCP
}

type CoordinationList struct {
	Name          string   `json:"name"`
	Id            string   `json:"id"`
	Airports      []string `json:"airports"`
	YellowEntries bool     `json:"yellow_entries"`
	Format        string   `json:"format"`

	// OwnerTCP, if set, restricts this list to release requests for departures
	// assigned to that departure controller TCP. This does not assign the
	// departure controller; it only lets one airport's releases be split across
	// several lists by assigned TCP.
	// Empty = all assigned TCPs for the list's airports, or the remainder when
	// the airport also has owner-scoped lists.
	OwnerTCP TCP `json:"owner_tcp,omitempty"`
}

type DepartureAircraft struct {
	ADSBCallsign  av.ADSBCallsign
	MinSeparation time.Duration // How long after takeoff it will be at ~6000' and airborne
	// AirborneDistance is the estimated distance in nm from the departure
	// point at which the aircraft lifts off; negative if it wasn't airborne
	// within the horizon of the takeoff-roll simulation.
	AirborneDistance float32
	SpawnTime        Time // when it was first spawned
	LaunchTime       Time // when it was actually launched; used for wake turbulence separation, etc.

	// When they're ready to leave the gate
	ReadyDepartGateTime Time

	// HFR-only.
	ReleaseRequested   bool
	ReleaseDelay       time.Duration // minimum wait after release before the takeoff roll
	RequestReleaseTime Time
}

type DepartureLaunchSlot struct {
	LaunchFlight
	Airport      string
	Category     string
	Rules        av.FlightRules
	AircraftType string
	Exit         string
	Destination  string
	Position     math.Point2LL
}

type DepartureRunway struct {
	Airport     string      `json:"airport"`
	Runway      av.RunwayID `json:"runway"`
	Category    string      `json:"category,omitempty"`
	DefaultRate float32     `json:"rate"`
}

type DerivedState struct {
	Tracks                  map[av.ADSBCallsign]*Track
	UnassociatedFlightPlans []*NASFlightPlan // Unassociated ones, including unsupported DBs
	ReleaseDepartures       []ReleaseDeparture

	// The launch control window's manual launch slots; empty for kinds whose
	// launches are automatic.
	DepartureLaunchSlots []DepartureLaunchSlot
	InboundLaunchSlots   []InboundLaunchSlot
}

type DynamicState struct {
	GenerationIndex int

	CurrentConsolidation map[TCW]*TCPConsolidation

	SimTime Time // this is our fake time--accounting for pauses & simRate..

	METAR      map[string]wx.METAR
	ATISLetter map[string]string // airport ICAO -> single letter "A"-"Z"
	ATIS       [10]string
	GIText     [10]string

	LaunchConfig LaunchConfig

	RestrictionAreas map[int]av.RestrictionArea

	Paused  bool
	SimRate float32

	ATPAEnabled     bool                                   // True if ATPA is enabled system-wide
	ATPAVolumeState map[string]map[string]*ATPAVolumeState // airport -> volumeId -> state

	// Automatic handoff processing (AHOP) inhibits: site-wide (STARS 8.8,
	// p. 8-13) and per-TCP (STARS 4.3, p. 4-30). TCPs with nothing inhibited
	// are absent from the map.
	AutoHandoffSiteInhibited bool
	AutoHandoffTCPInhibits   map[ControlPosition]AutoHandoffInhibit
}

type ERAMComputer struct {
	SquawkCodePool *av.EnrouteSquawkCodePool
	Identifier     string
	Adaptation     av.ERAMAdaptation
}

type Emergency struct {
	Name               string `json:"name"`
	ApplicableToString string `json:"applicable_to"`
	ApplicableTo       EmergencyApplicability
	Weight             float32          `json:"weight"`
	Stages             []EmergencyStage `json:"stages"`
}

type EmergencyApplicability int

type EmergencyStage struct {
	Transmission        string `json:"transmission"`
	DurationMinutes     [2]int `json:"duration_minutes"`
	RequestReturn       bool   `json:"request_return"`
	StopClimb           bool   `json:"stop_climb"`
	Checklists          bool   `json:"checklists"`
	RequestEquipment    bool   `json:"request_equipment"`
	RequestDelayVectors bool   `json:"request_delay_vectors"`
	DeclareEmergency    bool   `json:"declare_emergency"`
}

type EmergencyState struct {
	Emergency      *Emergency
	CurrentStage   int
	NextUpdateTime Time
}

type Event struct {
	Type                  EventType
	ADSBCallsign          av.ADSBCallsign
	ACID                  ACID
	FromController        ControlPosition
	ToController          ControlPosition   // For radio transmissions, the controlling controller.
	Redirectors           []ControlPosition // For AcceptedRedirectedHandoffEvent, the redirecting positions.
	DestinationTCW        TCW               // The TCW that should receive this transmission's TTS
	WrittenText           string
	SpokenText            string
	RadioTransmissionType av.RadioTransmissionType       // For radio transmissions only
	LeaderLineDirection   *math.CardinalOrdinalDirection // SetGlobalLeaderLineEvent, FDAMLeaderLineEvent
	WaypointInfo          []math.Point2LL
	STTTranscript         string
	STTCommand            string
	STTTimings            string
	Route                 av.WaypointArray // For QU
}

type EventStream struct {
	// contains filtered or unexported fields
}

type EventSubscriberId int

type EventType int

type EventsSubscription struct {
	// contains filtered or unexported fields
}

type FDAMConfigOp int

type FDAMRegion struct {
	av.AirspaceVolume
	FilterQualifiers

	// Entry actions
	NewScratchpad1           string `json:"new_scratchpad_1"`
	AllowScratchpad1Override bool   `json:"allow_scratchpad_1_override"`
	NewScratchpad2           string `json:"new_scratchpad_2"`
	AllowScratchpad2Override bool   `json:"allow_scratchpad_2_override"`

	NewOwnerLeaderDirectionString string `json:"new_owner_leader_direction"`
	NewOwnerLeaderDirection       *math.CardinalOrdinalDirection

	HandoffInitiateTransfer string `json:"handoff_initiate_transfer"` // "I", "T", or "N"
	NewOwnerTCPString       string `json:"new_owner_tcp"`
	NewOwnerTCP             ControlPosition

	NewTCPSpecificLeaderDirectionString string `json:"new_tcp_specific_leader_direction"`
	NewTCPSpecificLeaderDirection       *math.CardinalOrdinalDirection

	ImmediatePointout  bool   `json:"immediate_pointout"`
	PointoutTCPsString string `json:"pointout_tcps"`
	PointoutTCPs       []ControlPosition

	// Exit actions
	RetainOwnerLeaderDirection       bool `json:"retain_owner_leader_direction"`
	RetainTCPSpecificLeaderDirection bool `json:"retain_tcp_specific_leader_direction"`
}

type FDAMRegions []FDAMRegion

type FDAMTrackState struct {
	Inside                       bool
	PreEntryOwnerLeaderDirection *math.CardinalOrdinalDirection
}

type FacilityAdaptation struct {
	// Configurations maps config IDs (max 3 chars) to facility configurations.
	// These define which TCP handles each inbound flow and departure airport/runway/SID.
	Configurations map[string]*FacilityConfiguration `json:"configurations"`

	AirspaceAwareness []AirspaceAwareness                  `json:"airspace_awareness"`
	VideoMapLabels    map[string]string                    `json:"map_labels"`
	Controllers       map[ControlPosition]*STARSController `json:"controllers"`
	Areas             map[string]*STARSArea                `json:"areas,omitempty"`
	RadarSites        map[string]*av.RadarSite             `json:"radar_sites"`
	Center            math.Point2LL                        `json:"-"`
	CenterString      string                               `json:"center"`
	MaxDistance       float32                              `json:"max_distance"` // Distance from center where aircraft get culled from (default 125nm STARS, 400nm ERAM)
	Range             float32                              `json:"range"`
	Scratchpads       map[string]string                    `json:"scratchpads"`
	SignificantPoints map[string]SignificantPoint          `json:"significant_points"`

	// WeatherStation is the METAR station standing in for the facility when no
	// gridded weather is available for it: winds aloft are synthesized from its
	// observations and pattern traffic consults it when its own airport has no
	// METAR. Defaults to the SSA system altimeter.
	WeatherStation string `json:"weather_station,omitempty"`

	// Airports are fix-pair endpoints that name an airport rather than a
	// significant point.
	Airports map[string]*FixPairAirport `json:"airports,omitempty"`
	// FixPairConfiguration is the STARS-side fix-pair adaptation: reassignment
	// rules and per-configuration-plan owner assignments.
	FixPairConfiguration *FixPairConfiguration `json:"fix_pair_configuration,omitempty"`
	// AutoScratchpadAssignment sets a flight's default scratchpad(s) at
	// creation from adapted criteria (DMS Sec. 4.7.8, p. 4-189).
	AutoScratchpadAssignment []AutoScratchpadRow `json:"automatic_scratchpad_assignment,omitempty"`
	// TCPAssignmentClasses and AutomaticHandoffClasses name adapted aircraft
	// classes (DMS Sec. 4.21.1), each mapping a class name (1-8 alphanumeric
	// characters, at most 26 classes) to the aircraft types in the class.
	// The former is referenced by fix-pair reassignment rules' "ac_type", the
	// latter by handoff filters' "actype_class".
	TCPAssignmentClasses    map[string][]string `json:"tcp_assignment_classes,omitempty"`
	AutomaticHandoffClasses map[string][]string `json:"automatic_handoff_classes,omitempty"`

	// Pseudo-ERAM coordination adaptation; these live on the ARTCC (ERAM host)
	// configuration rather than on a TRACON's.
	ArtsCoordination map[string]*enroute.ArtsCoordEntry `json:"arts_coordination,omitempty"`
	Restrictions     []enroute.Restriction              `json:"restrictions,omitempty"`

	// Airpsace filters
	Filters struct {
		AutoAcquisition FilterRegions        `json:"auto_acquisition"`
		ArrivalDrop     FilterRegions        `json:"arrival_drop"`
		Departure       FilterRegions        `json:"departure"`
		InhibitCA       FilterRegions        `json:"inhibit_ca"`
		InhibitMSAW     FilterRegions        `json:"inhibit_msaw"`
		Quicklook       QuicklookRegions     `json:"quicklook"`
		FDAM            FDAMRegions          `json:"fdam"`
		Handoff         HandoffFilterRegions `json:"handoff"`
		SecondaryDrop   FilterRegions        `json:"secondary_drop"`
		SurfaceTracking FilterRegions        `json:"surface_tracking"`
		VFRInhibit      FilterRegions        `json:"vfr_inhibit"`
	} `json:"filters"`

	MonitoredBeaconCodeBlocksString  *string
	MonitoredBeaconCodeBlocks        []av.Squawk
	UntrackedPositionSymbolOverrides struct {
		CodeRangesString string         `json:"beacon_codes"`
		CodeRanges       [][2]av.Squawk // inclusive
		Symbol           string         `json:"symbol"`
	} `json:"untracked_position_symbol_overrides"`

	VideoMapFile       string                        `json:"video_map_file"`
	CoordinationFixes  map[string]av.AdaptationFixes `json:"coordination_fixes"`
	SingleCharAIDs     map[string]string             `json:"single_char_aids"`
	Monitor            string                        `json:"monitor"`
	Thick20NmRangeRing bool                          `json:"thick_20nm_range_ring"`

	SSRCodes av.LocalSquawkCodePoolSpecifier `json:"ssr_codes"`

	AirportCodes map[string]string `json:"airport_codes"`

	FlightPlan struct {
		QuickACID          string            `json:"quick_acid"`
		ACIDExpansions     map[string]string `json:"acid_expansions"`
		ModifyAfterDisplay bool              `json:"modify_after_display"`
	} `json:"flight_plan"`

	Datablocks struct {
		ClockPhase struct {
			Sequence  []int     `json:"sequence"`  // e.g., [1,2,1,3]
			Intervals []float32 `json:"intervals"` // per-position durations in seconds
		} `json:"clock_phase"`
		FDB struct {
			DisplayRequestedAltitude bool `json:"display_requested_altitude"`
			Scratchpad2OnLine3       bool `json:"scratchpad2_on_line3"`
			DisplayFacilityOnly      bool `json:"display_facility_only"`
			AcceptFlashDuration      int  `json:"accept_flash_duration"`
			SectorDisplayDuration    int  `json:"sector_display_duration"`
		} `json:"fdb"`
		PDB struct {
			ShowScratchpad2   bool `json:"show_scratchpad2"`
			HideGroundspeed   bool `json:"hide_gs"`
			ShowAircraftType  bool `json:"show_aircraft_type"`
			SplitGSAndCWT     bool `json:"split_gs_and_cwt"`
			DisplayCustomSPCs bool `json:"display_custom_spcs"`
		} `json:"pdb"`
		LDB struct {
			KeepAfterSlew bool `json:"keep_after_slew"`
			FullSeconds   int  `json:"full_seconds"`
		} `json:"ldb"`
		Scratchpad1 struct {
			DisplayExitFix     bool `json:"display_exit_fix"`
			DisplayExitFix1    bool `json:"display_exit_fix_1"`
			DisplayExitGate    bool `json:"display_exit_gate"`
			DisplayAltExitGate bool `json:"display_alternate_exit_gate"`
		} `json:"scratchpad1"`
		AllowLongScratchpad bool     `json:"allow_long_scratchpad"`
		ForceQLToSelf       bool     `json:"force_ql_self"`
		CustomSPCs          []string `json:"custom_spcs"`
		DisplayRNAVSymbol   bool     `json:"display_rnav_symbol"`
	} `json:"datablocks"`

	Lists struct {
		Coordination []CoordinationList `json:"coordination"`
		SSA          struct {
			Altimeters []string `json:"altimeters"`
			// SystemAltimeter is the station whose setting the SSA ALTSTG field
			// shows (5-55); it also heads the altimeter list when none is
			// adapted. A STARSArea may override it for its positions.
			SystemAltimeter   string `json:"system_altimeter,omitempty"`
			FlashOnATISUpdate bool   `json:"flash_on_atis_update"`
		} `json:"ssa"`
		VFR struct {
			Format string `json:"format"`
		} `json:"vfr"`
		TAB struct {
			Format string `json:"format"`
		} `json:"tab"`
		CoastSuspend struct {
			Format string `json:"format"`
		} `json:"coast_suspend"`
		MCISuppression struct {
			Format string `json:"format"`
		} `json:"mci_suppression"`
		Tower struct {
			Format string `json:"format"`
		} `json:"tower"`
	} `json:"lists"`
	RestrictionAreas map[int]av.RestrictionArea `json:"restriction_areas"`
	UseLegacyFont    bool                       `json:"use_legacy_font"`
	STARSMacros      STARSMacroSet              `json:"stars_macros"`
}

type FacilityConfig struct {
	ControlPositions           map[TCP]*av.Controller `json:"control_positions"`
	FacilityAdaptation         FacilityAdaptation     `json:"facility_adaptations"`
	HandoffIDs                 []HandoffID            `json:"handoff_ids"`
	DisableTFRRestrictionAreas bool                   `json:"disable_tfr_restriction_areas"`
}

type FacilityConfiguration struct {
	InboundAssignments   map[string]TCP `json:"inbound_assignments"`
	DepartureAssignments map[string]TCP `json:"departure_assignments"`
	// GoAroundAssignments maps airport or airport/runway to the controller
	// who should handle go-arounds. If not specified, departure controller is used.
	GoAroundAssignments  map[string]TCP        `json:"go_around_assignments"`
	DefaultConsolidation PositionConsolidation `json:"default_consolidation"`

	// ScratchpadLeaderLineDirectionStrings is the JSON-facing map from
	// primary scratchpad values to cardinal/ordinal direction strings
	// (e.g. "N", "NE", "SW"). Resolved into ScratchpadLeaderLineDirections
	// during PostDeserialize.
	ScratchpadLeaderLineDirectionStrings map[string]string `json:"scratchpad_leader_line_directions"`
	// ScratchpadLeaderLineDirections is the resolved map from primary
	// scratchpad values to leader line directions.
	ScratchpadLeaderLineDirections map[string]math.CardinalOrdinalDirection `json:"-"`
}

type FilterQualifiers struct {
	// JSON input fields (comma-delimited strings)
	TCPsString                string `json:"tcps"`
	ScratchpadString          string `json:"scratchpad"`
	SecondaryScratchpadString string `json:"secondary_scratchpad"`
	OwningTCPString           string `json:"owning_tcp"`
	EntryFixString            string `json:"entry_fix"`
	ExitFixString             string `json:"exit_fix"`
	FlightType                string `json:"flight_type"`
	FlightRules               string `json:"flight_rules"`
	CWTCategory               string `json:"cwt_category"`
	SSRCodesString            string `json:"ssr_codes"`
	RequestedAltitudeString   string `json:"requested_altitude"`

	// Parsed runtime fields
	TCPs                 []ControlPosition `json:"-"`
	Scratchpads          []string          `json:"-"`
	SecondaryScratchpads []string          `json:"-"`
	OwningTCPs           []ControlPosition `json:"-"`
	EntryFixes           []string          `json:"-"`
	ExitFixes            []string          `json:"-"`
	SSRCodes             [][2]av.Squawk    `json:"-"`
	RequestedAltitudes   [][2]int          `json:"-"`
}

type FilterRegion struct {
	av.AirspaceVolume
	InvertTest bool
}

type FilterRegions []FilterRegion

type FixPair struct {
	Entry string
	Exit  string
}

type FixPairAirport struct {
	Name         string        `json:"name"`
	LocationStr  string        `json:"location"`
	Abbreviation string        `json:"abbreviation"`
	Location     math.Point2LL `json:"-"`
}

type FixPairAssignmentRow struct {
	FixPair [2]string      `json:"fix_pair"` // [entry, exit]
	TCP     map[string]TCP `json:"tcp"`      // config plan id(s) -> owning logical TCP
	// RNAV marks the fix pair as an RNAV route ("RNAV Route?" in the Fix Pair
	// Configurations Window): matching flights are identified as RNAV and
	// display the RNAV symbol in their data blocks.
	RNAV bool `json:"rnav,omitempty"`
}

type FixPairAssignments struct {
	Arrival    []FixPairAssignmentRow `json:"arrival"`
	Departure  []FixPairAssignmentRow `json:"departure"`
	Overflight []FixPairAssignmentRow `json:"overflight"`
}

type FixPairConfiguration struct {
	// Plans maps a Configuration Plan id (== facility configuration id, e.g.
	// "CNE") to a human description.
	Plans map[string]string `json:"plans"`
	// Reassignments derive an alternate fix pair before assignment; rules are
	// evaluated in order and the first match wins. These correspond to the
	// real system's TCP-type reassignment conditions (the AHO type drives
	// BGS interfacility auto-handoff, which vice doesn't model).
	Reassignments []FixPairReassignment `json:"fix_pair_reassignment"`
	// Assignments is the sequential first-match table, split by the
	// arrival/departure/overflight bucket.
	Assignments FixPairAssignments `json:"fix_pair_assignments"`
}

type FixPairInput struct {
	Entry, Exit     string
	FlightType      av.TypeOfFlight
	Level           int // hundreds of feet (see fixPairLevel)
	VFR, OTP        bool
	ACType          string // aircraft type, e.g. "A320"
	ACID            string
	ActiveRunways   []string // the scenario's active runways, as "AIRPORT/RUNWAY"
	DepartureRunway string   // the flight's own departure runway; empty for arrivals/overflights
}

type FixPairReassignment struct {
	FpFixPair    [2]string `json:"fp_fix_pair"`    // flight-plan [fix1, fix2]; "*" = any
	AltBands     LevelBand `json:"alt_bands"`      // [lo,hi] hundreds ft | "VFR" | "OTP" | "*"
	ACType       string    `json:"ac_type"`        // an adapted "tcp_assignment" aircraft type class, or "*"
	ACID         string    `json:"acid"`           // callsign pattern (see matchACIDPattern)
	TypeOfFlight string    `json:"type_of_flight"` // "A" | "P" | "E" | "*"
	// ActiveRunway names a runway as "AIRPORT/RUNWAY" (e.g. "KJFK/22L") and
	// matches when it is active in the scenario ("*" or unset = any). DMS
	// scopes the criterion to the adapted Main ATIS/GSI airport; naming the
	// airport here is the general form, which a facility working more than
	// one airport needs.
	ActiveRunway string `json:"active_runway"`
	// DepartureRunway matches the flight's own departure runway exactly
	// ("*" or unset = any). This is a vice extension, not a DMS criterion:
	// it distinguishes simultaneous departures off different runways (e.g.
	// east- vs west-side splits), which active_runway cannot when both
	// runways are active.
	DepartureRunway string    `json:"departure_runway"`
	DerivedFixPair  [2]string `json:"derived_fix_pair"` // [derived1, derived2]; "" or "*" keeps original
}

type FlightPlanSpecifier struct {
	ACID                  util.Optional[ACID]
	EntryFix              util.Optional[string]
	ExitFix               util.Optional[string]
	ExitFixIsIntermediate util.Optional[bool]
	Rules                 util.Optional[av.FlightRules]
	CoordinationTime      util.Optional[Time]
	PlanType              util.Optional[NASFlightPlanType]

	SquawkAssignment         util.Optional[string]
	ImplicitSquawkAssignment util.Optional[av.Squawk] // only used when taking the track's current code

	TrackingController util.Optional[ControlPosition]

	AircraftCount   util.Optional[int]
	AircraftType    util.Optional[string]
	EquipmentSuffix util.Optional[string]

	TypeOfFlight util.Optional[av.TypeOfFlight]

	AssignedAltitude      util.Optional[int]
	InterimAlt            util.Optional[int]
	InterimType           util.Optional[InterimAltType]
	AltitudeBlock         util.Optional[[2]int]
	ControllerReportedAlt util.Optional[int]
	VFROTP                util.Optional[bool]
	RequestedAltitude     util.Optional[int]
	PilotReportedAltitude util.Optional[int]

	Scratchpad          util.Optional[string]
	SecondaryScratchpad util.Optional[string]

	RNAV       util.Optional[bool]
	RNAVToggle util.Optional[bool]

	Location util.Optional[math.Point2LL]

	PointOutHistory             util.Optional[[]string]
	InhibitModeCAltitudeDisplay util.Optional[bool]
	SPCOverride                 util.Optional[string]
	DisableMSAW                 util.Optional[bool]
	DisableCA                   util.Optional[bool]
	MCISuppressedCode           util.Optional[av.Squawk]
	GlobalLeaderLineDirection   util.Optional[*math.CardinalOrdinalDirection]
	QuickFlightPlan             util.Optional[bool]
	HoldState                   util.Optional[bool]
	Suspended                   util.Optional[bool]
	CoastSuspendIndex           util.Optional[int]

	InhibitACTypeDisplay      util.Optional[bool]
	AutoHandoffInhibited      util.Optional[bool]
	ForceACTypeDisplayEndTime util.Optional[Time]
}

type FlightSchedule struct {
	Departures  []ScheduledDeparture
	Arrivals    []ScheduledArrival
	Overflights []ScheduledOverflight

	// ScenarioGeneratedUntil is how far the scenario-sourced entries reach;
	// consumption extends the schedule when the clock nears it.
	ScenarioGeneratedUntil Time
}

type FutureChangeSquawk struct {
	ADSBCallsign av.ADSBCallsign
	Code         av.Squawk
	Mode         av.TransponderMode
	Time         Time
}

type FutureEmergencyUpdate struct {
	ADSBCallsign av.ADSBCallsign
	Time         Time
}

type FutureFieldCheck struct {
	Time Time
	// ClearedWhenAsked records whether the aircraft was already cleared for an
	// approach when the controller asked for the report. If it wasn't, a
	// clearance issued while the pilot is still looking makes the report moot.
	ClearedWhenAsked bool
}

type FutureFrequencyChange struct {
	ADSBCallsign av.ADSBCallsign
	TCP          TCP
	Time         Time
}

type FutureOnCourse struct {
	ADSBCallsign av.ADSBCallsign
	Time         Time
}

type FutureTrafficCheck struct {
	TrafficCallsign av.ADSBCallsign
	Time            Time
}

type GoAroundProcedure struct {
	Heading           int      `json:"heading"` // degrees 1-360; 0 (or unset) means runway heading
	IsRunwayHeading   bool     // true when heading was 0 (runway heading) before resolution
	Altitude          int      `json:"altitude"`           // feet, e.g., 2000, 3000
	HandoffController TCP      `json:"handoff_controller"` // TCP (e.g., "1D")
	HoldDepartures    []string `json:"hold_departures"`    // runways to hold, empty = no holds
}

type Handoff struct {
	AutoAcceptTime    Time
	ReceivingFacility string // only for auto accept
}

type HandoffFilterRegion struct {
	av.AirspaceVolume
	FilterQualifiers

	// ConfigPlan (Config Plan): the configuration plan that must be active for
	// this row to apply; blank means any plan.
	ConfigPlan string `json:"config_plan"`
	// TerminalSector (Terminal Sector): conditions the ConfigPlan match on a
	// specific terminal sector. Parsed and validated but not enforced at
	// runtime, since vice does not model per-terminal-sector plan activation.
	TerminalSector string `json:"terminal_sector"`
	// SlaveTCPs (+ Slave TCPs): when true, a TCP named in "owning_tcp" also
	// matches if it is consolidated to the flight's owning TCP.
	SlaveTCPs bool `json:"slave_tcps"`
	// OwnerTCPs takes over the "owning_tcp" list parsed by the embedded
	// FilterQualifiers, which is left empty: the match needs the SlaveTCPs
	// flag and the current consolidation, so it is made in the Sim rather than
	// by FilterQualifiers.Match.
	OwnerTCPs []ControlPosition `json:"-"`
	// ACTypeClass (A/C Type Class): an adapted class from
	// "automatic_handoff_classes"; blank means any.
	ACTypeClass string `json:"actype_class"`
	// HandoffAction (Handoff Action): "I" initiate, "T" transfer, or "D"
	// disable auto-handoff for the track. Mandatory in the real system; we
	// default it to "I". ("A", accept, is not supported.)
	HandoffAction string `json:"handoff_action"`
	// HORcvr (HO Rcvr): the local TCP that receives the handoff or transfer
	// for "I"/"T". Must be blank for "D". External facility receivers are not
	// supported.
	HORcvr ControlPosition `json:"ho_receiver"`
}

type HandoffFilterRegions []HandoffFilterRegion

type HandoffID struct {
	ID                string `json:"id"`
	Prefix            string `json:"prefix,omitempty"`
	SingleCharStarsID string `json:"single_char_stars_id,omitempty"`
	TwoCharStarsID    string `json:"two_char_stars_id,omitempty"`
	StarsID           string `json:"stars_id,omitempty"`
	FieldEFormat      string `json:"field_e_format,omitempty"`
	FieldELetter      string `json:"field_e_letter,omitempty"`
}

type HeadingArgs struct {
	TCW            TCW
	ADSBCallsign   av.ADSBCallsign
	Heading        int
	Present        bool
	LeftDegrees    int
	RightDegrees   int
	Turn           av.TurnDirection
	DelayReduction time.Duration
}

type InboundLaunchSlot struct {
	LaunchFlight
	Group        string
	Airport      string
	AircraftType string
	Position     math.Point2LL
}

type InterimAltType int

type LastSTTCommand struct {
	Callsign    av.ADSBCallsign
	NavSnapshot nav.NavSnapshot
}

type LaunchConfig struct {
	// LaunchManual or LaunchAutomatic, separate for each aircraft type
	DepartureMode  int32
	ArrivalMode    int32
	OverflightMode int32

	// TrafficSource controls whether automatic IFR aircraft come from the
	// scenario's own rate-based traffic generator, a built-in timetable, or
	// historical flight data.
	TrafficSource TrafficSource
	// TimetableID and TimetableAirport identify the selected built-in timetable
	// when TrafficSource is TrafficSourceTimetable; a scenario may offer
	// timetables for more than one of its airports, so the id alone doesn't
	// name one.
	TimetableID      string
	TimetableAirport string
	// TimetableStartMinute is the selected local start time, expressed as
	// minutes after midnight at the timetable's airport.
	TimetableStartMinute int
	// PublishedArrivalRateScale is how fast published IFR arrivals are flown as
	// a multiple of the rate the data holds them at: the sim reads through the
	// arrivals at that multiple of real time, anchored at the sim's start time,
	// so two flies the whole day's traffic in half the time rather than half of
	// its flights. It applies to both timetable and historical traffic.
	PublishedArrivalRateScale float32

	// PublishedDepartureRateScale is PublishedArrivalRateScale for published IFR
	// departures.
	PublishedDepartureRateScale float32

	GoAroundRate         float32
	EnableTowerGoArounds bool
	// airport -> runway -> category -> rate
	DepartureRates     map[string]map[av.RunwayID]map[string]float32
	DepartureRateScale float32
	// airport -> runway -> category -> enabled; which flows timetable and
	// historical traffic launch from. Scenario traffic uses the rates instead.
	DepartureEnabled map[string]map[av.RunwayID]map[string]bool
	// airport -> runway -> category -> the traffic there is nobody's to work.
	// A scenario flies a neighboring airport's operations for realism, start to
	// finish under virtual controllers; it fills out the scope but it isn't
	// traffic the user signed up for, so it stays out of what we report they
	// will see. Keyed like DepartureEnabled, and only the true entries are
	// present: an absent one is traffic a human works, which is the common case
	// and the safe assumption for a config that was never classified.
	DepartureBackground map[string]map[av.RunwayID]map[string]bool

	VFRDepartureRateScale   float32
	VFRAirportRates         map[string]float32 // name -> VFRRateSum()
	VFFRequestRate          int32
	HaveVFRReportingRegions bool

	// inbound flow -> airport / "overflights" -> rate
	InboundFlowRates map[string]map[string]float32
	// inbound flow -> airport -> enabled; which flows timetable and historical
	// traffic land. Overflights aren't included: they are always randomly
	// generated, so their rates apply regardless of the traffic source.
	InboundFlowEnabled map[string]map[string]bool
	// inbound flow -> airport -> the traffic there is nobody's to work; see
	// DepartureBackground. Overflights are included here, under the same
	// "overflights" key the rates use, since a flow may carry those for realism
	// as readily as it carries arrivals.
	InboundFlowBackground       map[string]map[string]bool
	InboundFlowRateScale        float32
	ArrivalPushes               bool
	ArrivalPushFrequencyMinutes int
	ArrivalPushLengthMinutes    int

	EmergencyAircraftRate float32 // Aircraft per hour
}

type LaunchFlight struct {
	Callsign  av.ADSBCallsign
	Departure bool
	Runway    av.RunwayID
	Day       uint16
	Minute    int
}

type LevelBand struct {
	Any      bool
	VFR      bool
	OTP      bool
	HasRange bool
	Range    [2]int // hundreds of feet, valid when HasRange
}

type NASFlightPlan struct {
	ACID     ACID
	CID      string
	EntryFix string
	ExitFix  string
	// DerivedEntryFix/DerivedExitFix are set when fix-pair reassignment
	// substitutes a derived fix for that end of the pair; empty means no
	// substitution. The flight plan keeps its actual fixes: the derived pair
	// is used for owning-TCP assignment, automatic scratchpad assignment, and
	// handoff-filter qualification, and the FDB prefers the derived fix's
	// abbreviation, but the displayed entry/exit fixes remain the actual ones.
	DerivedEntryFix       string
	DerivedExitFix        string
	ArrivalAirport        string // Technically not a string, but until the NAS system is fully integrated, we'll need this.
	ExitFixIsIntermediate bool
	Rules                 av.FlightRules
	CoordinationTime      Time
	PlanType              NASFlightPlanType

	AssignedSquawk av.Squawk

	TrackingController  ControlPosition // Who has the radar track
	HandoffController   ControlPosition // Handoff offered but not yet accepted
	LastLocalController ControlPosition // (May be the current controller.)
	OwningTCW           TCW             // TCW that owns this track

	AircraftCount   int
	AircraftType    string
	EquipmentSuffix string

	TypeOfFlight av.TypeOfFlight

	AssignedAltitude      int
	PerceivedAssigned     int // what the previous controller would put into the hard alt, even though the aircraft is descending via a STAR.
	InterimAlt            int
	InterimType           InterimAltType
	AltitudeBlock         [2]int
	ControllerReportedAlt int
	VFROTP                bool

	RequestedAltitude     int
	PilotReportedAltitude int

	Scratchpad          string
	SecondaryScratchpad string

	PriorScratchpad          string
	PriorSecondaryScratchpad string

	RNAV bool

	Location math.Point2LL
	Route    string

	PointOutHistory             []ControlPosition
	InhibitModeCAltitudeDisplay bool
	SPCOverride                 string
	DisableMSAW                 bool
	DisableCA                   bool
	MCISuppressedCode           av.Squawk
	GlobalLeaderLineDirection   *math.CardinalOrdinalDirection
	QuickFlightPlan             bool
	HoldState                   bool
	Suspended                   bool
	CoastSuspendIndex           int

	// FIXME: the following are all used internally by NAS code. It's
	// convenient to have them here but this stuff should just be managed
	// internally there.
	ListIndex int

	// First controller in the local facility to get the track: used both
	// for /ho and for departures
	InboundHandoffController ControlPosition

	CoordinationFix     string
	ContainedFacilities []string
	RedirectedHandoff   RedirectedHandoff

	// LocalArrival marks an internal ("fully-contained") flight whose exit fix
	// is a local-arrival airport, i.e. its destination is within this facility.
	LocalArrival bool `json:"-"`

	// AutoHandoffInhibited marks the track ineligible for automatic handoff
	// processing (AHOP); it drives the delta indicator in the data block.
	AutoHandoffInhibited bool
	// AutoHandoffInhibitLocked is set when AHOP was disabled by a handoff
	// filter row with the "D" action, which a controller can't reverse
	// (STARS 5.1.7, p. 5-15).
	AutoHandoffInhibitLocked bool
	// HandoffWasAutomatic is set while a handoff initiated by auto-handoff
	// filter processing is pending and cleared when it is accepted; recalling
	// such a handoff makes the track ineligible for further automatic
	// handoffs (STARS 5.1.17, p. 5-33).
	HandoffWasAutomatic bool

	InhibitACTypeDisplay      bool
	ForceACTypeDisplayEndTime Time
	CWTCategory               string

	// After fps are dropped, we hold on to them for a bit before they're
	// actually deleted.
	DeleteTime Time

	// Used so that such FPs can associate regardless of acquisition filters.
	ManuallyCreated bool

	// FDAM region membership state, keyed by region ID.
	FDAMState map[string]*FDAMTrackState `json:"-"`

	// Auto-handoff filter membership state, keyed by region ID. The value is
	// whether the track currently satisfies the region (inside + conditions).
	HandoffFilterState map[string]bool `json:"-"`

	// Flight strip fields
	StripCID         int             // numeric 000-999, allocated server-side
	StripAnnotations [9]string       // 3x3 annotation grid
	StripOwner       ControlPosition // which TCP position has this strip (empty = no strip)
}

type NASFlightPlanType int

type NewSimConfiguration struct {
	Facility    string
	Description string
	Brief       string

	Airports           map[string]*av.Airport
	DepartureRunways   []DepartureRunway
	ArrivalRunways     []ArrivalRunway
	InboundFlows       map[string]*av.InboundFlow
	LaunchConfig       LaunchConfig
	Fixes              map[string]math.Point2LL
	VFRReportingPoints []av.VFRReportingPoint

	ControlPositions        map[TCP]*av.Controller
	ControllerAirspace      map[TCP][]string
	VirtualControllers      []TCP
	ControllerConfiguration *ControllerConfiguration
	ConfigurationId         string

	TFRs                       []av.TFR
	FacilityAdaptation         FacilityAdaptation
	DisableTFRRestrictionAreas bool

	EnforceUniqueCallsignSuffix bool

	ReportingPoints   []av.ReportingPoint
	MagneticVariation float32
	NmPerLongitude    float32
	StartTime         time.Time
	WindSpecifier     *wx.WindSpecifier
	Center            math.Point2LL
	Range             float32
	ScenarioCenter    math.Point2LL
	ScenarioRange     float32
	DefaultMaps       []string
	DefaultMapGroup   string
	Airspace          av.Airspace

	PilotErrorInterval float32

	WXProvider *wx.Provider

	Emergencies []Emergency

	HandoffIDs []HandoffID
	// ERAMCoordination is the resolved pseudo-ERAM adaptation for this
	// facility's TRACON computer id, or nil if none is adapted.
	ERAMCoordination *enroute.Coordination
}

type PatternAircraft struct {
	ADSBCallsign av.ADSBCallsign
	Phase        PatternPhase
}

type PatternPhase int

type PatternState struct {
	Aircraft  []PatternAircraft // max 2
	NextSpawn Time
}

type PendingContact struct {
	ADSBCallsign           av.ADSBCallsign
	TCP                    TCP
	ReadyTime              Time                    // When pilot is ready to transmit
	Type                   PendingTransmissionType // What kind of transmission
	ReportDepartureHeading bool                    // For departures: include assigned heading
	HasQueuedEmergency     bool                    // For departures: trigger emergency after contact
	PrebuiltTransmission   *av.RadioTransmission   // For emergency transmissions: pre-built message
	FirstInFacility        bool                    // First contact with a controller in this facility
}

type PendingTransmissionType int

type PilotSpeech struct {
	Callsign av.ADSBCallsign
	Type     av.RadioTransmissionType
	Text     string
	SimTime  Time // Virtual simulation time when transmission was made
}

type PointOut struct {
	FromController ControlPosition
	ToController   ControlPosition
	AcceptTime     Time
}

type PositionConsolidation map[TCP][]TCP

type QuicklookRegion struct {
	av.AirspaceVolume
	FilterQualifiers
}

type QuicklookRegions []QuicklookRegion

type RedirectedHandoff struct {
	OriginalOwner ControlPosition   // Controller position
	Redirector    []ControlPosition // Redirecting controllers
	RedirectedTo  ControlPosition
}

type ReleaseDeparture struct {
	ADSBCallsign        av.ADSBCallsign
	DepartureAirport    string
	DepartureController ControlPosition
	Released            bool
	Squawk              av.Squawk
	ListIndex           int
	AircraftType        string
	Exit                string
}

type RunwayLaunchState struct {
	IFRSpawnRate float32
	VFRSpawnRate float32

	// NextVFRSpawn is when to create the runway's next VFR departure, based
	// on its VFR rate; IFR departures come from the schedule. The actual
	// time an aircraft is launched may be later, e.g. if we need longer for
	// wake turbulence separation, etc.
	NextVFRSpawn Time

	// At the gate, flight plan filed (if IFR), not yet ready to go
	Gate []DepartureAircraft
	// Ready to go, in hold for release purgatory.
	Held []DepartureAircraft
	// Ready to go.
	ReleasedIFR []DepartureAircraft
	ReleasedVFR []DepartureAircraft
	// Sequenced departures, pulled from Released. These are launched in-order.
	Sequenced []DepartureAircraft

	LastDeparture          *DepartureAircraft
	LastArrivalLandingTime Time           // when the last arrival landed on this runway
	LastArrivalFlightRules av.FlightRules // flight rules of the last arrival that landed

	// GoAroundHoldUntil is the time until which departures should be held
	// after a go-around. Departures auto-resume after this time.
	GoAroundHoldUntil Time

	VFRAttempts  int
	VFRSuccesses int
}

type STARSArea struct {
	DefaultAirport                  string        `json:"default_airport,omitempty"` // CRDA default airport for this area
	VideoMapFile                    string        `json:"video_map_file,omitempty"`
	VideoMapNames                   []string      `json:"video_maps,omitempty"`
	DefaultMaps                     []string      `json:"default_maps,omitempty"`
	Center                          math.Point2LL `json:"-"`
	CenterString                    string        `json:"center,omitempty"`
	Range                           float32       `json:"range,omitempty"`
	MonitoredBeaconCodeBlocksString *string       `json:"beacon_code_blocks,omitempty"`
	MonitoredBeaconCodeBlocks       []av.Squawk   `json:"-"`
	Altimeters                      []string      `json:"altimeters,omitempty"`
	// SystemAltimeter overrides the facility's SSA system altimeter for
	// positions in this area.
	SystemAltimeter   string              `json:"system_altimeter,omitempty"`
	Scratchpads       map[string]string   `json:"scratchpads,omitempty"`
	AirspaceAwareness []AirspaceAwareness `json:"airspace_awareness,omitempty"`
}

type STARSComputer struct {
	Identifier       string
	FlightPlans      []*NASFlightPlan
	HoldForRelease   []*Aircraft
	AvailableIndices []int
}

type STARSController struct {
	VideoMapFile                    string        `json:"video_map_file,omitempty"`
	VideoMapNames                   []string      `json:"video_maps"`
	DefaultMaps                     []string      `json:"default_maps"`
	Center                          math.Point2LL `json:"-"`
	CenterString                    string        `json:"center"`
	Range                           float32       `json:"range"`
	MonitoredBeaconCodeBlocksString *string       `json:"beacon_code_blocks"`
	MonitoredBeaconCodeBlocks       []av.Squawk
	FlightFollowingAirspace         []av.AirspaceVolume `json:"flight_following_airspace"`
	Altimeters                      []string            `json:"altimeters"`
}

type STARSMacro struct {
	Input       string   `json:"input"`
	Commands    []string `json:"commands"`
	Output      string   `json:"output"`
	Description string   `json:"description"`
}

type STARSMacroSet []STARSMacro

type ScheduledArrival struct {
	ScheduledFlight
	Group string
	Index int // into State.InboundFlows[Group].Arrivals

	// FiledRoute, Substitute, and How record how a published flight was
	// fitted into the scenario; see placeArrival.
	FiledRoute string
	Substitute string
	How        string

	// DropReason, when non-empty, marks a published arrival with no
	// placement; it stays queued so the drop is reported when its spawn time
	// comes around rather than in a heap at launch.
	DropReason string
}

type ScheduledDeparture struct {
	ScheduledFlight
	Runway         av.RunwayID
	Category       string
	DepartureIndex int // into State.Airports[DepartureAirport].Departures
}

type ScheduledFlight struct {
	Callsign         string
	AircraftType     string
	DepartureAirport string
	ArrivalAirport   string
	Source           TrafficSource
	SpawnTime        Time

	// Published entries retain the flight data's Day/Minute so that a rate
	// scale change can rewrite SpawnTime in place; SpawnOffset survives such
	// rewrites and carries recycle shifts and manual-to-automatic rebases.
	Day         uint16
	Minute      int
	SpawnOffset time.Duration

	// Airline lets a scenario entry resample its callsign if it clashes when
	// the flight is created; zero for published entries, whose real callsigns
	// are not resampled.
	Airline av.AirlineSpecifier
}

type ScheduledOverflight struct {
	ScheduledFlight
	Group string
	Index int // into State.InboundFlows[Group].Overflights
}

type SecondaryTCP struct {
	TCP  TCP
	Type ConsolidationType
}

type SeenAircraft struct {
	Callsign                    av.ADSBCallsign
	SightedTime                 Time
	OfferedToMaintainSeparation bool
	MaintainingVisualSeparation bool
	FollowingOnVisualApproach   bool
}

type SignificantPoint struct {
	Name         string        // JSON comes in as a map from name to SignificantPoint; we set this.
	ShortName    string        `json:"short_name"`
	Abbreviation string        `json:"abbreviation"`
	Description  string        `json:"description"`
	Location     math.Point2LL `json:"location"`
}

type Sim struct {
	State *CommonState

	Aircraft map[av.ADSBCallsign]*Aircraft

	ControlPositions     map[TCP]*av.Controller
	VirtualControllers   []TCP
	InboundAssignments   map[string]TCP // Inbound flow name -> TCP responsible
	DepartureAssignments map[string]TCP // Departure specifier -> TCP responsible
	GoAroundAssignments  map[string]TCP // Airport or airport/runway -> go-around controller

	STARSComputer *STARSComputer
	ERAMComputer  *ERAMComputer

	LocalCodePool *av.LocalSquawkCodePool
	CIDAllocator  *CIDAllocator

	TotalIFR, TotalVFR           int
	QuickFlightPlanIndex         int
	ScenarioDefaultConsolidation PositionConsolidation

	VFRReportingPoints []av.VFRReportingPoint

	METAR map[string][]wx.METAR

	ATISChangedTime map[string]Time

	// Airport -> runway -> state
	DepartureState map[string]map[av.RunwayID]*RunwayLaunchState
	// Airport -> pattern state
	PatternState   map[string]*PatternState
	NextVFFRequest Time

	Handoffs  map[ACID]Handoff
	PointOuts map[ACID][]PointOut

	PrivilegedTCWs map[TCW]bool // TCWs with elevated privileges (can control any aircraft)

	ReportingPoints []av.ReportingPoint

	FDAMSystemInhibited         bool
	DisabledFDAMRegions         map[string]struct{} // keyed by region ID
	EnforceUniqueCallsignSuffix bool

	PendingContacts        map[TCP][]PendingContact
	FutureFrequencyChanges []FutureFrequencyChange
	DeferredContacts       map[av.ADSBCallsign]map[ControlPosition]TCP
	FutureOnCourse         []FutureOnCourse
	// DeferredOnCourse holds departures that were handed off between two
	// virtual controllers before their tracks associated; they are sent on
	// course when association happens.
	DeferredOnCourse       map[ACID]bool
	FutureSquawkChanges    []FutureChangeSquawk
	FutureEmergencyUpdates []FutureEmergencyUpdate
	FutureFieldChecks      map[av.ADSBCallsign]*FutureFieldCheck
	FutureTrafficChecks    map[av.ADSBCallsign]*FutureTrafficCheck

	NextEmergencyTime Time

	PilotErrorInterval time.Duration
	LastPilotError     Time

	Rand *rand.Rand

	// User-selected scenario start time before Vice rewinds the clock for prespawn.
	StartTime Time

	// Schedule holds the pregenerated IFR traffic the sim flies, for every
	// traffic source.
	Schedule FlightSchedule

	// When each kind's launches were switched to manual, so that switching
	// back to automatic pushes its schedule later by the time spent there:
	// every flight resumes as far from launch as it was when manual mode
	// began, rather than a backlog spawning at once. Zero when automatic.
	DepartureManualSince  Time
	ArrivalManualSince    Time
	OverflightManualSince Time

	// The manual launch slots' pending flights, serialized with the sim so a
	// restored one shows the same aircraft. They hold no allocated resources.
	// Keys are airport/runway/category for departures, group/airport for
	// arrivals, the flow group for overflights, and the airport for VFR.
	PendingDepartures  map[string]*ScheduledDeparture
	PendingArrivals    map[string]*ScheduledArrival
	PendingOverflights map[string]*ScheduledOverflight
	PendingVFR         map[string]*Aircraft

	VoiceAssigner *VoiceAssigner

	SquawkWarnedACIDs map[ACID]any // Warn once in CheckLeaks(); don't spam the logs

	// LastSTTCommand stores state needed to roll back a misheard STT command.
	// Only the single most recent command is tracked.
	LastSTTCommand *LastSTTCommand

	AvailableStripCIDs []int
	// contains filtered or unexported fields
}