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.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.Time

	Strip av.FlightStrip

	// State related to navigation.
	Nav nav.Nav

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

	NASFlightPlan *NASFlightPlan

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

	GoAroundDistance *float32

	// Departure related state
	DepartureContactAltitude float32

	// The controller who gave approach clearance
	ApproachTCP TCP

	// Who had control when the fp disassociated due to an arrival filter.
	PreArrivalDropTCP TCP

	FirstSeen time.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.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  string `json:"runway"`
}

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

type CommonState struct {
	DynamicState

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

	ConfigurationId string // Short identifier for the configuration (from ControllerConfiguration.ConfigId)

	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
	ScenarioDefaultVideoMaps  []string
	ScenarioDefaultVideoGroup string

	FacilityAdaptation FacilityAdaptation

	Facility          string
	MagneticVariation float32
	NmPerLongitude    float32
	PrimaryAirport    string

	SimDescription string

	PrivilegedTCWs map[TCW]bool // TCWs with elevated privileges (can control any aircraft)
	Observers      map[TCW]bool // TCWs connected as observers (no position)

	VideoMapLibraryHash []byte
}

type ConsolidationType int

type ControlCommandsResult struct {
	RemainingInput string
	Error          error
}

type ControlPosition = av.ControlPosition

type ControllerAssignments struct {
	InboundAssignments   map[string]TCP `json:"inbound_assignments"`
	DepartureAssignments map[string]TCP `json:"departure_assignments"`
}

type ControllerConfiguration struct {
	// ConfigId references a configuration in stars_config.configurations that defines
	// the inbound and departure assignments for this scenario.
	ConfigId string `json:"config_id"`

	// DefaultConsolidation defines the consolidation tree. Each key is a parent TCP, and its value is the list
	// of TCPs consolidated into it.  Example: {"1A": ["1B", "1C"], "1C": ["1D"]} means 1B and 1C
	// consolidated into 1A, and 1D consolidated into 1C (and transitively into 1A).
	DefaultConsolidation PositionConsolidation `json:"default_consolidation"`

	// InboundAssignments maps inbound flow names to the TCP that handles them.
	// This is populated from the referenced configuration during post-deserialization.
	InboundAssignments map[string]TCP `json:"-"`

	// DepartureAssignments maps departure specifiers to the TCP that handles them.  Keys can be:
	// airport only ("KJFK"), airport/runway ("KJFK/22R"), or airport/SID ("KJFK/SKORR5"). It is not
	// allowed to mix different specifier types for the same airport within a configuration.
	// This is populated from the referenced configuration during post-deserialization.
	DepartureAssignments map[string]TCP `json:"-"`
}

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

type DepartureAircraft struct {
	ADSBCallsign  av.ADSBCallsign
	MinSeparation time.Duration // How long after takeoff it will be at ~6000' and airborne
	SpawnTime     time.Time     // when it was first spawned
	LaunchTime    time.Time     // when it was actually launched; used for wake turbulence separation, etc.

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

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

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

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

type DynamicState struct {
	GenerationIndex int

	CurrentConsolidation map[TCW]*TCPConsolidation

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

	METAR map[string]wx.METAR

	LaunchConfig LaunchConfig

	UserRestrictionAreas []av.RestrictionArea

	Paused  bool
	SimRate float32

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

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

type ERAMMap struct {
	BcgName    string
	LabelLine1 string
	LabelLine2 string
	Name       string
	Lines      [][]math.Point2LL
}

type ERAMMapGroup struct {
	Maps       []ERAMMap
	LabelLine1 string
	LabelLine2 string
}

type ERAMMapGroups map[string]ERAMMapGroup

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.Time
}

type Event struct {
	Type                  EventType
	ADSBCallsign          av.ADSBCallsign
	ACID                  ACID
	FromController        ControlPosition
	ToController          ControlPosition // For radio transmissions, the controlling controller.
	WrittenText           string
	SpokenText            string
	RadioTransmissionType av.RadioTransmissionType       // For radio transmissions only
	LeaderLineDirection   *math.CardinalOrdinalDirection // SetGlobalLeaderLineEvent
	WaypointInfo          []math.Point2LL
}

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

type EventSubscriberId int

type EventType int

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

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

	AirspaceAwareness   []AirspaceAwareness                        `json:"airspace_awareness" scope:"stars"`
	ForceQLToSelf       bool                                       `json:"force_ql_self" scope:"stars"`
	AllowLongScratchpad bool                                       `json:"allow_long_scratchpad" scope:"stars"`
	VideoMapNames       []string                                   `json:"stars_maps" scope:"stars"`
	ERAMMapNames        map[string][]string                        `json:"eram_maps" scope:"eram"`
	VideoMapLabels      map[string]string                          `json:"map_labels"`
	ControllerConfigs   map[ControlPosition]*STARSControllerConfig `json:"controller_configs"`
	RadarSites          map[string]*av.RadarSite                   `json:"radar_sites" scope:"stars"`
	Center              math.Point2LL                              `json:"-"`
	CenterString        string                                     `json:"center"`
	MaxDistance         float32                                    `json:"max_distance"` // Distance from center where aircraft get culled from (default 125nm)
	Range               float32                                    `json:"range"`
	Scratchpads         map[string]string                          `json:"scratchpads" scope:"stars"`
	SignificantPoints   map[string]SignificantPoint                `json:"significant_points" scope:"stars"`
	Altimeters          []string                                   `json:"altimeters"`

	// 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       FilterRegions `json:"quicklook"`
		SecondaryDrop   FilterRegions `json:"secondary_drop"`
		SurfaceTracking FilterRegions `json:"surface_tracking"`
		VFRInhibit      FilterRegions `json:"vfr_inhibit"`
	} `json:"filters" scope:"stars"` //Should this be STARS or justy parts of it?

	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" scope:"stars"`

	VideoMapFile      string                        `json:"video_map_file"`
	CoordinationFixes map[string]av.AdaptationFixes `json:"coordination_fixes" scope:"stars"`
	SingleCharAIDs    map[string]string             `json:"single_char_aids" scope:"stars"` // Char to airport. TODO: Check if this is for ERAM as well.
	KeepLDB           bool                          `json:"keep_ldb" scope:"stars"`
	FullLDBSeconds    int                           `json:"full_ldb_seconds" scope:"stars"`

	SSRCodes av.LocalSquawkCodePoolSpecifier `json:"ssr_codes" scope:"stars"`

	HandoffAcceptFlashDuration int  `json:"handoff_acceptance_flash_duration" scope:"stars"`
	DisplayHOFacilityOnly      bool `json:"display_handoff_facility_only" scope:"stars"`
	HOSectorDisplayDuration    int  `json:"handoff_sector_display_duration" scope:"stars"`

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

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

	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" scope:"stars"`

	FDB struct {
		DisplayRequestedAltitude bool `json:"display_requested_altitude"`
		Scratchpad2OnLine3       bool `json:"scratchpad2_on_line3"`
	} `json:"fdb" scope:"stars"`

	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" scope:"stars"`

	CustomSPCs []string `json:"custom_spcs"`

	CoordinationLists []CoordinationList `json:"coordination_lists" scope:"stars"`
	VFRList           struct {
		Format string `json:"format"`
	} `json:"vfr_list" scope:"stars"`
	TABList struct {
		Format string `json:"format"`
	} `json:"tab_list" scope:"stars"`
	CoastSuspendList struct {
		Format string `json:"format"`
	} `json:"coast_suspend_list" scope:"stars"`
	MCISuppressionList struct {
		Format string `json:"format"`
	} `json:"mci_suppression_list" scope:"stars"`
	TowerList struct {
		Format string `json:"format"`
	} `json:"tower_list" scope:"stars"`
	RestrictionAreas  []av.RestrictionArea `json:"restriction_areas" scope:"stars"`
	UseLegacyFont     bool                 `json:"use_legacy_font" scope:"stars"`
	DisplayRNAVSymbol bool                 `json:"display_rnav_symbol"`
}

type FilterRegion struct {
	av.AirspaceVolume
	InvertTest bool
}

type FilterRegions []FilterRegion

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.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[string]
	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]
	ForceACTypeDisplayEndTime util.Optional[time.Time]
}

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

type FutureControllerContact struct {
	ADSBCallsign av.ADSBCallsign
	TCP          TCP
	Time         time.Time
}

type FutureEmergencyUpdate struct {
	ADSBCallsign av.ADSBCallsign
	Time         time.Time
}

type FutureOnCourse struct {
	ADSBCallsign av.ADSBCallsign
	Time         time.Time
}

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

type HeadingArgs struct {
	TCW          TCW
	ADSBCallsign av.ADSBCallsign
	Heading      int
	Present      bool
	LeftDegrees  int
	RightDegrees int
	Turn         nav.TurnMethod
}

type LaunchConfig struct {
	// Controller is the TCW in charge of the launch settings; if empty then
	// launch control may be taken by any signed in controller.
	Controller TCW
	// LaunchManual or LaunchAutomatic, separate for each aircraft type
	DepartureMode  int32
	ArrivalMode    int32
	OverflightMode int32

	GoAroundRate float32
	// airport -> runway -> category -> rate
	DepartureRates     map[string]map[string]map[string]float32
	DepartureRateScale float32

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

	// inbound flow -> airport / "overflights" -> rate
	InboundFlowRates            map[string]map[string]float32
	InboundFlowRateScale        float32
	ArrivalPushes               bool
	ArrivalPushFrequencyMinutes int
	ArrivalPushLengthMinutes    int

	EmergencyAircraftRate float32 // Aircraft per hour
}

type NASFlightPlan struct {
	ACID                  ACID
	CID                   string
	EntryFix              string
	ExitFix               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.Time
	PlanType              NASFlightPlanType

	AssignedSquawk av.Squawk

	TrackingController    ControlPosition // Who has the radar track
	ControllingController ControlPosition // Who has control; not necessarily the same as TrackingController
	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           int
	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

	InhibitACTypeDisplay      bool
	ForceACTypeDisplayEndTime time.Time
	CWTCategory               string

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

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

type NASFlightPlanType int

type NewSimConfiguration struct {
	Facility    string
	Description string

	Airports           map[string]*av.Airport
	PrimaryAirport     string
	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

	TFRs               []av.TFR
	FacilityAdaptation FacilityAdaptation

	EnforceUniqueCallsignSuffix bool

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

	PilotErrorInterval float32

	WXProvider wx.Provider

	Emergencies []Emergency
}

type PilotSpeech struct {
	Callsign av.ADSBCallsign
	Type     av.RadioTransmissionType
	Text     string
	MP3      []byte
}

type PointOut struct {
	FromController ControlPosition
	ToController   ControlPosition
	AcceptTime     time.Time
}

type PositionConsolidation map[TCP][]TCP

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

	// For each runway, when to create the next departing aircraft, based
	// on the runway departure rate. The actual time an aircraft is
	// launched may be later, e.g. if we need longer for wake turbulence
	// separation, etc.
	NextIFRSpawn time.Time
	NextVFRSpawn time.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.Time      // when the last arrival landed on this runway
	LastArrivalFlightRules av.FlightRules // flight rules of the last arrival that landed

	VFRAttempts  int
	VFRSuccesses int
}

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

type STARSControllerConfig struct {
	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"`
}

type SecondaryTCP struct {
	TCP  TCP
	Type ConsolidationType
}

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

	STARSComputer *STARSComputer
	ERAMComputer  *ERAMComputer

	LocalCodePool *av.LocalSquawkCodePool
	CIDAllocator  *CIDAllocator

	TotalIFR, TotalVFR           int
	QuickFlightPlanIndex         int
	ScenarioDefaultConsolidation PositionConsolidation

	VFRReportingPoints []av.VFRReportingPoint

	METAR map[string][]wx.METAR

	// Airport -> runway -> state
	DepartureState map[string]map[string]*RunwayLaunchState
	// Key is inbound flow group name
	NextInboundSpawn map[string]time.Time
	NextVFFRequest   time.Time

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

	ReportingPoints []av.ReportingPoint

	EnforceUniqueCallsignSuffix bool

	FutureControllerContacts []FutureControllerContact
	FutureOnCourse           []FutureOnCourse
	FutureSquawkChanges      []FutureChangeSquawk
	FutureEmergencyUpdates   []FutureEmergencyUpdate

	NextEmergencyTime time.Time

	PilotErrorInterval time.Duration
	LastPilotError     time.Time

	NextPushStart time.Time // both w.r.t. sim time
	PushEnd       time.Time

	Rand *rand.Rand

	SquawkWarnedACIDs map[ACID]interface{} // Warn once in CheckLeaks(); don't spam the logs
	// contains filtered or unexported fields
}

type StateUpdate struct {
	DynamicState
	DerivedState
}

type TCP = ControlPosition

type TCPConsolidation struct {
	PrimaryTCP    TCP
	SecondaryTCPs []SecondaryTCP
}

type TCW string

type TTSProvider interface {
	GetAllVoices() TTSVoicesFuture
	TextToSpeech(voice Voice, text string) TTSSpeechFuture
}

type TTSSpeechFuture struct {
	Mp3Ch <-chan []byte
	ErrCh <-chan error
}

type TTSVoicesFuture struct {
	VoicesCh <-chan []Voice
	ErrCh    <-chan error
}

type Track struct {
	av.RadarTrack

	FlightPlan *NASFlightPlan

	// Sort of hacky to carry these along here but it's convenient...
	DepartureAirport          string
	DepartureAirportElevation float32
	DepartureAirportLocation  math.Point2LL
	ArrivalAirport            string
	ArrivalAirportElevation   float32
	ArrivalAirportLocation    math.Point2LL
	FiledRoute                string
	FiledAltitude             int
	OnExtendedCenterline      bool
	OnApproach                bool
	ATPAVolume                *av.ATPAVolume
	MVAsApply                 bool
	HoldForRelease            bool
	MissingFlightPlan         bool
	Route                     []math.Point2LL
	IsTentative               bool // first 5 seconds after first contact
}

type UserState struct {
	CommonState
	DerivedState
}

type VideoMap struct {
	Label       string // for DCB
	Group       int    // 0 -> A, 1 -> B
	Name        string // For maps system list
	Id          int
	Category    int
	Restriction struct {
		Id        int
		Text      [2]string
		TextBlink bool
		HideText  bool
	}
	Color int
	Lines [][]math.Point2LL
}

type VideoMapLibrary struct {
	Maps          []VideoMap
	ERAMMapGroups ERAMMapGroups
}

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

type Voice string