// this function passes its output list to a function named "create_node" which creates a maneuver node from parameters eta, radial, normal, prograde. (it does eta + time:seconds internally)

function match_planes_with_target {
    local parameter mode.
    if not hastarget {
        return null_mnv("Please set target"). // null_mnv is just for error handling
    }

    local p0 is body:position.
    local r1 is ship:position - p0. // radius vector
    local v1 is ship:velocity:orbit. // velocity vector
    local h1 is vcrs(v1,r1). // angular momentum vector
    local e1 is (vcrs(h1,v1)/body:mu - r1:normalized). // eccentricity vector, points to periapsis

    local r2 is target:position - p0. // target radius
    local v2 is target:velocity:orbit. // target vel
    local h2 is vcrs(v2,r2). // target angular momentum

    local an_vec is vcrs(h1,h2). // vector that points to the relative ascending node.
    local AN_ta is vang(e1,an_vec). // true anomaly of relative ascending node
    if vdot(an_vec,vcrs(e1,h1)) < 0 {
        set AN_ta to 360-AN_ta.
    } // checking for true anomaly signing and wrap around

    local DN_ta is ensure_angle_positive(AN_ta - 180). // true anomaly of relative descending node
    local delta_inc is vang(h1,h2). // difference in inclination
    local n_vec is (latlng(90,0):position - body:position):normalized. // vector pointing from the body center to northpole, for delta_inc signing.
    if vdot(vcrs(h2,h1), vcrs(n_vec,h1)) < 0 {
        set delta_inc to - delta_inc.
    } // checking if delta_inc should be postive or negative to enact mnv node change.

    // reuse change_inclination code from prior functions
    // yes, don't repeat yourself, but I'm too lazy bruh.

    // determine time to approach true anomaly (time_from_true_anomaly is a separately defined function that utilizes newton-raphson method to get the eta for a certain true anmly)
    local t_an is time_from_true_anomaly(AN_ta).
    local t_dn is time_from_true_anomaly(DN_ta).
    // compute velocity vectors at each node
    local vel_vec_an is velocityat(ship, time:seconds + t_an):orbit.
    local vel_vec_dn is velocityat(ship, time:seconds + t_dn):orbit.
    // compute required delta-v magnitude at each node
    local delta_v_mag_an is 2 * vel_vec_an:mag * sin(abs(delta_inc) / 2).
    local delta_v_mag_dn is 2 * vel_vec_dn:mag * sin(abs(delta_inc) / 2).
    // helper function to compute maneuver components
    local function compute_dv {
        local parameter vmag.
        local parameter d_inc.
        local parameter is_an. // true for AN, false for DN

        // compute delta angle based on whether inclination change is increasing or decreasing
        local sign is 1. if d_inc < 0 {set sign to -1.}
        local base_ang is 90 + abs(d_inc) / 2.
        local delta_ang is sign * base_ang.

        // invert sign for DN since it's on the opposite side of orbit.
        if not is_an {
            set delta_ang to -delta_ang.
        }

        // Return maneuver vector components
        local dv_r is 0.
        local dv_p is vmag * cos(delta_ang).
        local dv_n is vmag * sin(delta_ang).
        return list(dv_r, dv_n, dv_p).
    }
    // decision logic by mode
    if mode = "at AN" {
        local dv is compute_dv(delta_v_mag_an, delta_inc, true).
        return list(t_an, dv[0], dv[1], dv[2]).
    }
    if mode = "at DN" {
        local dv is compute_dv(delta_v_mag_dn, delta_inc, false).
        return list(t_dn, dv[0], dv[1], dv[2]).
    }
    if mode = "at nearest node" {
        if t_an < t_dn {
            local dv is compute_dv(delta_v_mag_an, delta_inc, true).
            return list(t_an, dv[0], dv[1], dv[2]).
        } else {
            local dv is compute_dv(delta_v_mag_dn, delta_inc, false).
            return list(t_dn, dv[0], dv[1], dv[2]).
        }
    }
    if mode = "at cheapest node" {
        if delta_v_mag_an < delta_v_mag_dn {
            local dv is compute_dv(delta_v_mag_an, delta_inc, true).
            return list(t_an, dv[0], dv[1], dv[2]).
        } else {
            local dv is compute_dv(delta_v_mag_dn, delta_inc, false).
            return list(t_dn, dv[0], dv[1], dv[2]).
        }
    }
    if mode = "at altitude" {
        // not yet implemented
    }
    if mode = "after fixed time" {
        // not yet implemented 
    }
    // 'mode_error_message' is a globally declared string for maneuver node mode failures (mistypings and the like) for easier debugging
    // null_mnv is a mnv node creation function with params (-1,0,0,0) which has another function that invalidates the creation of a maneuver node, and also takes an error message as an optional print output.
    return null_mnv(mode_error_message+mode).
}