#!/usr/bin/env python
#---------------------------------------------------------------------
# Imports and Global Values
#---------------------------------------------------------------------

import sys
import os


# Get this value from MachineStateBufferMapping.h, EPICS_FAULT_SECTION_SIZE
MAX_FAULT_COUNT = 128











#---------------------------------------------------------------------
# Write the state notation program
#---------------------------------------------------------------------


def writeStateNotationProgram(verbose, sttPath, headerPath, programName, faultCount):
    from string import Template
    from time   import ctime


    ## State notation language file templates ##
    sttHeaderPart1 = Template("""/*
 * Implementation of $programName.
 * Created on $date
 */
 
program $programName

%%#include "MachineStateBuffer.h"

int     v[$faultCount];""")

    sttHeaderPart2 = Template("""assign  v[$i] to "{pv$i}";""")
    sttHeaderPart3 = """monitor v;"""
    
    stateSet = Template("""
/* State set for EPICS fault index $i */
ss epicsFaultStateSet$i
{    
    state init
    {
        when() {
            epicsFaultStateMakeFaulted($i);
        } state low
    }

    state low
    {
        when((pvConnected(v[$i])) && (v[$i] != 0)) {
            epicsFaultStateMakeOk($i);
        } state high
        when(delay(.1)) {} state low
    }
    
    state high
    {
        when(!pvConnected(v[$i])) {
            epicsFaultStateMakeFaulted($i);
        } state low
              
        when(v[$i] == 0) {
            epicsFaultStateMakeFaulted($i);
        } state low
     
        when(delay(.1)) {} state high
    }
}\n\n""")


    ## Header file template ##
    headerTemplate = Template("""/*
 * $programName.h
 *
 * Header file for $programName
 * Created on $date
 */

#ifndef $headerDefine
#define $headerDefine

#define EPICS_FAULTS_MAX_PV_COUNT ($faultCount)

#endif\n\n\n""")
    
    try:
        sttFile = open(sttPath, 'w')
    except IOError, e:
        sys.stderr.write('Could not open "' + sttPath + '": ' + e.strerror + "\n")
        return 1

    try:
        headerFile = open(headerPath, 'w')
    except IOError, e:
        sys.stderr.write('Could not open "' + headerPath + '": ' + e.strerror + "\n")
        sttFile.close()
        return 1
        
    date = ctime()



    ## Create the stt file ##
    if verbose:
        print "Creating program, \"" + programName + "\", at " + sttPath

    print >> sttFile, sttHeaderPart1.substitute(date = date, programName = programName, faultCount = faultCount)
    
    for i in range(0, faultCount): 
        print >> sttFile, sttHeaderPart2.substitute(i = i)

    print >> sttFile, sttHeaderPart3
    
    for i in range(0, faultCount): 
        print >> sttFile, stateSet.substitute(i = i)
        
    sttFile.close()



    ## Create the header file ##
    if verbose:
        print "Creating header file for \"" + programName + "\" at " + headerPath

    headerDefine = programName.upper() + "_H"

    print >> headerFile, headerTemplate.substitute(date = date, headerDefine = headerDefine, programName = programName, faultCount = faultCount)
    
    headerFile.close()





#---------------------------------------------------------------------
# Helper Functions
#---------------------------------------------------------------------



def handleOptions():
    from optparse import OptionParser, OptionGroup, SUPPRESS_HELP

    # Create parse options
    usage   = "Usage: %prog [options]"
                
    version = "%prog 1.0"
    parser = OptionParser(usage=usage, version=version)

    parser.add_option("-v", "",           action="store_true",            dest="verbose",                      help="Print verbose output")
    parser.add_option("-n", "--name",     action="store", type="string",  dest="name",        metavar="NAME",  help="State notation program name.  Default: mpsEpicsFaultInputs")
    parser.add_option("-c", "--count",    action="store", type="string",  dest="faultCount",  metavar="COUNT", help="Number of EPICS faults to monitor (up to " + str(MAX_FAULT_COUNT) + ").  Default: 64")
    parser.add_option("-o", "--outpath",  action="store", type="string",  dest="path",        metavar="PATH",  help="Destination directory of NAME.stt and NAME.h")

    # Defaults
    parser.set_defaults(verbose    = False,
                        name       = "mpsEpicsFaultInputs",
                        faultCount = "64",
                        path       = "")

    # Parse arguments
    (options, args) = parser.parse_args()
    options.faultCount = int(options.faultCount)
    
    # Check to see if faultsCount is valid
    if (options.faultCount < 0) or (options.faultCount > MAX_FAULT_COUNT):
        parser.error("Number of EPICS faults to monitor is out of range (0 - " + str(MAX_FAULT_COUNT) + ")")
            
    return (options, args)




#---------------------------------------------------------------------
# Main
#---------------------------------------------------------------------

def main():
    
    # Options
    (options, args) = handleOptions()
    
    # Delete outpath if it already exists

    sttPath    = os.path.normcase(options.path + "/" + options.name + ".stt")
    headerPath = os.path.normcase(options.path + "/" + options.name + ".h"  )
    
    fileList = (sttPath, headerPath)
    
    for file in fileList:
        if os.path.isfile(file):
            try:
                os.remove(file)
            except OSError, e:
                sys.stderr.write('Could not remove "' + file + '": ' + e.strerror + "\n")
                sys.exit(1)
    
    
    # Write file
    writeStateNotationProgram(options.verbose, sttPath, headerPath, options.name, options.faultCount)


if __name__ == "__main__":
    main()


