sgp4.wai

// sgp4.wai

/// underlying structs and variants for errors
variant error-tle-what {
    bad-checksum,
    bad-length,
    bad-first-character,
    expected-float,
    expected-float-with-assumed-decimal-point,
    expected-integer,
    expected-space,
    expected-string,
    float-with-assumed-decimal-point-too-long,
    norad-id-mismatch,
    unknown-classification,
    from-yo-opt-failed,
    from-num-seconds-from-midnight-failed,
}

variant error-tle-line {
    line1,
    line2,
    both,
}

record out-of-range-epoch-eccentricity {
    eccentricity: float64,
}

record out-of-range-eccentricity {
    eccentricity: float64,
    t: float64,
}

record out-of-range-perturbed-eccentricity {
    eccentricity: float64,
    t: float64,
}

record negative-semi-latus-rectum {
    t: float64,
}

record tle {
    what: error-tle-what,
    line: error-tle-line,
    start: u32,
    end: u32,
}


/// main error variant
variant error {
    out-of-range-epoch-eccentricity(out-of-range-epoch-eccentricity),
    out-of-range-eccentricity(out-of-range-eccentricity),
    out-of-range-perturbed-eccentricity(out-of-range-perturbed-eccentricity),
    negative-brouwer-mean-motion,
    negative-kozai-mean-motion,
    negative-semi-latus-rectum(negative-semi-latus-rectum),
    tle(tle),
    json-parse(string)
}

record unix-timestamp {
    secs: s64, 
    nsecs: u32
}

enum classification {
    unclassified,
    classified,
    secret,
}

resource elements {
    static from-tle: func(object-name: option<string>, line1: string, line2: string) -> expected<elements,error>
    static from-json: func(json: string) -> expected<elements,error>
    epoch: func() -> float64
    epoch-afspc-compatibility-mode: func() -> float64
    get-object-name: func() -> option<string>
    get-international-designator: func() -> option<string>
    get-norad-id: func() -> u64
    get-classification: func() -> classification 
    get-datetime: func() -> unix-timestamp
    get-mean-motion-dot: func() -> float64
    get-mean-motion-ddot: func() -> float64
    get-drag-term: func() -> float64
    get-element-set-number: func() -> u64 
    get-inclination: func() -> float64 
    get-right-ascension: func() -> float64 
    get-eccentricity: func() -> float64 
    get-argument-of-perigee: func() -> float64 
    get-mean-anomaly: func() -> float64 
    get-mean-motion: func() -> float64 
    get-revolution-number: func() -> u64 
    get-ephemeris-type: func() -> u8
}


/// Geopotential Struct

record geopotential {
    ae: float64,
    ke: float64,
    j2: float64,
    j3: float64,
    j4: float64,
}

/// Orbit Struct
record orbit {
    inclination: float64,
    right-ascension: float64,
    eccentricity: float64,
    argument-of-perigee: float64,
    mean-anomaly: float64,
    mean-motion: float64,
}

orbit-from-kozai-elements: func(geopotential: geopotential,inclination: float64, right-ascension: float64, eccentricity: float64, argument-of-perigee: float64, mean-anomaly: float64, kozai-mean-motion: float64) -> expected<orbit,error>

/// Prediction Struct
record prediction {
    position: tuple<float64,float64,float64>,
    velocity: tuple<float64,float64,float64>,
}


/// Constant WGS72
wgs72: func() -> geopotential

/// Constant WGS84
wgs84: func() -> geopotential

afspc-epoch-to-sidereal-time: func(epoch: float64) -> float64
iau-epoch-to-sidereal-time: func(epoch: float64) -> float64
parse2les: func(tles: string) -> expected<list<elements>,error>
parse3les: func(tles: string) -> expected<list<elements>,error>


// get the t from resonanceState as all the fields are private and doeesn't allow automatic initialization
resource resonance-state {
    t: func()->float64
}


enum epoch-to-sidereal-time-algorithm {
  afspc,
  iau,
}

/// implmenetation for Constants
resource constants {
    static new: func(geopotential: geopotential, epoch-to-sidereal-time: epoch-to-sidereal-time-algorithm, epoch: float64, drag-item: float64, orbit0: orbit) -> expected<constants, error>
    static from-elements: func(elements: elements) -> expected<constants, error>
    static from-elements-afspc-compatibility-mode: func(elements: elements) -> expected<constants, error>
    initial-state: func() -> option<resonance-state>
    propagate-from-state: func(t: float64, state: option<resonance-state>, afspc-compatibility-mode: bool) -> expected<prediction, error>
    propagate: func(t: float64) -> expected<prediction, error>
    propagate-afspc-compatibility-mode: func(t: float64) -> expected<prediction, error>
}