from PIPRes.wrap.idl import CipresIDL_api1, CipresIDL_api2
from PIPRes.cipres_types import toIDLTree, toIDLMatrix, reorderMatrix, mapLeaves, CipresTree, toIDLDiscreteCharacterModel
import sys 
import copy
from PIPRes.util.io import cipresGetLogger
_LOG = cipresGetLogger('pipres.wrap.stub')

#    PIPResInterfaceWrapper and its subclasses were created because the cipres_types Tree and DataMatrix overload base class attributes (of CipresIDL_api1.Tree and CipresIDL_api1.DataMatrix)
#        with properties.  This does not make omniORB happy when these types are used as arguments to corba calls.
#        Most troublesome is the fact that it seems to work some of the time (usually with small arguments).
#    
#    The caller could call toIDLTree() and toIDLMatrix() for each argument, but that may be easy to forget.  These wrappers do the conversion for you.
#    Currently the synchronization between these classes and the IDL is done by hand (ugh), but things don't change too quickly/
#    we only have to wrap classes that take Tree or DataMatrix args (return values come in as CipresIDL_api1 types and are not translated)

class PIPResInterfaceWrapper:
    def __init__(self, objRef):
        self.objRef = objRef
    def remove(self):
        return self.objRef.remove()
    def release(self):
        return self.objRef.remove()
    def getUIXml(self):
        return self.objRef.getUIXml()
    def execute(self, command):
        return self.objRef.execute(command)
    def __getattr__(self, name):
        if name in self.objRef.__dict__:
            return self.objRef.__dict__[name]
        raise AttributeError, '%s instance has not attribute %s' %(self.__class__.__name__, name)
        #return self.objRef.__getattr__(name)

class ModelSupplierWrapper(PIPResInterfaceWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)
    def getModel(self, mod):
        x = toIDLDiscreteCharacterModel(mod)
        _LOG.debug(self.objRef.__class__)
        _LOG.debug(x.__class__)
        _LOG.debug("calling ModelSupplier.getModel() with " + str(x))
        
        return self.objRef.getModel(x)
    def ping(self, mod):
        _LOG.debug("calling ModelSupplier.ping() with " + str(mod))
        
        return self.objRef.ping(mod)

class TreeDecomposeWrapper(PIPResInterfaceWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)
    def leafSetDecompose(self, tree):
        it = toIDLTree(tree)
        return self.objRef.leafSetDecompose(it)

class TreeMergeWrapper(PIPResInterfaceWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)
    def mergeTrees(self, trees):
        return self.objRef.mergeTrees([toIDLTree(i) for i in trees])

class TreeSupplierWrapper(PIPResInterfaceWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)
    def getNumTrees(self):
        return self.objRef.getNumTrees()
    def getTree(self, treeIndex, outOfRangeBehavior):
        return self.objRef.getTree(treeIndex, outOfRangeBehavior)
    def getTrees(self, fromIndex, toIndex, outOfRangeBehavior):
        return self.objRef.getTrees(fromIndex, toIndex, outOfRangeBehavior)
    def tell(self):
        return self.objRef.tell()
    def seek(self, treeIndex, outOfRangeBehavior):
        return self.objRef.seek(treeIndex, outOfRangeBehavior)
    def next(self, numTrees, outOfRangeBehavior):
        return self.objRef.next(numTrees, outOfRangeBehavior)

class MatrixAlignWrapper(PIPResInterfaceWrapper):
    def setTaxa(self, taxa):
        self._outTaxa = None
        self._inTaxa = copy.copy(taxa)
        return self.objRef.setTaxa(taxa)
    def setInputMatrix(self, matrix):
        self._outTaxa = None
        im = toIDLMatrix(matrix)
        return self.objRef.setInputMatrix(im)
    def setGuideTree(self, tree):
        self._outTaxa = None
        return self.objRef.setGuideTree(toIDLTree(tree))
    def getTaxa(self):
        return self.objRef.getTaxa()
    def getAlignedMatrix(self):
        m = self.objRef.getAlignedMatrix();
        self._outTaxa = copy.copy(self.objRef.getTaxa())
        _LOG.debug('intaxa = %s' % ' '.join(self._inTaxa))
        _LOG.debug('outtaxa = %s' % ' '.join(self._outTaxa))
        reorderMatrix(m, self._outTaxa, self._inTaxa)
        return m
    def getTree(self, proxyConsumer):
        t = CipresTree(self.objRef.getTree(proxyConsumer))
        self._outTaxa = copy.copy(self.objRef.getTaxa())
        mapLeaves(t, self._outTaxa, self._inTaxa)
        return t
    def getScore(self):
        return self.objRef.getScore()

class TreeMatrixDependentWrapper(PIPResInterfaceWrapper):
    def setTree(self, tree):
        return self.objRef.setTree(toIDLTree(tree))
    def setMatrix(self, matrix):
        return self.objRef.setMatrix(toIDLMatrix(matrix))

class TreeImproveWrapper(TreeMatrixDependentWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)
    def improveTree(self, proxyConsumer):
        return self.objRef.improveTree(proxyConsumer)
    def improveTreeReturnAll(self, proxyConsumer):
        return self.objRef.improveTreeReturnAll(proxyConsumer)

class Rid3TreeImproveWrapper(TreeImproveWrapper):
    def executeRecursive(self, cmd):
        return self.objRef.executeRecursive(cmd)

class TreeInferWrapper(TreeMatrixDependentWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)
    def inferTree(self, proxyConsumer):
        return self.objRef.inferTree(proxyConsumer)
    def inferTreeReturnAll(self, proxyConsumer):
        return self.objRef.inferTreeReturnAll(proxyConsumer)

class TreeEvaluateWrapper(TreeMatrixDependentWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)
    def evaluateTree(self, proxyConsumer):
        return self.objRef.evaluateTree(proxyConsumer)

class TreeRefineWrapper(TreeMatrixDependentWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)
    def refineTree(self):
        return self.objRef.refineTree()

class RendezVousWrapper(PIPResInterfaceWrapper):
    def __init__(self, objRef):
        PIPResInterfaceWrapper.__init__(self, objRef)    

class AsyncTreeIteratorWrapper(RendezVousWrapper):
    def getFirstTree(self):
        return self.objRef.getFirstTree()
    def getLastTree(self):
        return self.objRef.getLastTree()
    def getNextTree(self):
        return self.objRef.getNextTree()
    def getPreviousTree(self):
        return self.objRef.getPreviousTree()
    def getTreeByIndex(self, whichTree):
        return self.objRef.getTreeByIndex(whichTree)
    def pop(self):
        return self.objRef.pop()
    def push(self, treeParam):
        return self.objRef.push(treeParam)
    def shift(self):
        return self.objRef.shift()
    def unshift(self, treeParam):
        return self.objRef.unshift(treeParam)
    def getNumTrees(self):
        return self.objRef.getNumTrees()
    def exists(self, treeInd):
        return self.objRef.exists(treeInd)

class AsyncTreeInferWrapper(AsyncTreeIteratorWrapper):
    def setMatrix(self, mat):
        return self.objRef.setMatrix(toIDLMatrix(mat))
    def inferTrees(self, outStream):
        ati = self.objRef.inferTrees(outStream)
        objRef = ati._narrow(CipresIDL_api1.AsyncTreeIterator)
        return AsyncTreeIteratorWrapper(objRef)


wrapperObjRefTranslator = {
    'AsyncTreeInfer':   AsyncTreeInferWrapper,
    'AsyncTreeIterator':AsyncTreeIteratorWrapper,
    'MatrixAlign':      MatrixAlignWrapper,
    'TreeDecompose':    TreeDecomposeWrapper,
    'TreeEvaluate':     TreeEvaluateWrapper,
    'TreeMerge':        TreeMergeWrapper,
    'TreeImprove':      TreeImproveWrapper,
    'TreeInfer':        TreeInferWrapper,
    'TreeRefine':       TreeRefineWrapper,
    'Rid3TreeImprove':  Rid3TreeImproveWrapper,
    'ModelSupplier':    ModelSupplierWrapper,
    }



def _defaultOrArgTreeOrMatrix(registryWrapper, cmdLineArgs, bits):
    fileToRead = None
    
    for n, a in enumerate(cmdLineArgs):
        if n > 0:
            if sys.argv[n - 1].upper() == '-FILENAME':
                fileToRead = a
                break
    if fileToRead:
        cmdLineArgs.pop(n)
        cmdLineArgs.pop(n-1)
        import os
        readNexusObjRef = registryWrapper.getServiceOrExit(CipresIDL_api1.ReadNexus)
        if not os.path.exists(fileToRead):
            sys.exit('The file %s does not exist.' % fileToRead)
        readBlocks = readNexusObjRef.readNexusFile(fileToRead, bits)
        try:
            if readBlocks[CipresIDL_api1.ReadNexus.NEXUS_TREES_BLOCK_INDEX] < 1:
                if bits & CipresIDL_api1.ReadNexus.NEXUS_TREES_BLOCK_BIT:
                    sys.exit('No trees found in ' + fileToRead)
            else:
                cipresTree = readNexusObjRef.getTrees(0)[0]
            if readBlocks[CipresIDL_api1.ReadNexus.NEXUS_CHARACTERS_BLOCK_INDEX] < 1:
                if bits & CipresIDL_api1.ReadNexus.NEXUS_CHARACTERS_BLOCK_BIT:
                    sys.exit('No characters found in ' + fileToRead)
            else:
                cipresMatrix = readNexusObjRef.getCharacters(0)
        finally:
            readNexusObjRef.remove()
    else:
        cipresTree = cipresMatrix = None
    if bits & CipresIDL_api1.ReadNexus.NEXUS_TREES_BLOCK_BIT:
        if  bits & CipresIDL_api1.ReadNexus.NEXUS_CHARACTERS_BLOCK_BIT:
            return cipresMatrix, cipresTree
        return cipresTree
    assert(bits & CipresIDL_api1.ReadNexus.NEXUS_CHARACTERS_BLOCK_BIT)
    return cipresMatrix


def matrixAndTreeFromFileOrDefault(registryWrapper, cmdLineArgs):
    '''Utility function for testing clients that need a matrix and tree.'''
    return _defaultOrArgTreeOrMatrix(registryWrapper, cmdLineArgs, CipresIDL_api1.ReadNexus.NEXUS_TREES_BLOCK_BIT | CipresIDL_api1.ReadNexus.NEXUS_CHARACTERS_BLOCK_BIT)
def matrixFromFileOrDefault(registryWrapper, cmdLineArgs):
    '''Utility function for testing clients that need a matrix.'''
    return _defaultOrArgTreeOrMatrix(registryWrapper, cmdLineArgs, CipresIDL_api1.ReadNexus.NEXUS_CHARACTERS_BLOCK_BIT)
def treeFromFileOrDefault(registryWrapper, cmdLineArgs):
    '''Utility function for testing clients that need a  tree.'''
    return _defaultOrArgTreeOrMatrix(registryWrapper, cmdLineArgs, CipresIDL_api1.ReadNexus.NEXUS_TREES_BLOCK_BIT)