Intercept of sunrise on an Airplane

Question

I want to calculate predicted Time of closest approach between an aircraft and Sunrise or Sunset keeping in mind:

Airplane Flying South-westbound as sunrise approaches Red line is the GreatCircle Track on airplane. Blue circle is the Airplane. moment of intersection with sunrise and the Airplane

1- sun Declination (latitude) and crossing Longitude is known , plus the radius of sunrise which is approx 5450 Nautical miles, so sunrise can be shown as a circle with known centre and radius.

2- I used 2D Vector code which did not work since Great circle Path can not be applies to XY plane.

2- The Airplane is flying on Great circle Track which is curved and Latitude change is not Linear, how can I use Airplane Speed as Velocity Vector if latitude change is not constant ?

 /// Va - Velocity of circle A.
     Va = new Vector2(450, 0);

I used c# code

    /// Calculate the time of closest approach of two moving circles.  Also determine if the circles collide.
    /// 
    /// Input:
    /// Pa - Position of circle A.
    /// Pb - Position of circle B.
    /// Va - Velocity of circle A.
    /// Vb - Velocity of circle B.
    /// Ra - Radius of circle A.
    /// Rb - Radius of circle B.

    // Set up the initial position, velocity, and size of the circles.
        Pa = new Vector2(150, 250);
        Pb = new Vector2(600, 400);
        Va = new Vector2(450, 0);
        Vb = new Vector2(-100, -250);
        Ra = 60;
        Rb = 30;


    /// Returns:
    /// collision - Returns True if a collision occured, else False.
    /// The method returns the time to impact if collision=true, else it returns the time of closest approach.
    public float TimeOfClosestApproach(Vector2 Pa, Vector2 Pb, Vector2 Va, Vector2 Vb, float Ra, float Rb, out bool collision)
    {
        Vector2 Pab = Pa - Pb;
        Vector2 Vab = Va - Vb;
        float a = Vector2.Dot(Vab, Vab);
        float b = 2 * Vector2.Dot(Pab, Vab);
        float c = Vector2.Dot(Pab, Pab) - (Ra + Rb) * (Ra + Rb);

        // The quadratic discriminant.
        float discriminant = b * b - 4 * a * c;

        // Case 1:
        // If the discriminant is negative, then there are no real roots, so there is no collision.  The time of
        // closest approach is then given by the average of the imaginary roots, which is:  t = -b / 2a
        float t;
        if (discriminant < 0)
        {
            t = -b / (2 * a);
            collision = false;
        }
        else
        {
            // Case 2 and 3:
            // If the discriminant is zero, then there is exactly one real root, meaning that the circles just grazed each other.  If the 
            // discriminant is positive, then there are two real roots, meaning that the circles penetrate each other.  In that case, the
            // smallest of the two roots is the initial time of impact.  We handle these two cases identically.
            float t0 = (-b + (float)Math.Sqrt(discriminant)) / (2 * a);
            float t1 = (-b - (float)Math.Sqrt(discriminant)) / (2 * a);
            t = Math.Min(t0, t1);

            // We also have to check if the time to impact is negative.  If it is negative, then that means that the collision
            // occured in the past.  Since we're only concerned about future events, we say that no collision occurs if t < 0.
            if (t < 0)
                collision = false;
            else
                collision = true;
        }

        // Finally, if the time is negative, then set it to zero, because, again, we want this function to respond only to future events.
        if (t < 0)
            t = 0;

        return t;
    }

I accept any answer in any language:

    JAVA , JS, Objective-C , Swift , C#.

All I am looking for is the Algorithm. and how to Represent the Airplane Speed as Velocity Vector2D or Vector3D.