#!PYTHONEXE

"""This script is the old version of isprint that worked with Madrigal 2.X Cedar format files.  It exists only to help
the conversion process from Madrigal 2.X to Madrigal 3.0.

Deprecated notes:

This script replaces the command line version of the isprint Fortran application.  It is based on the maddata
engine as found in madc/madrec, and exposed to python via _Madrec.c.

It is different from the old isprint application in the following ways:
1.  It works with any legal Cedar file format, not just the Madrigal format.
2.  It allows any parameter to be used in filters, not just the few offered by the Fortran isprint application

It is similar in that it supports most of the options that the Fortran isprint application did

$Id: isprint_deprecated.py 7046 2019-10-07 19:57:14Z brideout $
"""

import sys
import os
import traceback


usageStr = """Usage: isprint_deprecated.py file=<path to old format Cedar file>
     date1=<mm/dd/yyyy - starting date to be examined - defaults to first day>
     time1=<hh:mm:ss - starting UT time to be examined - defaults to 0>
     date2=<mm/dd/yyyy - ending date to be examined - defaults to last day>
     time2=<hh:mm:ss - ending UT time to be examined - defaults to 24>
     (in the follow arguments, any value missing may be used to indicate no lower or upper limit)
     z=<lower alt limit1>,<upper alt limit1>[or<lower alt limit2>,<upper alt limit2>...] (km)
     az=<lower az limit1>,<upper az limit1>[or<lower az limit2>,<upper az limit2>...] (from -180 to 180)
     el=<lower el limit1>,<upper el limit1>[or<lower el limit2>,<upper el limit2>...] (from 0 to 90)
     plen=<lower pl limit1>,<upper pl limit1>[or<lower pl limit2>,<upper pl limit2>...] (pulse len in sec)
     header=<t or f> (defaults to header=t, show headers)
     summary=<t or f> (defaults to summary=t, show summary)
     badval=<bad value string> (defaults to "missing")
     assumed=<assumed value string> (defaults to "assumed")
     knownbad=<known bad value string> (defaults to "knownbad")
     mxchar=<maximum characters per line> (minimum 50 - defaults to no maximum)
     filter=<[mnemonic] or [mnemonic1,[+-*/]mnemonic2]>,<lower limit1>,<upper limit1>[or<lower limit2>,<upper limit2>...]
        (any number of filters may be added)
     <list of mnemonics to display> (will be show in order listed)

Example:

    isprint_deprecated.py file=/opt/madrigal/experiments/1998/mlh/20jan98/mil980120g.003 date1=01/20/1998
    time1=15:00:00 date2=01/20/1998 time2=16:00:00 z=200,300or500,600 badval=noData
    filter=gdalt,-,sdwht,0, filter=ti,500,1000 uth gdalt gdlat glon ti te

This example would show data from mil980120g.003 between 15 and 16 UT on 01/20/1998 where
altitude is either between 200 and 300 km or between 500 and 600 km, and where gdalt-sdwht is
greater than 0 (point is in sunlight), and where ti is between 500 and 1000.  "noData" would
be printed if data was not available.

See complete instructions at http://www.haystack.mit.edu/madrigal/isprint.html
"""

def appendFilter(filter, type, parm1, parm2, numRanges, lowRangeList, highRangeList):
    """ appendFilter adds to the lists that make up a filter, which is a list of lists.

    Inputs:
        filter - the existing list of 6 lists to be appended to
        type - '1','*','/','+', or '-'.  If '1', parm2 not needed
        parm1 - filter mnemonic 1
        parm2 - filter mnemonic 1 - may be None if type = 1
        numRanges - number of ranges to add for this filter
        lowRangeList - list of lower limits; len must = numRanges
        highRangeList - list of upper limits; len must = numRanges

    Outputs: None

    Affects:  Appends to the following 6 lists in the filter:

        filtTypeList:    filter types, len = # filters, chars are '1','*','/','+', or '-'
        filtParm1List:   mnemonics of filter parameter 1 (items = # filters)
        filtParm2List:   mnemonics of filter parameter 2 (items = # filters) (may be None)
        filtNumRangeList: number of ranges per filter (items = # filters)
        filterLowList:   doubles of filter lower limits (items = sum of number of ranges above)
        filterHighList:  doubles of filter upper limits (items = sum of number of ranges above) 
    """
    # type
    if type not in ['1', '+', '-', '*', '/']:
        raise IOError("Illegal type: " + str(type))
    filter[0].append(type)

    #parm1
    filter[1].append(parm1)

    #parm2
    if type != '1':
        filter[2].append(parm2)
    else:
        filter[2].append(None)

    # numRanges
    filter[3].append(numRanges)

    #lowRangeList
    if len(lowRangeList) != numRanges:
        raise IOError("Wrong number of items in lowRangeList: " + str(numRanges) + ' ' + str(lowRangeList))
    for item in lowRangeList:
        if len(item) != 0:
            filter[4].append(float(item))
        else:
            filter[4].append(None)

    #highRangeList
    if len(highRangeList) != numRanges:
        raise IOError("Wrong number of items in highRangeList")
    for item in highRangeList:
        if len(item) != 0:
            filter[5].append(float(item))
        else:
            filter[5].append(None)
    
    
#  ********* main script begins here ***************
# catch any exception, and write an appropriate message
try:

    # check if pythonlibpath env variable exists
    # written 'PYTHON' + 'LIBPATH' to stop automatic replacement during setup
    temp = os.environ.get('PYTHON' + 'LIBPATH')
    if temp != None:
            sys.path.append(temp)
            
    # append path madroot/lib (needed only if python not installed by setup)
    sys.path.append('MADROOT/lib/python')

    # prepare to handle MadrigalError
    import madrigal.admin
    
except ImportError:
    
    # Fatal error - madpy library not found
    print("Unable to import the madrigal python library - please alert the sys admin!")
    sys.exit(0)

# try to run script, and report all errors to Madrigal sys admin

try:

    import madrigal.metadata
    import madrigal.data
    import madrigal._Madrec

    # create MadrigalDB obj
    madDBObj = madrigal.metadata.MadrigalDB()

    # create MadrigalParm obj
    madParmObj = madrigal.data._DeprecatedMadrigalParameters(madDBObj)

    # create an empty filter
    filter = [[],[],[],[],[],[]]

    # inital values
    desiredParmList = []
    filename = ''
    header = 1
    summary = 1
    badvalStr = 'missing'
    assumedStr = 'assumed'
    knownbadStr = 'knownbad'
    mxchar = 10000
    date1 = ''
    time1 = ''
    date2 = ''
    time2 = ''



    # parse arguments
    if len(sys.argv) == 1:
        print(usageStr)
        sys.exit(0)

    for arg in sys.argv[1:]:

        lowerLimList = []
        upperLimList = []
        
        # skip isprint command
        if arg.find('isprint_deprecated.py') != -1:
            continue
        
        # check if its a parameter
        if arg.find('=') == -1:
            if madParmObj.getParmType(arg) == -1:
                raise IOError("Illegal parameter: " + str(arg))
            desiredParmList.append(madParmObj.getParmMnemonic(arg))
            continue

        # check if its a file
        if arg.find('file=') != -1:
            filename = arg[arg.find('=')+1:]
            continue

        # check for header
        if arg[:7] == 'header=':
            if arg[7] in ['f', 'F']:
                header = 0
            elif arg[7] not in ['t', 'T']:
                raise IOError("Bad argument for header, must be t or f")
            continue

        # check for summary
        if arg[:8] == 'summary=':
            if arg[8] in ['f', 'F']:
                summary = 0
            elif arg[8] not in ['t', 'T']:
                raise IOError("Bad argument for summary, must be t or f")
            continue
                
        # check for badval
        if arg[:7] == 'badval=':
            badvalStr = arg[7:]
            continue

        # check for assumed
        if arg[:8] == 'assumed=':
            assumedStr = arg[8:]
            continue

        # check for knownbad
        if arg[:9] == 'knownbad=':
            knownbadStr = arg[9:]
            continue

        # check for mxchar
        if arg[:7] == 'mxchar=':
            try:
                mxchar = int(arg[7:])
                if mxchar < 50:
                    print("Lowest limit for mxchar is 50 - setting to 50")
                    mxchar = 50
            except:
                raise IOError("Illegal argument for mxchar: " + str(arg[7:]))
            continue
        

        # check if its date1
        if arg[:6] == 'date1=':
            date1 = arg[arg.find('=')+1:]
            continue

        # check if its time1
        if arg[:6] == 'time1=':
            time1 = arg[arg.find('=')+1:]
            continue

        # check if its date2
        if arg[:6] == 'date2=':
            date2 = arg[arg.find('=')+1:]
            continue

        # check if its time2
        if arg[:6] == 'time2=':
            time2 = arg[arg.find('=')+1:]
            continue

        # check if its z argument
        if arg[:2] == 'z=':
            argStr = arg[arg.find('=')+1:]
            # get number of ranges
            zRangeList = argStr.split('or')
            for zRange in zRangeList:
                limList = zRange.split(',')
                if len(limList) != 2:
                    raise IOError("Illegal range in z filter")
                lowerLimList.append(limList[0])
                upperLimList.append(limList[1])

            #append filter
            appendFilter(filter, '1', 'gdalt', '', len(zRangeList),
                         lowerLimList, upperLimList)
            continue
            
        # check if its az argument
        if arg[:3] == 'az=':
            argStr = arg[arg.find('=')+1:]
            # get number of ranges
            azList = argStr.split('or')
            for az in azList:
                limList = az.split(',')
                if len(limList) != 2:
                    raise IOError("Illegal range in az filter")
                lowerLimList.append(limList[0])
                upperLimList.append(limList[1])
                # check for valid az
                if float(limList[0]) < -180.0 or float(limList[0]) > 180.0:
                    raise IOError("Illegal az - must be -180 to 180: " + str(limList[0]))
                if float(limList[1]) < -180.0 or float(limList[1]) > 180.0:
                    raise IOError("Illegal az - must be -180 to 180: " + str(limList[1]))

            #append filter
            appendFilter(filter, '1', 'azm', '', len(azList),
                         lowerLimList, upperLimList)
            continue


        # check if its el argument
        if arg[:3] == 'el=':
            argStr = arg[arg.find('=')+1:]
            # get number of ranges
            elList = argStr.split('or')
            for el in elList:
                limList = el.split(',')
                if len(limList) != 2:
                    raise IOError("Illegal range in el filter")
                lowerLimList.append(limList[0])
                upperLimList.append(limList[1])
                # check for valid el
                if float(limList[0]) < 0.0 or float(limList[0]) > 90.0:
                    raise IOError("Illegal el - must be 0 to 90: " + str(limList[0]))
                if float(limList[1]) < 0.0 or float(limList[1]) > 90.0:
                    raise IOError("Illegal el - must be 0 to 90: " + str(limList[1]))

            #append filter
            appendFilter(filter, '1', 'elm', '', len(elList),
                         lowerLimList, upperLimList)
            continue

        # check if its plen argument
        if arg[:5] == 'plen=':
            argStr = arg[arg.find('=')+1:]
            # get number of ranges
            plList = argStr.split('or')
            for pl in plList:
                limList = pl.split(',')
                if len(limList) != 2:
                    raise IOError("Illegal range in pulse length filter")
                lowerLimList.append(limList[0])
                upperLimList.append(limList[1])

            #append filter
            appendFilter(filter, '1', 'pl', '', len(plList),
                         lowerLimList, upperLimList)
            continue

        # finally, check if its a filter argument
        if arg[:7] == 'filter=':
            argStr = arg[arg.find('=')+1:]
            #get mnemonic string
            itemList = argStr.split(',')
            if itemList[1] in ['+','-','*','/']:
                # two mnemonics used
                twoMnem = 1
                mnem1 = itemList[0]
                operator = itemList[1]
                mnem2 = itemList[2]
                # check that both are valid
                if madParmObj.getParmType(mnem1) == -1:
                    raise IOError("Illegal parameter: " + str(mnem1))
                if madParmObj.getParmType(mnem2) == -1:
                    raise IOError("Illegal parameter: " + str(mnem2))
            else:
                # one menmonic
                twoMnem = 0
                mnem1 = itemList[0]
                operator = '1'
                mnem2 = ''
                # check mnem1 is valid
                if madParmObj.getParmType(mnem1) == -1:
                    raise IOError("Illegal parameter: " + str(mnem1))

            
            # get ranges
            delimiter = ','
            rangeStr = delimiter.join(itemList[1 + 2*twoMnem:])
            rangeList = rangeStr.split('or')
            for thisRange in rangeList:
                limList = thisRange.split(',')
                if len(limList) != 2:
                    raise IOError("Illegal range in filter")
                lowerLimList.append(limList[0])
                upperLimList.append(limList[1])

            #append filter
            appendFilter(filter, operator, mnem1, mnem2, len(rangeList),
                         lowerLimList, upperLimList)
            continue

        # unknown argument
        print('Argument %s is unknown - see usage' % (arg))
        print('\n')
        print(usageStr)
        sys.exit(0)

    # command line fully parsed - finally set up the time filter based on
    # date, time args if needed

    if len(date1) or len(time1) or len(date2) or len(time2):
        # if time1 is given but not date1, set up a UTH filter
        if len(time1) and len(date1)==0:
            time1List = time1.split(':')
            if len(time1List) != 3:
                raise IOError("Illegal value for time1: " + time1)
            beg_uth = float(time1List[0])
            beg_uth += float(time1List[1])/60.0
            beg_uth += float(time1List[2])/3600.0
            appendFilter(filter, '1', 'UTH', '', 1,
                         [str(beg_uth)], [''])

        # if time2 is given but not date1 or date2, set up a UTH filter
        if len(time2) and len(date1)==0 and len(date2)==0:
            time2List = time2.split(':')
            if len(time2List) != 3:
                raise IOError("Illegal value for time2: " + time2)
            end_uth = float(time2List[0])
            end_uth += float(time2List[1])/60.0
            end_uth += float(time2List[2])/3600.0
            appendFilter(filter, '1', 'UTH', '', 1,
                         [''], [str(end_uth)])

        # set up UT1 filter if both date and times given
        beg_ut1 = ''
        end_ut1 = ''
        
        if (date1):
            if time1 == '':
                time1 = '00:00:00'
            time1List = time1.split(':')
            if len(time1List) != 3:
                raise IOError("Illegal value for time1: " + time1)
            date1List = date1.split('/')
            if len(date1List) != 3:
                raise IOError("Illegal value for date1: " + date1)
            beg_ut1 = madrigal._Madrec.getUtFromDate(int(date1List[2]),
                                                     int(date1List[0]),
                                                     int(date1List[1]),
                                                     int(time1List[0]),
                                                     int(time1List[1]),
                                                     int(time1List[2]),
                                                     0)
            beg_ut1 = str(beg_ut1)

            # now check for the case that time2 given, but not date2
            # in which case time2 referes to date1
            if len(time2) and len(date2)==0:
                end_ut1 = madrigal._Madrec.getUtFromDate(int(date1List[2]),
                                                         int(date1List[0]),
                                                         int(date1List[1]),
                                                         0,
                                                         0,
                                                         0,
                                                         0)
                time2List = time2.split(':')
                if len(time2List) != 3:
                    raise IOError("Illegal value for time2: " + time2)
                end_ut1 += float(time2List[0]) * 3600.0
                end_ut1 += float(time2List[1]) * 60.0
                end_ut1 += float(time2List[2])
                end_ut1 = str(end_ut1)
                

        if len(date2):
            if time2 == '':
                time2 = '00:00:00'
            time2List = time2.split(':')
            if len(time2List) != 3:
                raise IOError("Illegal value for time2: " + time2)
            date2List = date2.split('/')
            if len(date2List) != 3:
                raise IOError("Illegal value for date2: " + date2)
            end_ut1 = madrigal._Madrec.getUtFromDate(int(date2List[2]),
                                                     int(date2List[0]),
                                                     int(date2List[1]),
                                                     int(time2List[0]),
                                                     int(time2List[1]),
                                                     int(time2List[2]),
                                                     0)
            end_ut1 = str(end_ut1)

        # append ut1 filter if needed
        if len(beg_ut1) != 0 or len(end_ut1) != 0:
            appendFilter(filter, '1', 'UT1', '', 1,
                         [beg_ut1], [end_ut1])

    # check that filename was given
    if len(filename) == 0:
        raise IOError('Required argument file missing')


    madrigal._Madrec.getIsprintReport(filename,
                                      '',
                                      desiredParmList,
                                      filter[0],
                                      filter[1],
                                      filter[2],
                                      filter[3],
                                      filter[4],
                                      filter[5],
                                      header,
                                      summary,
                                      int(mxchar),
                                      badvalStr,
                                      assumedStr,
                                      knownbadStr,
                                      'stdout')

except:
    # handle an error

    # if a normal SystemExit, simply terminate
    if str(sys.exc_info()[0]).find('exceptions.SystemExit') != -1:
        sys.exit(0)

    if sys.exc_info()[0] != None:
        print('\n****  ' + str(sys.exc_info()[0]) + '  ****\n')
    if sys.exc_info()[1] != None:
        print('\n****  ' + str(sys.exc_info()[1]) + '  ****\n')
    if sys.exc_info()[0] == None and sys.exc_info()[1] == None:
        print()
        traceback.print_exc()


# end script