from PIPRes.exceptions import CipresException, raiseCipresExcepFromPyExcep, raiseCipresExcepFromUnknownErr
from PIPRes.wrap.idl import CipresIDL_api1__POA, CipresIDL_api2__POA
from PIPRes.util.cipres import SimpleServer
from PIPRes.cipres_types import toIDLTree, toIDLMatrix, nilTree, toIDLDiscreteCharacterModel, PipresDiscreteCharacterModel
from PIPRes.util.io import logException, expandPath, cipresGetLogger
import sys 

_LOG = cipresGetLogger('pipres.wrap.impl')

def _exceptionTranslate(method, *args):
    try:
        return method(*args)
    except CipresException, ex:
        return raiseCipresExcepFromPyExcep(ex)
    except :
        return raiseCipresExcepFromUnknownErr()

class ModelSupplierImplWrapper(CipresIDL_api2__POA.ModelSupplier):
    def __init__(self, argv, registry, implRef):
        self.implRef = implRef
    def getModel(self, mod):
        # _LOG.debug("ModelSupplier.getModel() new empty model")
#         m = PipresDiscreteCharacterModel()
#         return toIDLDiscreteCharacterModel(m)
        _LOG.debug("ModelSupplier.getModel() bouncing back")
        return mod
        _LOG.debug("ModelSupplier.getModel() incoming = " + str(mod))
        m = self.implRef.getModel(mod)
        _LOG.debug("ModelSupplier.getModel() returning = " + str(m))
        c = toIDLDiscreteCharacterModel(m)
        _LOG.debug("ModelSupplier.getModel() returning (converted)= " + str(c))
        assert(c is mod)
        return m
    def ping(self, n):
        return self.implRef.ping(n)

class ImplWrapper(CipresIDL_api1__POA.Scriptable, CipresIDL_api1__POA.LifeCycle):
    def __init__(self, argv, registry, implRef):
        self.implRef = implRef
    def remove(self):
        _exceptionTranslate(self.implRef.remove)
    def getUIXml(self):
        return _exceptionTranslate(self.implRef.getUIXml)
    def execute(self, command):
        return _exceptionTranslate(self.implRef.execute, command)

class RecursiveScriptableWrapper(ImplWrapper):
    def executeRecursive(self, cmdObject):
        _LOG.error(str(cmd.__dict__))
        time.sleep(5)
        return True, ''

        
class TreeMatrixDependentImplWrapper(ImplWrapper):
    def setTree(self, inTree):
        return _exceptionTranslate(self.implRef.setTree, inTree)
    def setMatrix(self, matrix):
        return _exceptionTranslate(self.implRef.setMatrix, matrix)

class MatrixDependentImplWrapper(ImplWrapper):
    def setMatrix(self, matrix):
        return _exceptionTranslate(self.implRef.setMatrix, matrix)

class TreeDecomposeImplWrapper(CipresIDL_api1__POA.TreeDecompose, ImplWrapper):
    def leafSetDecompose(self, tree):
        _exceptionTranslate(self.implRef.leafSetDecompose, tree)

class _TreeImproveBehavior:
    def improveTree(self, proxyConsumer):
        try:
            improved = _exceptionTranslate(self.implRef.improveTree, proxyConsumer)
            return _exceptionTranslate(toIDLTree, improved)
        except:
            logException(_LOG) # in the current API, treeImprove does not raise any exceptions
            return nilTree()

class TreeEvaluateImplWrapper(CipresIDL_api1__POA.TreeEvaluate, TreeMatrixDependentImplWrapper):
    def evaluateTree(self, proxyConsumer):
        scored = _exceptionTranslate(self.implRef.evaluateTree, proxyConsumer)
        return _exceptionTranslate(toIDLTree, scored)

class TreeImproveImplWrapper(CipresIDL_api1__POA.TreeImprove, _TreeImproveBehavior,  TreeMatrixDependentImplWrapper):
    pass

class TreeInferImplWrapper(CipresIDL_api1__POA.TreeInfer, MatrixDependentImplWrapper):
    def inferTree(self, proxyConsumer):
        try:
            inferred = _exceptionTranslate(self.implRef.inferTree, proxyConsumer)
            return _exceptionTranslate(toIDLTree, inferred)
        except:
            logException(_LOG) # in the current API, inferTree does not raise any exceptions
            return nilTree()

class TreeMergeImplWrapper(CipresIDL_api1__POA.TreeMerge, ImplWrapper):
    def mergeTrees(self, trees):
        merged = _exceptionTranslate(self.implRef.mergeTrees, trees)
        return _exceptionTranslate(toIDLTree, merged)
        
class TreeSupplierImplWrapper(CipresIDL_api1__POA.TreeSupplier, ImplWrapper):
    def getNumTrees(self):
        return _exceptionTranslate(self.implRef.getNumTrees)
    def getTree(self, treeIndex, outOfRangeBehavior):
        tree = _exceptionTranslate(self.implRef.getTrees, treeIndex, outOfRangeBehavior)
        return _exceptionTranslate(toIDLTree, tree)
    def getTrees(self, fromIndex, toIndex, outOfRangeBehavior):
        trees = _exceptionTranslate(self.implRef.getTrees, fromIndex, toIndex, outOfRangeBehavior)
        return _exceptionTranslate(map, toIDLTree, tree)
    def tell(self):
        return _exceptionTranslate(self.implRef.tell)
    def seek(self, treeIndex, outOfRangeBehavior):
        return _exceptionTranslate(self.implRef.seek, treeIndex, outOfRangeBehavior)
    def next(self, numTrees, outOfRangeBehavior):
        tree = _exceptionTranslate(self.implRef.next, numTrees, outOfRangeBehavior)
        return _exceptionTranslate(toIDLTree, tree)

        
class TreeRefineImplWrapper(CipresIDL_api1__POA.TreeRefine, TreeMatrixDependentImplWrapper):
    def refineTree(self):
        refined = _exceptionTranslate(self.implRef.refineTree)
        return _exceptionTranslate(toIDLTree, refined)

class Rid3TreeImproveWrapper(CipresIDL_api1__POA.Rid3TreeImprove, _TreeImproveBehavior, TreeMatrixDependentImplWrapper, RecursiveScriptableWrapper):
    pass
class DelegatingTreeImproveWrapper(CipresIDL_api1__POA.DelegatingTreeImprove, _TreeImproveBehavior, TreeMatrixDependentImplWrapper, RecursiveScriptableWrapper):
    pass

class RendezVousImplWrapper(CipresIDL_api1__POA.RendezVous, ImplWrapper):
    def disconnect(self):
        return _exceptionTranslate(self.implRef.disconnect)
    def reconnect(self, regEnt):
        return _exceptionTranslate(self.implRef.reconnect, regEnt)

class AsyncTreeIteratorImplWrapper(CipresIDL_api1__POA.AsyncTreeIterator, CipresIDL_api1__POA.TreeIterator, RendezVousImplWrapper):
    def getFirstTree(self):
        t = _exceptionTranslate(self.implRef.getFirstTree)
        return _exceptionTranslate(toIDLTree, t)
    def getLastTree(self):
        t =  _exceptionTranslate(self.implRef.getLastTree)
        return _exceptionTranslate(toIDLTree, t)
    def getNextTree(self):
        t = _exceptionTranslate(self.implRef.getNextTree)
        return _exceptionTranslate(toIDLTree, t)
    def getPreviousTree(self):
        t = _exceptionTranslate(self.implRef.getPreviousTree)
        return _exceptionTranslate(toIDLTree, t)
    def getTreeByIndex(self, whichTree):
        t = _exceptionTranslate(self.implRef.getTreeByIndex, whichTree)
        return _exceptionTranslate(toIDLTree, t)
    def pop(self):
        t = _exceptionTranslate(self.implRef.pop)
        return _exceptionTranslate(toIDLTree, t)
    def push(self, treeParam):
        return _exceptionTranslate(self.implRef.push, treeParam)
    def shift(self):
        t = _exceptionTranslate(self.implRef.shift)
        return _exceptionTranslate(toIDLTree, t)
    def unshift(self, treeParam):
        return _exceptionTranslate(self.implRef.unshift, treeParam)
    def getNumTrees(self):
        return _exceptionTranslate(self.implRef.getNumTrees)
    def exists(self, treeInd):
        return _exceptionTranslate(self.implRef.exists, treeInd)

class AsyncTreeInferImplWrapper(CipresIDL_api1__POA.AsyncTreeInfer, AsyncTreeIteratorImplWrapper):
    def __init__(self, argv, registry, implRef):
        self.argv = list(argv)
        self.registry = registry
        RendezVousImplWrapper.__init__(self, argv, registry, implRef)
    def setMatrix(self, matrix):
        return _exceptionTranslate(self.implRef.setMatrix, matrix)
    def inferTrees(self, outStream):
        atiRef = _exceptionTranslate(self.implRef.inferTrees, outStream)
        #atiWrapper = AsyncTreeIteratorImplWrapper(self.argv, self.registry, atiRef)
        #atiWrapper = AsyncTreeInferImplWrapper(self.argv, self.registry, atiRef)
        return self._this()

wrapperDict = {
    'AsyncTreeInfer': AsyncTreeInferImplWrapper,
    'AsyncTreeIterator': AsyncTreeIteratorImplWrapper,
    'TreeDecompose': TreeDecomposeImplWrapper,
    'TreeEvaluate': TreeEvaluateImplWrapper,
    'TreeMerge': TreeMergeImplWrapper,
    'TreeImprove': TreeImproveImplWrapper,
    'TreeInfer': TreeInferImplWrapper,
    'TreeRefine': TreeRefineImplWrapper,
    'RendezVous': RendezVousImplWrapper,
    'Rid3TreeImprove': Rid3TreeImproveWrapper,
    'DelegatingTreeImprove': DelegatingTreeImproveWrapper,
    'ModelSupplier' : ModelSupplierImplWrapper,
    }