import datetime
import math
import doctest
import typing 

from .durations import Duration

# ========================================================
# ========================================================
# === DATE
# ========================================================
# ========================================================

class Date:
    """ Class to convert dates for astronomy

    *Date formats are:*

    | now = Now. e.g. "now"    
    | jd = Julian day. e.g. 24504527.45678
    | iso = ISO 8601. e.g. 2018-02-28T12:34:55.23
    | sql = ISO 8601. e.g. 2018-02-28 12:34:55.23
    | ymdhms = Calendar. e.g. 2018 2 28 12 34 55.23
    | equinox = Equinox. e.g. J2000,0
    | digits = Pure digits e.g. 20180228123455.23

    
    *Usage:*

    First, instanciate an object from the class: 
    
    ::
        date = Date()

    Second, assign a date in any date format:

    
    ::
        date.date("2018-02-28T12:34:55")

    Third, get the converted date:
    
    ::
        jd = date.jd()
        date = date.date()
        iso = date.iso()
        ymdhms = date.ymdhms()
        equinox = date.equinox()

    *Informations:*

    All dates are in UTC.

    Some other useful methods:

    ::
        help(Date)
        Date().infos("doctest")
        Date().infos("doc_methods")
        

    """
# ========================================================
# === attributs
# ========================================================

    _B1850 = 2396758.203
    _B1900 = 2415020.3135
    _B1950 = 2433282.4235
    _B1975 = 2442413.478
    _B2000 = 2451544.533
    _B2025 = 2460675.588
    _B2050 = 2469806.643
    _B2100 = 2488068.753
    _J1900 = 2415020.0000
    _J1950 = 2433282.5000
    _J2000 = 2451545.0000
    _J2050 = 2469807.5000
    _J2100 = 2488070.0000

# ========================================================
# === internal methods
# ========================================================

    def _init(self,date="") -> None:

        """ Initialize internal attributes.

        :param date: date is a date in any supported format (cf. help(Date))
        :type date: any 

        :returns: None

        :rtype: None
 
        :Example:
            
        >>> objdate = Date()
        >>> objdate._init()
        
        """
        self._init_date = date
        self._init_dateformat = 0
        self._computed_jd = 0

        self._computed_iso = 0
        self._computed_iso_nb_subdigit = 3
        self._computed_iso_letter = 'T'
        self._computed_ymdhms = 0
        self._computed_digits = 0
        self._computed_digits_nb_subdigit = 3
        self._computed_equinox = 0
        self._computed_equinox_year_type = "J"
        self._computed_equinox_nb_subdigit = 1
        self._jd = 0

        self._iso = 0
        self._ymdhms = 0
        self._equinox = 0

    def _is_number(self,s) -> bool:
        """ Return True if the string is a number else return False.

        :param s: A string to test
        :type s: string

        :returns: True is the string can be concerted into a float

        :rtype: bool
 
        :Example:

        >>> objdate = Date()
        >>> objdate._is_number("3e5")
        True
        >>> objdate._is_number("3a5")
        False
        
        """
        try:
            float(s)
            return True
        except ValueError:
            pass 
        try:
            import unicodedata
            unicodedata.numeric(s)
            return True
        except (TypeError, ValueError):
            pass 
        return False

    def _duration2day(self, duration) -> float:
        """ Return a duration in day unit from a duration in dhms format.

        :param duration: A string formated as "2d7h23m12.5s"
        :type duration: string

        :returns: duration expressed in day and fraction of day

        :rtype: float
 
        :Example:

        >>> objdate = Date()
        >>> objdate._duration2day("2d7h23m12.5s")
        2.3077835648148146
        
        """
        duration = str(duration)
        duration = duration.upper()
        cars = "+-.E0123456789"
        units = "DHMS"
        dur = 0
        k1 = -1
        k2 = -1
        k = 0
        div = 0
        for car in duration:
            if car in cars:
                if k1 == -1:
                    k1 = k
                k2 = k
            elif car in units:                
                if (k1>=0 and k2>=0):
                    div = 0
                    if car=='D':
                        div = 1.
                    elif car=='H':
                        div = 24.
                    elif car=='M':
                        div = 1440.
                    elif car=='S':
                        div = 86400.
                    if div>0:
                        n = float(duration[k1:k2+1])
                        dur += n/div
                    k1 = -1
                    k2 = -1
            k += 1
        if (div==0 and dur==0 and k1>=0 and k2>=k1):
            n = float(duration[k1:k2+1])
            dur += n
        return dur
    
    def _date_compare(self, date, operator):
        """ Comparaison of dates for various operators.

        :param date: A date in any supported format (cf. help(Date))
        :type date: Date()
        :param operator : Operator such as == != > >= < <=
        :type operator : string

        :returns: The logic result of the comparison.

        :rtype: bool
        
        :Example:

        >>> objdate1 = Date()
        >>> objdate2 = Date()
        >>> objdate1.date("2018 02 28"); objdate2.date("2018 02 27"); objdate1._date_compare(objdate2,">")
        '2018 02 28'
        '2018 02 27'
        True
        
        .. note:: Does not account for the modulo.
        """
        if self._computed_jd == 0:
            self.jd()
        if date._computed_jd == 0:
            date.jd()
        res = False
        if (self._computed_jd == 1) and (date._computed_jd == 1):
            toeval = str(self._jd)+" "+operator+" "+str(date._jd)
            res = eval(toeval)
        return res
    
# ========================================================
# === date methods
# ========================================================

    def date_date2jd(self,date) -> typing.Tuple[int, float]:
        """ Compute a julian day from any date format

        :param date: A string formated as "2d7h23m12.5s"
        :type date: string

        :returns: A tuple of init_dateformat, julian day. init_dateformat: The identified format of the input:
            * 0 = Error, format not known
            * 1 = Now
            * 2 = Equinox
            * 3 = Sql
            * 4 = Calendar
            * 5 = ISO 8601
            * 6 = Julian day
            * 7 = Modified Julian day
            * 8 = Digits

        :rtype: tuple(int, float)
 
        :Example:

        >>> objdate = Date()
        >>> objdate.date_date2jd("2018-02-28T12:34:55.234")
        (5, 2458178.0242503937)
                
        .. note:: Prefer using objdate.date() followed by objdate.jd().            
        """
        # --- First we do not process if date is ever a Date object
        if (isinstance(date, Date)):
            return date
        # --- Decode the date
        jd = 0
        init_dateformat = 0
        str_date = str(date).upper()
        str_split = str_date.split(" ")
        str_nsplit = len(str_split)
        if str_date == "NOW":
            # style NOW
            utc_datetime = datetime.datetime.utcnow()
            day = utc_datetime.day + ((((utc_datetime.microsecond*1e-6) + utc_datetime.second)/60. + utc_datetime.minute)/60. + utc_datetime.hour)/24.
            error, jd = self.date_ymd2jd(utc_datetime.year, utc_datetime.month, day)
            init_dateformat = 1

        elif (str_date[0] == "B") or (str_date[0] == "J"):

            # style J2000,0
            error, jd = self.date_equinox2jd(str_date)
            init_dateformat = 2

        elif (str_nsplit == 2):

            # style SQL 2018-01-02 23:02:45.456
            iso_date = str_split[0] + "T" + str_split[1]
            error, jd = self.date_iso2jd(iso_date)
            init_dateformat = 3

        elif (str_nsplit == 3):

            # style calenday 2018 01 02.4567
            str_split = [ float(x) for x in str_split]
            error, jd = self.date_ymd2jd(str_split[0],str_split[1],str_split[2])
            init_dateformat = 4

        elif (str_nsplit == 4):

            # style calenday 2018 01 02 05.324
            str_split = [ float(x) for x in str_split]
            error, jd = self.date_ymdhms2jd(str_split[0],str_split[1],str_split[2],str_split[3])
            init_dateformat = 4

        elif (str_nsplit == 5):

            # style calenday 2018 01 02 05 12.1809
            str_split = [ float(x) for x in str_split]
            error, jd = self.date_ymdhms2jd(str_split[0],str_split[1],str_split[2],str_split[3],str_split[4])
            init_dateformat = 4

        elif (str_nsplit == 6):

            # style calenday 2018 01 02 05 12 56.789
            str_split = [ float(x) for x in str_split]
            error, jd = self.date_ymdhms2jd(str_split[0],str_split[1],str_split[2],str_split[3],str_split[4],str_split[5])
            init_dateformat = 4

        elif (str_nsplit == 1) and (str_date.find("T") > 6):

            # style ISO 2018-01-02T23:02:45.456
            error, jd = self.date_iso2jd(str_date)
            init_dateformat = 5
        elif (self._is_number(str_date) is True):
            # style is julian day or MJD   
            # MJD = JD - 2400000.5 (SAO in 1957)
            # digits as 20180316
            jd = float(str_date)
            init_dateformat = 6
            if (math.log10(jd) > 7.2):
                # --- digits
                error, jd = self.date_digits2jd(str_date)
                init_dateformat = 8
            elif (math.log10(jd) < 5):
                # --- MJD
                jd += 2400000.5
                init_dateformat = 7
        return init_dateformat, jd
        

    def date_iso2jd(self,string) -> tuple:

        """ Compute a julian day from a ISO8601 date

        :param string: A string formated in ISO 8601
        :type string: string

        :returns: A tuple of error, julian day. error = 0 means no error

        :rtype: tuple(int, float)
 
        :Example:

        >>> objdate = Date()
        >>> objdate.date_iso2jd("2018-02-28T12:34:55.234")
        (0, 2458178.0242503937)
        
        First integer is an error code. 0 = no problem.
            
        .. note:: Prefer using objdate.date() followed by objdate.jd().            
        """
        error = 0
        k1 = string.find("-",1)
        k2 = string.find("-",k1+1)
        kt = string.find("T",k2+1)
        if (kt==-1):
            kt = string.find("T",k2+1)
        k3 = string.find(":",kt+1)
        k4 = string.find(":",k3+1)
        d=1
        hh=0
        mm=0
        ss=0.0
        if (k2 > -1): 
            y = int(string[0:k1])
            m = int(string[k1+1:k2])
            if (kt == -1):
                d = float(string[k2+1:])
            else:
                d = int(string[k2+1:kt])
            if (k3 > -1):
                hh = int(string[kt+1:k3])
                d += hh/24.
            if (k4 == -1):
                mm = float(string[k3+1:])
                d += mm/1440.
            else:
                mm = int(string[k3+1:k4])
                d += mm/1440.
                ss = float(string[k4+1:])
                d += ss/86400.                
            error, jd = self.date_ymd2jd(y,m,d)
        else:
            # pb format
            error = 1
        return error, jd

    def date_jd2iso(self, jd, nb_subdigit=3, letter='T') -> tuple:

        """ Compute a ISO8601 date from a julian day

        :param jd: A julian day
        :type jd: float

        :param nb_subdigit: The number of digits returned after the seconds.

        :type nb_subdigit: int

        :param letter: The letter to separe date end time. If letter is "" then the output format sticks all digits without any characters :-T. So the format is no longer ISO but useful for a pure digit code.

        :type letter: int

        :returns: A tuple of error, string of a date formatted into ISO8601. error = 0 means no error.

        :rtype: tuple(int, float)
 
        :Example:

        >>> objdate = Date()
        >>> objdate.date_jd2iso(2458178.0242503937)
        (0, '2018-02-28T12:34:55.234')
        
        .. note:: Prefer using objdate.date() followed by objdate.iso()            
        """
        error, y, m, d, hh, mm, ss = self.date_jd2ymdhms(jd)
        nb_prefixdigit = nb_subdigit+3
        if (nb_subdigit < 0):
            nb_subdigit = 0
        if (nb_subdigit == 0):
            nb_prefixdigit -= 1
        if (letter==''):
            fstring  = "{:04d}{:02d}{:02d}{}{:02d}{:02d}{:0"+str(nb_prefixdigit)+"."+str(nb_subdigit)+"f}"
        else:
            fstring  = "{:04d}-{:02d}-{:02d}{}{:02d}:{:02d}:{:0"+str(nb_prefixdigit)+"."+str(nb_subdigit)+"f}"
        res = fstring.format(y, m, d, letter, hh, mm, ss)
        return error, res
                
    def date_equinox2jd(self,string):
        """ Compute a julian day from a equinoxal date
        
        :param string: date string is a string in Equinox format (cf. help(Date))
        :type string: string 

        :returns: A tuple of error, julian day. error = 0 means no error

        :rtype: tuple(int, float)
 
        :Example:

        >>> objdate = Date()
        >>> objdate.date_equinox2jd("J2025,0")
        (0, 2460676.25)
        
        .. note:: Prefer using objdate.date() followed by objdate.jd()            
        """
        error = 0
        t = string[0]
        s = string[1:].replace(',','.')
        a = float(s)
        jd = 0