import sys
import re
import os.path

from optparse import OptionParser

from xomo.utils import *
from xomo.lisp.casestudy import *


def fixOutputFileName(outputFileName, inputFileNames) :
    '''
    If outputFileName isn't specified,  base it on the inputFileName 
    if there is only one inputFileName, else default: 'output.lisp'.
    '''
    if outputFileName :
        return outputFileName
    elif len(inputFileNames) == 1:
        (baseOutputFileName,inputExt)  = os.path.splitext(inputFileNames[0])
        return  baseOutputFileName + ".lisp"
    else:
        return  "output.lisp"

attributeNameExceptions = {'automated_analysis':'aa',
                           'peer_reviews' : 'pr',
                           'execution_testing_and_tools' : 'etat',
                           'Ksloc' : 'kloc'  }

def fixAttributeName(attributeName) :
    if attributeName in attributeNameExceptions :
        return attributeNameExceptions[attributeName]
    else :
        return attributeName


def parseStream(inputFileStream) :
    attributes = {}
    for line in inputFileStream:
        parts = line.split()
        if len(parts) == 2 :
            attributeName = fixAttributeName(parts[0])
            value = float(parts[1])
            attributes[attributeName] = createXomoRange(attributeName,value,value)
        elif len(parts) == 3 :
            attributeName = fixAttributeName(parts[0])
            minValue = float(parts[1])
            maxValue = float(parts[2])
            attributes[attributeName] = createXomoRange(attributeName,minValue,maxValue)
        else :
            print >> sys.stderr, 'unable to parse line: ', line
    return attributes

def parseInput(inputFileName) :
    '''
    parses inputFile.ranges and inputFile.values into attribute map (attributes -> values)
    '''

    #parse values file
    valueAttributes = {}
    try:
        inputFileStream = open(inputFileName + ".values","rb")
    except IOError:
        print >> sys.stderr, 'unable to open', inputFileName
    else:
        valueAttributes = parseStream(inputFileStream)
        inputFileStream.close()

    #parse ranges file
    rangeAttributes = {}
    try:
        inputFileStream = open(inputFileName + ".ranges","rb")
    except IOError:
        print >> sys.stderr, 'unable to open', inputFileName
    else:
        rangeAttributes = parseStream(inputFileStream)
        inputFileStream.close()

    attributes = valueAttributes
    for attributeName,values in rangeAttributes.iteritems():
        if attributeName in attributes:
            print >> sys.stderr, 'duplicate definitions for ', attributeName, 'using more constrained:', ",".join(attributes[attributeName])
        else :
            attributes[attributeName] = values
    return attributes

def main():
    usage = "usage: %prog [options] inputFileNames"
    parser = OptionParser()
    parser.add_option("-o", "--output", dest="outputFileName", help="output file name")
    (options, args) = parser.parse_args()
    parser.destroy()

    if len(args) < 1:
        parser.error("inputFileNames not specified")

    #input -> projects
    inputFileNames = list(set(args)) # remove duplicates

    projects = {}
    for inputFileName in inputFileNames:
       projects[inputFileName] = parseInput(inputFileName)


    #projects -> output
    outputFileName = fixOutputFileName(options.outputFileName, inputFileNames)
    try:
        outputFileStream = open(outputFileName,"w")
    except IOError:
        print >> sys.stderr, 'unable to open', outputFileName
    else:
        outputHeader(outputFileStream,",".join(inputFileNames))
        outputCaseStudies(outputFileStream,projects)
        outputFileStream.close()

if __name__ == "__main__":
    main()
