sim

type AbbreviatedFPFields struct {
	ACID                string
	BCN                 av.Squawk
	ControllingPosition string
	TypeOfFlight        string // Figure out this
	SC1                 string
	SC2                 string
	AircraftType        string
	RequestedALT        string
	Rules               av.FlightRules
	DepartureAirport    string // Specified with type of flight (maybe)

	// TODO: why is there an error stored here (vs just returned from the
	// parsing function)?
	Error error
}

type AcceptHandoffArgs AircraftSpecifier

type AircraftCommandsArgs struct {
	ControllerToken string
	Callsign        string
	Commands        string
}

type AircraftCommandsResult struct {
	ErrorMessage   string
	RemainingInput string
}

type AircraftDataMessage struct {
	DepartureLocation string // Only for departures.
	ArrivalLocation   string // Only for arrivals. I think this is made up, but I don't know where to get the arrival info from.
	NumberOfAircraft  int    // Default this at one for now.
	AircraftType      string // A20N, B737, etc.

	// V = VFR (not heavy jet),
	// H = Heavy,
	// W = Heavy + VFR,
	// U = Heavy + OTP.
	AircraftCategory string
	Equipment        string // /L, /G, /A, etc
}

type AircraftSpecifier struct {
	ControllerToken string
	Callsign        string
}

type Airspace struct {
	Boundaries map[string][]math.Point2LL            `json:"boundaries"`
	Volumes    map[string][]ControllerAirspaceVolume `json:"volumes"`
}

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

type AssignAltitudeArgs struct {
	ControllerToken string
	Callsign        string
	Altitude        int
}

type CancelHandoffArgs AircraftSpecifier

type ChangeControlPositionArgs struct {
	ControllerToken string
	Callsign        string
	KeepTracks      bool
}

type Configuration struct {
	ScenarioConfigs  map[string]*SimScenarioConfiguration
	ControlPositions map[string]*av.Controller
	DefaultScenario  string
}

type Connection struct {
	SimState State
	SimProxy *proxy
}

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

type ControlClient struct {

	// This is all read-only data that we expect other parts of the system
	// to access directly.
	State
	// contains filtered or unexported fields
}

type ControllerAirspaceVolume struct {
	LowerLimit    int               `json:"lower"`
	UpperLimit    int               `json:"upper"`
	Boundaries    [][]math.Point2LL `json:"boundary_polylines"` // not in JSON
	BoundaryNames []string          `json:"boundaries"`
}

type CoordinationList struct {
	Name     string   `json:"name"`
	Id       string   `json:"id"`
	Airports []string `json:"airports"`
}

type CoordinationTime struct {
	Time time.Time
	Type string // A for arrivals, P for Departures, E for overflights
}

type CreateArrivalArgs struct {
	ControllerToken string
	Group           string
	Airport         string
}

type CreateDepartureArgs struct {
	ControllerToken string
	Airport         string
	Runway          string
	Category        string
}

type CreateOverflightArgs struct {
	ControllerToken string
	Group           string
}

type CreateUnsupportedTrackArgs struct {
	ControllerToken  string
	Callsign         string
	UnsupportedTrack *UnsupportedTrack
}

type DeleteAircraftArgs AircraftSpecifier

type DepartureAircraft struct {
	Callsign         string
	Runway           string
	ReleaseRequested bool
	Index            int
	MinSeparation    time.Duration // How long after takeoff it will be at ~6000' and airborne
	LaunchTime       time.Time
}

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

type DropTrackArgs AircraftSpecifier

type ERAMComputer struct {
	STARSComputers   map[string]*STARSComputer
	ReceivedMessages []FlightPlanMessage
	FlightPlans      map[av.Squawk]*STARSFlightPlan
	TrackInformation map[string]*TrackInformation
	SquawkCodePool   *av.SquawkCodePool
	// This is shared among all STARS computers for our facility; we keep a
	// copy in ERAMComputer so that when we deserialize after loading a
	// saved sim, we are still sharing the same one.
	STARSCodePool *av.SquawkCodePool
	Identifier    string
	Adaptation    av.ERAMAdaptation
	// contains filtered or unexported fields
}

type ERAMComputers struct {
	Computers map[string]*ERAMComputer
}

type ERAMTrackInfo struct {
	Location          math.Point2LL
	Owner             string
	HandoffController string
}

type Event struct {
	Type                  EventType
	Callsign              string
	FromController        string
	ToController          string // For radio transmissions, the controlling controller.
	Message               string
	RadioTransmissionType av.RadioTransmissionType       // For radio transmissions only
	LeaderLineDirection   *math.CardinalOrdinalDirection // SetGlobalLeaderLineEvent
}

type EventPoster interface {
	PostEvent(Event)
}

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

type EventSubscriberId int

type EventType int

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

type FlightPlanMessage struct {
	SourceID         string // LLLdddd e.g. ZCN2034 (ZNY at 2034z)
	MessageType      int
	FlightID         string // ddaLa(a)(a)(a)(a)(a)ECID (3 chars start w/ digit), Aircraft ID (2-7 chars start with letter)
	AircraftData     AircraftDataMessage
	BCN              av.Squawk
	CoordinationFix  string
	CoordinationTime CoordinationTime

	// Altitude will either be requested (cruise altitude) for departures,
	// or the assigned altitude for arrivals.  ERAM has the ability to
	// assign interm alts (and is used much more than STARS interm alts)
	// with `QQ`.  This interim altiude gets sent down to the STARS
	// computer instead of the cruising altitude. If no interim altitude is
	// set, use the cruise altitude (check this) Examples of altitudes
	// could be 310, VFR/170, VFR, 170B210 (block altitude), etc.
	Altitude string
	Route    string

	TrackInformation // For track messages
}

type ForceQLArgs struct {
	ControllerToken string
	Callsign        string
	Controller      string
}

type GlobalMessage struct {
	Message        string
	FromController string
}

type GlobalMessageArgs struct {
	ControllerToken string
	FromController  string
	Message         string
}

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

type HandoffArgs struct {
	ControllerToken string
	Callsign        string
	Controller      string
}

type HeadingArgs struct {
	ControllerToken string
	Callsign        string
	Heading         int
	Present         bool
	LeftDegrees     int
	RightDegrees    int
	Turn            av.TurnMethod
}

type HeldDepartureArgs AircraftSpecifier

type InboundFlow struct {
	Arrivals    []av.Arrival    `json:"arrivals"`
	Overflights []av.Overflight `json:"overflights"`
}

type InitiateTrackArgs struct {
	AircraftSpecifier
	Plan *STARSFlightPlan
}

type IntermTrackArgs struct {
	Token, Callsign, Initial string
	// contains filtered or unexported fields
}

type LaunchAircraftArgs struct {
	ControllerToken string
	Aircraft        av.Aircraft
}

type LaunchConfig struct {
	// Controller is the controller in charge of the launch settings; if empty then
	// launch control may be taken by any signed in controller.
	Controller string
	// LaunchManual or LaunchAutomatic
	Mode int

	GoAroundRate float32
	// airport -> runway -> category -> rate
	DepartureRates     map[string]map[string]map[string]float32
	DepartureRateScale float32
	// inbound flow -> airport / "overflights" -> rate
	InboundFlowRates            map[string]map[string]float32
	InboundFlowRateScale        float32
	ArrivalPushes               bool
	ArrivalPushFrequencyMinutes int
	ArrivalPushLengthMinutes    int
}

type NewSimConfiguration struct {
	TRACONName   string
	TRACON       map[string]*Configuration
	GroupName    string
	Scenario     *SimScenarioConfiguration
	ScenarioName string

	NewSimName      string // for create remote only
	RequirePassword bool   // for create remote only
	Password        string // for create remote only
	NewSimType      int

	LiveWeather               bool
	SelectedRemoteSim         string
	SelectedRemoteSimPosition string
	RemoteSimPassword         string // for join remote only

	DisplayError error
	// contains filtered or unexported fields
}

type NewSimResult struct {
	SimState        *State
	ControllerToken string
}

type PointOut struct {
	FromController string
	AcceptTime     time.Time
}

type PointOutArgs struct {
	ControllerToken string
	Callsign        string
	Controller      string
}

type RemoteSim struct {
	GroupName          string
	ScenarioName       string
	PrimaryController  string
	RequirePassword    bool
	AvailablePositions map[string]struct{}
	CoveredPositions   map[string]struct{}
}

type RootFS struct{}

type STARSComputer struct {
	Identifier        string
	ContainedPlans    map[av.Squawk]*STARSFlightPlan
	ReceivedMessages  []FlightPlanMessage
	TrackInformation  map[string]*TrackInformation
	ERAMInbox         *[]FlightPlanMessage            // The address of the overlying ERAM's message inbox.
	STARSInbox        map[string]*[]FlightPlanMessage // Other STARS Facilities' inboxes
	UnsupportedTracks []UnsupportedTrack
	SquawkCodePool    *av.SquawkCodePool
	HoldForRelease    []*av.Aircraft
}

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"`
}

type STARSFacilityAdaptation struct {
	AirspaceAwareness   []AirspaceAwareness              `json:"airspace_awareness"`
	ForceQLToSelf       bool                             `json:"force_ql_self"`
	AllowLongScratchpad bool                             `json:"allow_long_scratchpad"`
	VideoMapNames       []string                         `json:"stars_maps"`
	VideoMapLabels      map[string]string                `json:"map_labels"`
	ControllerConfigs   map[string]STARSControllerConfig `json:"controller_configs"`
	InhibitCAVolumes    []av.AirspaceVolume              `json:"inhibit_ca_volumes"`
	RadarSites          map[string]*av.RadarSite         `json:"radar_sites"`
	Center              math.Point2LL                    `json:"-"`
	CenterString        string                           `json:"center"`
	Range               float32                          `json:"range"`
	Scratchpads         map[string]string                `json:"scratchpads"`
	SignificantPoints   map[string]SignificantPoint      `json:"significant_points"`

	VideoMapFile      string                        `json:"video_map_file"`
	CoordinationFixes map[string]av.AdaptationFixes `json:"coordination_fixes"`
	SingleCharAIDs    map[string]string             `json:"single_char_aids"` // Char to airport
	BeaconBank        int                           `json:"beacon_bank"`
	KeepLDB           bool                          `json:"keep_ldb"`
	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"`
	} `json:"pdb"`
	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"`
	CoordinationLists []CoordinationList `json:"coordination_lists"`
}

type STARSFlightPlan struct {
	*av.FlightPlan
	FlightPlanType      int
	CoordinationTime    CoordinationTime
	CoordinationFix     string
	ContainedFacilities []string
	Altitude            string
	SP1                 string
	SP2                 string
	InitialController   string // For abbreviated FPs
}

type Scenario struct {
	SoloController      string                   `json:"solo_controller"`
	SplitConfigurations av.SplitConfigurationSet `json:"multi_controllers"`
	DefaultSplit        string                   `json:"default_split"`
	Wind                av.Wind                  `json:"wind"`
	VirtualControllers  []string                 `json:"controllers"`

	// Map from inbound flow names to a map from airport name to default rate,
	// with "overflights" a special case to denote overflights
	InboundFlowDefaultRates map[string]map[string]int `json:"inbound_rates"`
	// Temporary backwards compatibility
	ArrivalGroupDefaultRates map[string]map[string]int `json:"arrivals"`

	ApproachAirspace       []ControllerAirspaceVolume `json:"approach_airspace_volumes"`  // not in JSON
	DepartureAirspace      []ControllerAirspaceVolume `json:"departure_airspace_volumes"` // not in JSON
	ApproachAirspaceNames  []string                   `json:"approach_airspace"`
	DepartureAirspaceNames []string                   `json:"departure_airspace"`

	DepartureRunways []ScenarioGroupDepartureRunway `json:"departure_runways,omitempty"`
	ArrivalRunways   []ScenarioGroupArrivalRunway   `json:"arrival_runways,omitempty"`

	Center       math.Point2LL `json:"-"`
	CenterString string        `json:"center"`
	Range        float32       `json:"range"`
	DefaultMaps  []string      `json:"default_maps"`
}

type ScenarioGroup struct {
	TRACON           string                    `json:"tracon"`
	Name             string                    `json:"name"`
	Airports         map[string]*av.Airport    `json:"airports"`
	Fixes            map[string]math.Point2LL  `json:"-"`
	FixesStrings     util.OrderedMap           `json:"fixes"`
	Scenarios        map[string]*Scenario      `json:"scenarios"`
	DefaultScenario  string                    `json:"default_scenario"`
	ControlPositions map[string]*av.Controller `json:"control_positions"`
	Airspace         Airspace                  `json:"airspace"`
	InboundFlows     map[string]InboundFlow    `json:"inbound_flows"`

	// Temporary for the transition to inbound_flows
	ArrivalGroups map[string][]av.Arrival `json:"arrival_groups"`

	PrimaryAirport string `json:"primary_airport"`

	ReportingPointStrings []string            `json:"reporting_points"`
	ReportingPoints       []av.ReportingPoint // not in JSON

	NmPerLatitude           float32 // Always 60
	NmPerLongitude          float32 // Derived from Center
	MagneticVariation       float32
	MagneticAdjustment      float32                 `json:"magnetic_adjustment"`
	STARSFacilityAdaptation STARSFacilityAdaptation `json:"stars_config"`
}

type ScenarioGroupArrivalRunway struct {
	Airport string `json:"airport"`
	Runway  string `json:"runway"`
}

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

	ExitRoutes map[string]av.ExitRoute // copied from airport's  departure_routes
}

type Server struct {
	*util.RPCClient
	// contains filtered or unexported fields
}

type ServerController struct {
	Callsign string
	// contains filtered or unexported fields
}

type SetGlobalLeaderLineArgs struct {
	ControllerToken string
	Callsign        string
	Direction       *math.CardinalOrdinalDirection
}

type SetLaunchConfigArgs struct {
	ControllerToken string
	Config          LaunchConfig
}

type SetScratchpadArgs struct {
	ControllerToken string
	Callsign        string
	Scratchpad      string
}

type SetSimRateArgs struct {
	ControllerToken string
	Rate            float32
}

type SignOnResult struct {
	Configurations map[string]map[string]*Configuration
	RunningSims    map[string]*RemoteSim
}

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 {
	Name string

	ScenarioGroup string
	Scenario      string

	State *State

	SignOnPositions map[string]*av.Controller

	LaunchConfig LaunchConfig

	// For each airport, at what time we would like to launch a departure,
	// based on the airport's departure rate. The actual time an aircraft
	// is launched may be later, e.g. if we need longer for wake turbulence
	// separation, etc.
	NextDepartureLaunch map[string]time.Time
	// Map from airport to aircraft that are ready to go. The slice is
	// ordered according to the departure sequence.
	DeparturePool map[string][]DepartureAircraft
	// Index to track departing aircraft; we use this to make sure we don't
	// keep pushing an aircraft to the end of the queue.
	DepartureIndex map[string]int
	// Airport -> runway -> *DepartureAircraft (nil if none launched yet)
	LastDeparture map[string]map[string]*DepartureAircraft

	// Key is inbound flow group name
	NextInboundSpawn map[string]time.Time

	Handoffs map[string]Handoff
	// callsign -> "to" controller
	PointOuts map[string]map[string]PointOut

	TotalDepartures  int
	TotalArrivals    int
	TotalOverflights int

	ReportingPoints []av.ReportingPoint

	RequirePassword bool
	Password        string

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

	SimRate float32
	Paused  bool

	NextPushStart time.Time // both w.r.t. sim time
	PushEnd       time.Time
	// contains filtered or unexported fields
}

type SimBroadcastMessage struct {
	Password string
	Message  string
}

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

type SimScenarioConfiguration struct {
	SelectedController  string
	SelectedSplit       string
	SplitConfigurations av.SplitConfigurationSet
	PrimaryAirport      string

	Wind         av.Wind
	LaunchConfig LaunchConfig

	DepartureRunways []ScenarioGroupDepartureRunway
	ArrivalRunways   []ScenarioGroupArrivalRunway
}

type State struct {
	Aircraft    map[string]*av.Aircraft
	METAR       map[string]*av.METAR
	Controllers map[string]*av.Controller

	DepartureAirports map[string]*av.Airport
	ArrivalAirports   map[string]*av.Airport

	ERAMComputers *ERAMComputers

	TRACON                   string
	LaunchConfig             LaunchConfig
	PrimaryController        string
	MultiControllers         av.SplitConfiguration
	SimIsPaused              bool
	SimRate                  float32
	SimName                  string
	SimDescription           string
	SimTime                  time.Time
	MagneticVariation        float32
	NmPerLongitude           float32
	Airports                 map[string]*av.Airport
	Fixes                    map[string]math.Point2LL
	PrimaryAirport           string
	RadarSites               map[string]*av.RadarSite
	Center                   math.Point2LL
	Range                    float32
	Wind                     av.Wind
	Callsign                 string
	ScenarioDefaultVideoMaps []string
	ApproachAirspace         []ControllerAirspaceVolume
	DepartureAirspace        []ControllerAirspaceVolume
	DepartureRunways         []ScenarioGroupDepartureRunway
	ArrivalRunways           []ScenarioGroupArrivalRunway
	Scratchpads              map[string]string
	InboundFlows             map[string]InboundFlow
	TotalDepartures          int
	TotalArrivals            int
	TotalOverflights         int
	STARSFacilityAdaptation  STARSFacilityAdaptation

	ControllerVideoMaps        []av.VideoMap
	ControllerDefaultVideoMaps []string
	// contains filtered or unexported fields
}

type ToggleSPCArgs struct {
	ControllerToken string
	Callsign        string
	SPC             string
}

type TrackInformation struct {
	Identifier        string
	TrackOwner        string
	HandoffController string
	FlightPlan        *STARSFlightPlan
	PointOut          string
	PointOutHistory   []string
	RedirectedHandoff av.RedirectedHandoff
	SP1               string
	SP2               string
	AutoAssociateFP   bool // If it's white or not
}

type UnsupportedTrack struct {
	TrackLocation     math.Point2LL
	Owner             string
	HandoffController string
	FlightPlan        *STARSFlightPlan
}

type UploadPlanArgs struct {
	ControllerToken string
	Type            int
	Plan            *STARSFlightPlan
}

type WorldUpdate struct {
	Aircraft    map[string]*av.Aircraft
	Controllers map[string]*av.Controller
	Time        time.Time

	ERAMComputers *ERAMComputers

	LaunchConfig LaunchConfig

	SimIsPaused      bool
	SimRate          float32
	Events           []Event
	TotalDepartures  int
	TotalArrivals    int
	TotalOverflights int
}