using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CoordinateSharp
{
    //CURRENT ALTITUDE IS SET CONSTANT AT 100M. POSSIBLY NEED TO ADJUST TO ALLOW USER PASS.
    //Altitude adjustments appear to have minimal effect on eclipse timing. These were mainly used
    //to signify eclipses that had already started during rise and set times on the NASA calculator

    //SOME TIMES AND ALTS WERE RETURNED WITH COLOR AND STYLING. DETERMINE WHY AND ADJUST VALUE AS REQUIRED. SEARCH "WAS ITALIC".

    //ELLIPSOID ADJUSTMENT
    //6378140.0 Ellipsoid is used in the NASA Calculator
    //WGS84 Ellipsoid is 6378137.0. Adjustments to the ellipsoid appear to effect eclipse seconds in fractions.
    //This can be modified if need to allow users to pass custom number with the Coordinate SetDatum() functions.

    //CURRENT RANGE 1601-2600.
    internal class SolarEclipseCalc
    {                             
        public static List<List<string>> CalculateSolarEclipse(DateTime d, double latRad, double longRad)
        {
            return Calculate(d, latRad, longRad, null);
        }
        public static List<SolarEclipseDetails> CalculateSolarEclipse(DateTime d, double latRad, double longRad, double[] events)
        {
            List<List<string>> evs = Calculate(d, latRad, longRad, events);
            List<SolarEclipseDetails> deetsList = new List<SolarEclipseDetails>();
            foreach(List<string> ls in evs)
            {
                SolarEclipseDetails deets = new SolarEclipseDetails(ls);
                deetsList.Add(deets);
            }
            return deetsList;
        }
        public static List<List<string>> CalculateSolarEclipse(DateTime d, Coordinate coord)
        {
            return Calculate(d, coord.Latitude.ToRadians(), coord.Longitude.ToRadians(), null);
        }

        private static List<List<string>> Calculate(DateTime d, double latRad, double longRad, double[] ev)
        {
            //Declare storage arrays
            double[] obsvconst = new double[7];
            double[] mid = new double[41];//Check index to see if array needs to be this size
            double[] c1 = new double[41];
            double[] c2 = new double[41];
            double[] c3 = new double[41];
            double[] c4 = new double[41];

        List<List<string>> events = new List<List<string>>();
            double[] el;
            if (ev == null)
            {
                el = Eclipse.SolarData.SolarDateData(d);//Get 100 year solar data;
            }
            else
            {
                el = ev;
            }
           
            events = new List<List<string>>();
            ReadData(latRad, longRad, obsvconst);
            for (int i = 0; i < el.Length; i += 28)
            {
                obsvconst[6] = i;
                GetAll(el, obsvconst, mid,c1,c2,c3,c4);
                // Is there an event...
                if (mid[39] > 0)
                {
                    List<string> values = new List<string>();             
                    values.Add(GetDate(el, mid, obsvconst));
                    if (mid[39] == 1)
                    {
                        values.Add("P");
                    }
                    else if (mid[39] == 2)
                    {
                        values.Add("A");
                    }
                    else
                    {
                        values.Add("T");
                    }

                    // Partial eclipse start
                    if (c1[40] == 4)
                    {
                        values.Add("-");
                        values.Add(" ");
                    }
                    else
                    {
                        // Partial eclipse start time
                        values.Add(GetTime(el, c1, obsvconst));
                        values.Add(GetAlt(c1));
                    }
                    // Central eclipse time                
                    if ((mid[39] > 1) && (c2[40] != 4))
                    {
                        values.Add(GetTime(el, c2, obsvconst));
                    }
                    else
                    {
                        values.Add("-");
                    }

                    //Mid Time
                    values.Add(GetTime(el, mid, obsvconst));

                    // Maximum eclipse alt                  
                    values.Add(GetAlt(mid));

                    // Maximum eclipse azi                    
                    values.Add(GetAzi(mid));
                    // Central eclipse ends
                    if ((mid[39] > 1) && (c3[40] != 4))
                    {
                        values.Add(GetTime(el, c3, obsvconst));
                    }
                    else
                    {
                        values.Add("-");
                    }
                    // Partial eclipse ends
                    if (c4[40] == 4)
                    {
                        values.Add("-");
                        values.Add(" ");
                    }
                    else
                    {
                        // Partial eclipse ends
                        values.Add(GetTime(el, c4, obsvconst));

                        // ... sun alt
                        values.Add(GetAlt(c4));
                    }
                    // Eclipse magnitude
                    values.Add(GetMagnitude(mid));


                    // Coverage                
                    values.Add(GetCoverage(mid));

                    // Central duration                   
                    if (mid[39] > 1)
                    {
                        values.Add(GetDuration(mid,c2,c3));
                    }
                    else
                    {
                        values.Add("-");
                    }
                   
                    events.Add(values);
                }
            }
            return events;
        }
        //Populates the obsvcont array
        private static  void ReadData(double latRad, double longRad, double[] obsvconst)
        {
            // Get the latitude
            obsvconst[0] = latRad;

            //// Get the longitude
            obsvconst[1] = -1 * longRad; //PASS REVERSE RADIAN.

            // Get the altitude
            obsvconst[2] = 100; //CHANGE TO ALLOW USER TO PASS.

            // Get the time zone
            obsvconst[3] = 0; //ALWAYS GMT

            // Get the observer's geocentric position
            double tmp = Math.Atan(0.99664719 * Math.Tan(obsvconst[0]));
            obsvconst[4] = 0.99664719 * Math.Sin(tmp) + (obsvconst[2] / 6378140.0) * Math.Sin(obsvconst[0]);
            obsvconst[5] = Math.Cos(tmp) + (obsvconst[2] / 6378140.0 * Math.Cos(obsvconst[0]));
          
        }
        // Populate the c1, c2, mid, c3 and c4 arrays
        private static  void GetAll(double[] elements, double[] obsvconst, double[] mid, double[] c1, double[] c2,double[] c3, double[] c4)
        {
            GetMid(elements, obsvconst, mid);
            MidObservational(obsvconst, mid);
            if (mid[37] > 0.0)
            {
                Getc1c4(elements, obsvconst, mid,c1,c2,c3,c4);
                if ((mid[36] < mid[29]) || (mid[36] < -mid[29]))
                {
                    Getc2c3(elements, obsvconst, mid,c2,c3);
                    if (mid[29] < 0.0)
                    {
                        mid[39] = 3; // Total eclipse
                    }
                    else
                    {
                        mid[39] = 2; // Annular eclipse
                    }
                    Observational(c1, obsvconst, mid);
                    Observational(c2, obsvconst, mid);
                    Observational(c3, obsvconst, mid);
                    Observational(c4, obsvconst, mid);
                    c2[36] = 999.9;
                    c3[36] = 999.9;
                    // Calculate how much of the eclipse is above the horizon
                    double pattern = 0;
                    if (c1[40] == 0) { pattern += 10000; }
                    if (c2[40] == 0) { pattern += 1000; }
                    if (mid[40] == 0) { pattern += 100; }
                    if (c3[40] == 0) { pattern += 10; }
                    if (c4[40] == 0) { pattern += 1; }
                    // Now, time to make sure that all my Observational[39] and Observational[40] are OK
                    if (pattern == 11110)
                    {
                        GetSunset(elements, c4, obsvconst);
                        Observational(c4, obsvconst, mid);
                        c4[40] = 3;
                    }
                    else if (pattern == 11100)
                    {
                        GetSunset(elements, c3, obsvconst);
                        Observational(c3, obsvconst, mid);
                        c3[40] = 3;
                        CopyCircumstances(c3, c4);
                    }
                    else if (pattern == 11000)
                    {
                        c3[40] = 4;
                        GetSunset(elements, mid, obsvconst);
                        MidObservational(obsvconst, mid);
                        mid[40] = 3;
                        CopyCircumstances(mid, c4);
                    }
                    else if (pattern == 10000)
                    {
                        mid[39] = 1;
                        GetSunset(elements, mid, obsvconst);
                        MidObservational(obsvconst, mid);
                        mid[40] = 3;
                        CopyCircumstances(mid, c4);
                    }
                    else if (pattern == 1111)
                    {
                        GetSunrise(elements, c1, obsvconst);
                        Observational(c1, obsvconst, mid);
                        c1[40] = 2;
                    }
                    else if (pattern == 111)
                    {
                        GetSunrise(elements, c2, obsvconst);
                        Observational(c2, obsvconst, mid);
                        c2[40] = 2;
                        CopyCircumstances(c2, c1);
                    }
                    else if (pattern == 11)
                    {
                        c2[40] = 4;
                        GetSunrise(elements, mid, obsvconst);
                        MidObservational(obsvconst, mid);
                        mid[40] = 2;
                        CopyCircumstances(mid, c1);
                    }
                    else if (pattern == 1)
                    {
                        mid[39] = 1;
                        GetSunrise(elements, mid, obsvconst);
                        MidObservational(obsvconst, mid);
                        mid[40] = 2;
                        CopyCircumstances(mid, c1);
                    }
                    else if (pattern == 0)
                    {
                        mid[39] = 0;
                    }
                    // There are other patterns, but those are the only ones we're covering!
                }
                else
                {
                    mid[39] = 1; // Partial eclipse
                    double pattern = 0;
                    Observational(c1, obsvconst, mid);
                    Observational(c4, obsvconst, mid);
                    if (c1[40] == 0) { pattern += 100; }
                    if (mid[40] == 0) { pattern += 10; }
                    if (c4[40] == 0) { pattern += 1; }
                    if (pattern == 110)
                    {
                        GetSunset(elements, c4, obsvconst);
                        Observational(c4, obsvconst, mid);
                        c4[40] = 3;
                    }
                    else if (pattern == 100)
                    {
                        GetSunset(elements, mid, obsvconst);
                        MidObservational(obsvconst, mid);
                        mid[40] = 3;
                        CopyCircumstances(mid, c4);
                    }
                    else if (pattern == 11)
                    {
                        GetSunrise(elements, c1, obsvconst);
                        Observational(c1, obsvconst, mid);
                        c1[40] = 2;
                    }
                    else if (pattern == 1)
                    {
                        GetSunrise(elements, mid, obsvconst);
                        MidObservational(obsvconst, mid);
                        mid[40] = 2;
                        CopyCircumstances(mid, c1);
                    }
                    else if (pattern == 0)
                    {
                        mid[39] = 0;
                    }
                    // There are other patterns, but those are the only ones we're covering!
                }
            }
            else
            {
                mid[39] = 0; // No eclipse
            }
            // Magnitude for total and annular eclipse is moon/sun ratio
            if ((mid[39] == 2) || (mid[39] == 3))
            {
                mid[37] = mid[38];
            }
        }
        // Calculate mid eclipse
        private static  void GetMid(double[] elements, double[] obsvconst, double[] mid)
        {
            double iter, tmp;

            mid[0] = 0;
            mid[1] = 0.0;
            iter = 0;
            tmp = 1.0;
            TimeLocDependent(elements, mid, obsvconst);
            while (((tmp > 0.000001) || (tmp < -0.000001)) && (iter < 50))
            {
                tmp = (mid[24] * mid[26] + mid[25] * mid[27]) / mid[30];
                mid[1] = mid[1] - tmp;
                iter++;
                TimeLocDependent(elements, mid, obsvconst);
            }
        }
        // Populate the circumstances array with the time and location dependent circumstances
        private static  double[] TimeLocDependent(double[] elements, double[] circumstances, double[] obsvconst)
        {
            double index, type;

            TimeDependent(elements, circumstances, obsvconst);
            index = obsvconst[6];
            // Calculate h, sin h, cos h
            circumstances[16] = circumstances[7] - obsvconst[1] - (elements[(int)index + 5] / 13713.44);
            circumstances[17] = Math.Sin(circumstances[16]);
            circumstances[18] = Math.Cos(circumstances[16]);
            // Calculate xi
            circumstances[19] = obsvconst[5] * circumstances[17];
            // Calculate eta
            circumstances[20] = obsvconst[4] * circumstances[6] - obsvconst[5] * circumstances[18] * circumstances[5];
            // Calculate zeta
            circumstances[21] = obsvconst[4] * circumstances[5] + obsvconst[5] * circumstances[18] * circumstances[6];
            // Calculate dxi
            circumstances[22] = circumstances[13] * obsvconst[5] * circumstances[18];
            // Calculate deta
            circumstances[23] = circumstances[13] * circumstances[19] * circumstances[5] - circumstances[21] * circumstances[12];
            // Calculate u
            circumstances[24] = circumstances[2] - circumstances[19];
            // Calculate v
            circumstances[25] = circumstances[3] - circumstances[20];
            // Calculate a
            circumstances[26] = circumstances[10] - circumstances[22];
            // Calculate b
            circumstances[27] = circumstances[11] - circumstances[23];
            // Calculate l1'
            type = circumstances[0];
            if ((type == -2) || (type == 0) || (type == 2))
            {
                circumstances[28] = circumstances[8] - circumstances[21] * elements[26 + (int)index];
            }
            // Calculate l2'
            if ((type == -1) || (type == 0) || (type == 1))
            {
                circumstances[29] = circumstances[9] - circumstances[21] * elements[27 + (int)index];
            }
            // Calculate n^2
            circumstances[30] = circumstances[26] * circumstances[26] + circumstances[27] * circumstances[27];
            return circumstances;
        }
        // Populate the circumstances array with the time-only dependent circumstances (x, y, d, m, ...)
        private static  double[] TimeDependent(double[] elements, double[] circumstances, double[] obsvconst)
        {
            double type, t, ans;

            t = circumstances[1];
            int index = (int)obsvconst[6];
            // Calculate x
            ans = elements[9 + index] * t + elements[8 + index];
            ans = ans * t + elements[7 + index];
            ans = ans * t + elements[6 + index];
            circumstances[2] = ans;
            // Calculate dx
            ans = 3.0 * elements[9 + index] * t + 2.0 * elements[8 + index];
            ans = ans * t + elements[7 + index];
            circumstances[10] = ans;
            // Calculate y
            ans = elements[13 + index] * t + elements[12 + index];
            ans = ans * t + elements[11 + index];
            ans = ans * t + elements[10 + index];
            circumstances[3] = ans;
            // Calculate dy
            ans = 3.0 * elements[13 + index] * t + 2.0 * elements[12 + index];
            ans = ans * t + elements[11 + index];
            circumstances[11] = ans;
            // Calculate d
            ans = elements[16 + index] * t + elements[15 + index];
            ans = ans * t + elements[14 + index];
            ans = ans * Math.PI / 180.0;
            circumstances[4] = ans;
            // sin d and cos d
            circumstances[5] = Math.Sin(ans);
            circumstances[6] = Math.Cos(ans);
            // Calculate dd
            ans = 2.0 * elements[16 + index] * t + elements[15 + index];
            ans = ans * Math.PI / 180.0;
            circumstances[12] = ans;
            // Calculate m
            ans = elements[19 + index] * t + elements[18 + index];
            ans = ans * t + elements[17 + index];
            if (ans >= 360.0)
            {
                ans = ans - 360.0;
            }
            ans = ans * Math.PI / 180.0;
            circumstances[7] = ans;
            // Calculate dm
            ans = 2.0 * elements[19 + index] * t + elements[18 + index];
            ans = ans * Math.PI / 180.0;
            circumstances[13] = ans;
            // Calculate l1 and dl1
            type = circumstances[0];
            if ((type == -2) || (type == 0) || (type == 2))
            {
                ans = elements[22 + index] * t + elements[21 + index];
                ans = ans * t + elements[20 + index];
                circumstances[8] = ans;
                circumstances[14] = 2.0 * elements[22 + index] * t + elements[21 + index];
            }
            // Calculate l2 and dl2
            if ((type == -1) || (type == 0) || (type == 1))
            {
                ans = elements[25 + index] * t + elements[24 + index];
                ans = ans * t + elements[23 + index];
                circumstances[9] = ans;
                circumstances[15] = 2.0 * elements[25 + index] * t + elements[24 + index];
            }
            return circumstances;
        }
        // Get the observational circumstances for mid eclipse
        private static  void MidObservational(double[] obsvconst, double[] mid)
        {
            Observational(mid, obsvconst, mid);
            // Calculate m, magnitude and moon/sun
            mid[36] = Math.Sqrt(mid[24] * mid[24] + mid[25] * mid[25]);
            mid[37] = (mid[28] - mid[36]) / (mid[28] + mid[29]);
            mid[38] = (mid[28] - mid[29]) / (mid[28] + mid[29]);
        }
        // Get the observational circumstances
        private static  void Observational(double[] circumstances, double[] obsvconst, double[] mid)
        {
            double contacttype, coslat, sinlat;

            // We are looking at an "external" contact UNLESS this is a total eclipse AND we are looking at
            // c2 or c3, in which case it is an INTERNAL contact! Note that if we are looking at mid eclipse,
            // then we may not have determined the type of eclipse (mid[39]) just yet!
            if (circumstances[0] == 0)
            {
                contacttype = 1.0;
            }
            else
            {
                if ((mid[39] == 3) && ((circumstances[0] == -1) || (circumstances[0] == 1)))
                {
                    contacttype = -1.0;
                }
                else
                {
                    contacttype = 1.0;
                }
            }
            // Calculate p
            circumstances[31] = Math.Atan2(contacttype * circumstances[24], contacttype * circumstances[25]);
            // Calculate alt
            sinlat = Math.Sin(obsvconst[0]);
            coslat = Math.Cos(obsvconst[0]);
            circumstances[32] = Math.Asin(circumstances[5] * sinlat + circumstances[6] * coslat * circumstances[18]);
            // Calculate q
            circumstances[33] = Math.Asin(coslat * circumstances[17] / Math.Cos(circumstances[32]));
            if (circumstances[20] < 0.0)
            {
                circumstances[33] = Math.PI - circumstances[33];
            }
            // Calculate v
            circumstances[34] = circumstances[31] - circumstances[33];
            // Calculate azi
            circumstances[35] = Math.Atan2(-1.0 * circumstances[17] * circumstances[6], circumstances[5] * coslat - circumstances[18] * sinlat * circumstances[6]);
            // Calculate visibility
            if (circumstances[32] > -0.00524)
            {
                circumstances[40] = 0;
            }
            else
            {
                circumstances[40] = 1;
            }
        }
        // Get C1 and C4 data
        //   Entry conditions -
        //   1. The mid array must be populated
        //   2. The magnitude at mid eclipse must be > 0.0
        private static  void Getc1c4(double[] elements, double[] obsvconst, double[] mid, double[] c1, double[] c2, double[] c3, double[] c4)
        {
            double tmp, n;

            n = Math.Sqrt(mid[30]);
            tmp = mid[26] * mid[25] - mid[24] * mid[27];
            tmp = tmp / n / mid[28];
            tmp = Math.Sqrt(1.0 - tmp * tmp) * mid[28] / n;
            c1[0] = -2;
            c4[0] = 2;
            c1[1] = mid[1] - tmp;
            c4[1] = mid[1] + tmp;
            c1c4iterate(elements, c1, obsvconst);
            c1c4iterate(elements, c4, obsvconst);
        }
        // Iterate on C1 or C4
        private static  double[] c1c4iterate(double[] elements, double[] circumstances, double[] obsvconst)
        {
            double sign, iter, tmp, n;

            TimeLocDependent(elements, circumstances, obsvconst);
            if (circumstances[0] < 0)
            {
                sign = -1.0;
            }
            else
            {
                sign = 1.0;
            }
            tmp = 1.0;
            iter = 0;
            while (((tmp > 0.000001) || (tmp < -0.000001)) && (iter < 50))
            {
                n = Math.Sqrt(circumstances[30]);
                tmp = circumstances[26] * circumstances[25] - circumstances[24] * circumstances[27];
                tmp = tmp / n / circumstances[28];
                tmp = sign * Math.Sqrt(1.0 - tmp * tmp) * circumstances[28] / n;
                tmp = (circumstances[24] * circumstances[26] + circumstances[25] * circumstances[27]) / circumstances[30] - tmp;
                circumstances[1] = circumstances[1] - tmp;
                TimeLocDependent(elements, circumstances, obsvconst);
                iter++;
            }
            return circumstances;
        }
        // Get C2 and C3 data
        //   Entry conditions -
        //   1. The mid array must be populated
        //   2. There must be either a total or annular eclipse at the location!
        private static void Getc2c3(double[] elements, double[] obsvconst, double[] mid, double[] c2, double[] c3)
        {
            double tmp, n;

            n = Math.Sqrt(mid[30]);
            tmp = mid[26] * mid[25] - mid[24] * mid[27];
            tmp = tmp / n / mid[29];
            tmp = Math.Sqrt(1.0 - tmp * tmp) * mid[29] / n;
            c2[0] = -1;
            c3[0] = 1;
            if (mid[29] < 0.0)
            {
                c2[1] = mid[1] + tmp;
                c3[1] = mid[1] - tmp;
            }
            else
            {
                c2[1] = mid[1] - tmp;
                c3[1] = mid[1] + tmp;
            }
            c2c3iterate(elements, c2, obsvconst, mid);
            c2c3iterate(elements, c3, obsvconst, mid);
        }
        // Iterate on C2 or C3
        private static  double[] c2c3iterate(double[] elements, double[] circumstances, double[] obsvconst, double[] mid)
        {
            double sign, iter, tmp, n;

            TimeLocDependent(elements, circumstances, obsvconst);
            if (circumstances[0] < 0)
            {
                sign = -1.0;
            }
            else
            {
                sign = 1.0;
            }
            if (mid[29] < 0.0)
            {
                sign = -sign;
            }
            tmp = 1.0;
            iter = 0;
            while (((tmp > 0.000001) || (tmp < -0.000001)) && (iter < 50))
            {
                n = Math.Sqrt(circumstances[30]);
                tmp = circumstances[26] * circumstances[25] - circumstances[24] * circumstances[27];
                tmp = tmp / n / circumstances[29];
                tmp = sign * Math.Sqrt(1.0 - tmp * tmp) * circumstances[29] / n;
                tmp = (circumstances[24] * circumstances[26] + circumstances[25] * circumstances[27]) / circumstances[30] - tmp;
                circumstances[1] = circumstances[1] - tmp;
                TimeLocDependent(elements, circumstances, obsvconst);
                iter++;
            }
            return circumstances;
        }
        // Get the date of an event
        private static string GetDate(double[] elements, double[] circumstances, double[] obsvconst)
        {
            string[] month = new string[] { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
            double t, jd, a, b, c, d, e, index;
            string ans = "";
            index = obsvconst[6];
            // Calculate the JD for noon (TDT) the day before the day that contains T0
            jd = Math.Floor(elements[(int)index] - (elements[1 + (int)index] / 24.0));
            // Calculate the local time (ie the offset in hours since midnight TDT on the day containing T0).
            t = circumstances[1] + elements[1 + (int)index] - obsvconst[3] - (elements[4 + (int)index] - 0.5) / 3600.0;
            if (t < 0.0)
            {
                jd--;
            }
            if (t >= 24.0)
            {
                jd++;
            }
            if (jd >= 2299160.0)
            {
                a = Math.Floor((jd - 1867216.25) / 36524.25);
                a = jd + 1 + a - Math.Floor(a / 4.0);
            }
            else
            {
                a = jd;
            }
            b = a + 1525.0;
            c = Math.Floor((b - 122.1) / 365.25);
            d = Math.Floor(365.25 * c);
            e = Math.Floor((b - d) / 30.6001);
            d = b - d - Math.Floor(30.6001 * e);
            if (e < 13.5)
            {
                e = e - 1;
            }
            else
            {
                e = e - 13;
            }
            double year;
            if (e > 2.5)
            {
                ans = c - 4716 + "-";
                year = c - 4716;
            }
            else
            {
                ans = c - 4715 + "-";
                year = c - 4715;
            }
            string m = month[(int)e - 1];
            ans += m + "-";
            if (d < 10)
            {
                ans = ans + "0";
            }
           
            ans = ans + d;
            //Leap Year Integrity Check

            if(m  =="Feb" && d ==29 && !DateTime.IsLeapYear((int)year))
            {
                ans = year.ToString() + "-Mar-01";
            }
            return ans;
        }
        // Calculate the time of sunset
        private static  void GetSunset(double[] elements, double[] circumstances, double[] obsvconst)
        {
            GetSunriset(elements, circumstances, 1.0, obsvconst);
        }
        // Calculate the time of sunrise
        private static  void GetSunrise(double[] elements, double[] circumstances, double[] obsvconst)
        {
            GetSunriset(elements, circumstances, -1.0, obsvconst);
        }
        // Calculate the time of sunrise or sunset
        private static  void GetSunriset(double[] elements, double[] circumstances, double riset, double[] obsvconst)
        {
            double h0, diff, iter;

            diff = 1.0;
            iter = 0;
            while ((diff > 0.00001) || (diff < -0.00001))
            {
                iter++;
                if (iter == 4) { return; }
                h0 = Math.Acos((Math.Sin(-0.00524) - Math.Sin(obsvconst[0]) * circumstances[5]) / Math.Cos(obsvconst[0]) / circumstances[6]);
                diff = (riset * h0 - circumstances[16]) / circumstances[13];
                while (diff >= 12.0) { diff -= 24.0; }
                while (diff <= -12.0) { diff += 24.0; }
                circumstances[1] += diff;
                TimeLocDependent(elements, circumstances, obsvconst);
            }
        }
        // Copy a set of circumstances
        private static  void CopyCircumstances(double[] circumstancesfrom, double[] circumstancesto)
        {
            for (int i = 1; i < 41; i++)
            {
                circumstancesto[i] = circumstancesfrom[i];
            }
        }
        // Get the local time of an event
        private static  string GetTime(double[] elements, double[] circumstances, double[] obsvconst)
        {
            string ans = "";
            int index = (int)obsvconst[6];
            double t = circumstances[1] + elements[1 + index] - obsvconst[3] - (elements[4 + index] - 0.5) / 3600.0;
            if (t < 0.0)
            {
                t = t + 24.0;
            }
            if (t >= 24.0)
            {
                t = t - 24.0;
            }
            if (t < 10.0)
            {
                ans = ans + "0";
            }
            ans = ans + Math.Floor(t) + ":";
            t = (t * 60.0) - 60.0 * Math.Floor(t);
            if (t < 10.0)
            {
                ans = ans + "0";
            }
            ans = ans + Math.Floor(t);
            if (circumstances[40] <= 1)
            { // not sunrise or sunset
                ans = ans + ":";
                t = (t * 60.0) - 60.0 * Math.Floor(t);
                if (t < 10.0)
                {
                    ans = ans + "0";
                }
                ans = ans + Math.Floor(t);
            }
            if (circumstances[40] == 1)
            {
                //WAS ITALIC
                return ans;
            }
            else if (circumstances[40] == 2)
            {
                //Rise (CHANGED FROM NASA CALC THE INDICATES (r) WITH STRING, INVESTIGATE REMOVAL)
                return ans;
            }
            else if (circumstances[40] == 3)
            {
                //Set (CHANGED FROM NASA CALC THE INDICATES (s) WITH STRING, INVESTIGATE REMOVAL)
                return ans;
            }
            else
            {
                return ans;
            }
        }
        // Get the altitude
        private static  string GetAlt(double[] circumstances)
        {
            double t;
            string ans = "";

            if (circumstances[40] == 2)
            {
                return "0(r)";
            }
            if (circumstances[40] == 3)
            {
                return "0(s)";
            }
            if ((circumstances[32] < 0.0) && (circumstances[32] >= -0.00524))
            {
                // Crude correction for refraction (and for consistency's sake)
                t = 0.0;
            }
            else
            {
                t = circumstances[32] * 180.0 / Math.PI;
            }
            if (t < 0.0)
            {
                ans = "-";
                t = -t;
            }
            else
            {
                ans = "";
            }
            t = Math.Floor(t + 0.5);
            if (t < 10.0)
            {
                ans = ans + "0";
            }
            ans = ans + t;
            if (circumstances[40] == 1)
            {
                //WAS ITALIC
                return ans;
            }
            else
            {
                return ans;
            }
        }
        // Get the azimuth
        private static  string GetAzi(double[] circumstances)
        {
            string ans = "";
            double t = circumstances[35] * 180.0 / Math.PI;
            if (t < 0.0)
            {
                t = t + 360.0;
            }
            if (t >= 360.0)
            {
                t = t - 360.0;
            }
            t = Math.Floor(t + 0.5);
            if (t < 100.0)
            {
                ans = ans + "0";
            }
            if (t < 10.0)
            {
                ans = ans + "0";
            }
            ans = ans + t;
            if (circumstances[40] == 1)
            {
                //WAS ITALIC
                return ans;
            }
            else
            {
                return ans;
            }
        }
        // Get the magnitude
        private static  string GetMagnitude(double[] mid)
        {
            double a = Math.Floor(1000.0 * mid[37] + 0.5) / 1000.0;
            string ans = a.ToString();
            if (mid[40] == 1)
            {
                return ans;
            }
            if (mid[40] == 2)
            {
                ans = a.ToString() + "(r)";
            }
            if (mid[40] == 3)
            {
                ans = a.ToString() + "(s)";
            }
            return ans;
        }
        // Get the coverage
        private static  string GetCoverage(double[] mid)
        {
            double a=0, b, c;
            string ans = "";
            if (mid[37] <= 0.0)
            {
                ans = "0.0";
            }
            else if (mid[37] >= 1.0)
            {
                ans = "1.000";
            }
            else
            {
                if (mid[39] == 2)
                {
                    c = mid[38] * mid[38];
                }
                else
                {
                    c = Math.Acos((mid[28] * mid[28] + mid[29] * mid[29] - 2.0 * mid[36] * mid[36]) / (mid[28] * mid[28] - mid[29] * mid[29]));
                    b = Math.Acos((mid[28] * mid[29] + mid[36] * mid[36]) / mid[36] / (mid[28] + mid[29]));
                    a = Math.PI - b - c;
                    c = ((mid[38] * mid[38] * a + b) - mid[38] * Math.Sin(c)) / Math.PI;
                }
                a = Math.Floor(1000.0 * c + 0.5) / 1000.0;
                ans = a.ToString();
            }
            if (mid[40] == 1)
            {
                //WAS ITALIC
                return ans;
            }
            if (mid[40] == 2)
            {
                ans = a.ToString() + "(r)";
            }
            if (mid[40] == 3)
            {
                ans = a + "(s)";
            }
            return ans;
        }
        // Get the duration in mm:ss.s format
        // Adapted from code written by Stephen McCann - 27/04/2001
        private static  string GetDuration(double[] mid, double[] c2, double[] c3)
        {
            double tmp;
            string ans;

            if (c3[40] == 4)
            {
                tmp = mid[1] - c2[1];
            }
            else if (c2[40] == 4)
            {
                tmp = c3[1] - mid[1];
            }
            else
            {
                tmp = c3[1] - c2[1];
            }
            if (tmp < 0.0)
            {
                tmp = tmp + 24.0;
            }
            else if (tmp >= 24.0)
            {
                tmp = tmp - 24.0;
            }
            tmp = (tmp * 60.0) - 60.0 * Math.Floor(tmp) + 0.05 / 60.0;
            ans = Math.Floor(tmp) + "m";
            tmp = (tmp * 60.0) - 60.0 * Math.Floor(tmp);
            if (tmp < 10.0)
            {
                ans = ans + "0";
            }
            ans += Math.Floor(tmp) + "s";
            return ans;
        }
    }
}