import grpc
import os
import sys

sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'generated'))

from Empty_pb2 import Empty
import Commands_pb2 as Cmd
import Commands_pb2_grpc as CmdRpc
from .Case import Case

class Commands:
    """Command executor which can run ResInsight Command File commands nearly verbatim
    
    Documentation Command File Interface:
        https://resinsight.org/docs/commandfile/

    The differences are:
        * Enum values have to be provided as strings. I.e. "ALL" instead of ALL.
        * Booleans have to be specified as correct Python. True instead of true.
    
    """
    def __init__(self, channel):
        self.channel = channel
        self.commands = CmdRpc.CommandsStub(channel)

    def __execute(self, **commandParams):
        try:
            return self.commands.Execute(Cmd.CommandParams(**commandParams))
        except grpc.RpcError as e:
            if e.code() == grpc.StatusCode.NOT_FOUND:
                print("Command not found", commandParams.keys())
            else:
                print("Other error", e)

    ########################
    # Case Control Commands
    ########################

    def openProject(self, path):
        """Open a project
        
        Arguments:
            path (str): path to project file
        
        
        """
        return self.__execute(openProject=Cmd.FilePathRequest(path=path))

    def closeProject(self):
        """Close the current project (and reopen empty one)"""
        return self.__execute(closeProject=Empty())

    def setStartDir(self, path):
        """Set current start directory
        
        Arguments:
            path (str): path to directory
        
        """
        return self.__execute(setStartDir=Cmd.FilePathRequest(path=path))

    def loadCase(self, path):
        """Load a case
        
        Arguments:
            path (str): path to EGRID file
        
        Returns:
            A Case object
        
        """
        commandReply = self.__execute(loadCase=Cmd.FilePathRequest(path=path))
        assert commandReply.HasField("loadCaseResult")
        return Case(self.channel, commandReply.loadCaseResult.id)

    def replaceCase(self, newGridFile, caseId=0):
        """Replace the given case with a new case loaded from file
        
        Arguments:
            newGridFile (str): path to EGRID file
            caseId (int): case Id to replace
            
        """
        return self.__execute(replaceCase=Cmd.ReplaceCaseRequest(newGridFile=newGridFile,
                                                               caseId=caseId))
    
    def replaceSourceCases(self, gridListFile, caseGroupId=0):
        """Replace all source cases within a case group
        
        Arguments:
            gridListFile (str): path to file containing a list of cases
            caseGroupId (int): id of the case group to replace
        
        """
        return self.__execute(replaceSourceCases=Cmd.ReplaceSourceCasesRequest(gridListFile=gridListFile,
                                                                             caseGroupId=caseGroupId))
    ##################
    # Export Commands
    ##################

    def exportMultiCaseSnapshots(self, gridListFile):
        """Export snapshots for a set of cases
        
        Arguments:
            gridListFile (str): Path to a file containing a list of grids to export snapshot for
        
        """
        return self.__execute(exportMultiCaseSnapshot=Cmd.ExportMultiCaseRequest(gridListFile=gridListFile))

    def exportSnapshots(self, type = 'ALL', prefix=''):
        """ Export snapshots of a given type
        
        Arguments:
            type (str): Enum string ('ALL', 'VIEWS' or 'PLOTS')
            prefix (str): Exported file name prefix
        
        """
        return self.__execute(exportSnapshots=Cmd.ExportSnapshotsRequest(type=type,
                                                                       prefix=prefix))

    def exportProperty(self, caseId, timeStep, property, eclipseKeyword=property, undefinedValue=0.0, exportFile=property):
        """ Export an Eclipse property

        Arguments:
            caseId (int): case id
            timeStep (int): time step index
            property (str): property to export
            eclipseKeyword (str): Eclipse keyword used as text in export header. Defaults to the value of property parameter.
            undefinedValue (double):	Value to use for undefined values. Defaults to 0.0
            exportFile (str):	Filename for export. Defaults to the value of property parameter
        """
        return self.__execute(exportProperty=Cmd.ExportPropertyRequest(caseId=caseId,
                                                                     timeStep=timeStep,
                                                                     property=property,
                                                                     eclipseKeyword=eclipseKeyword,
                                                                     undefinedValue=undefinedValue,
                                                                     exportFile=exportFile))

    def exportPropertyInViews(self, caseId, viewNames, undefinedValue):
        if isinstance(viewNames, str):
            viewNames = [viewNames]

        return self.__execute(exportPropertyInViews=Cmd.ExportPropertyInViewsRequest(caseId=caseId,
                                                                                   viewNames=viewNames,
                                                                                   undefinedValue=undefinedValue))

    def exportWellPathCompletions(self, caseId, timeStep, wellPathNames, fileSplit,
                                  compdatExport, includePerforations, includeFishbones,
                                  excludeMainBoreForFishbones, combinationMode):
        if (isinstance(wellPathNames, str)):
            wellPathNames = [wellPathNames]
        return self.__execute(exportWellPathCompletions=Cmd.ExportWellPathCompRequest(caseId=caseId,
                                                                                    timeStep=timeStep,
                                                                                    wellPathNames=wellPathNames,
                                                                                    fileSplit=fileSplit,
                                                                                    compdatExport=compdatExport,
                                                                                    includePerforations=includePerforations,
                                                                                    includeFishbones=includeFishbones,
                                                                                    excludeMainBoreForFishbones=excludeMainBoreForFishbones,
                                                                                    combinationMode=combinationMode))

    def exportSimWellFractureCompletions(self, caseId, viewName, timeStep, simulationWellNames, fileSplit, compdatExport):
        if(isinstance(simulationWellNames, str)):
            simulationWellNames = [simulationWellNames]
        return self.__execute(exportSimWellFractureCompletions=Cmd.ExportSimWellPathFraqRequest(caseId=caseId,
                                                                                              viewName=viewName,
                                                                                              timeStep=timeStep,
                                                                                              simulationWellNames=simulationWellNames,
                                                                                              fileSplit=fileSplit,
                                                                                              compdatExport=compdatExport))

    def exportMsw(self, caseId, wellPath):
        return self.__execute(exportMsw=Cmd.ExportMswRequest(caseId=caseId,
                                                           wellPath=wellPath))

    def exportWellPaths(self, wellPaths=[], mdStepSize=5.0):
        if isinstance(wellPaths, str):
            wellPaths = [wellpaths]
        return self.__execute(exportWellPaths=Cmd.ExportWellPathRequest(wellPathNames=wellPaths, mdStepSize=mdStepSize))

    def exportVisibleCells(self, caseId, viewName, exportKeyword='FLUXNUM', visibleActiveCellsValue=1, hiddenActiveCellsValue=0, inactiveCellsValue=0):
        return self.__execute(exportVisibleCells=Cmd.ExportVisibleCellsRequest(caseId=caseId,
                                                                             viewName=viewName,
                                                                             exportKeyword=exportKeyword,
                                                                             visibleActiveCellsValue=visibleActiveCellsValue,
                                                                             hiddenActiveCellsValue=hiddenActiveCellsValue,
                                                                             inactiveCellsValue=inactiveCellsValue))
    def setExportFolder(self, type, path, createFolder=False):
        return self.__execute(setExportFolder=Cmd.SetExportFolderRequest(type=type,
                                                                       path=path,
                                                                       createFolder=createFolder))

    def runOctaveScript(self, path, cases):
        caseIds = []
        for case in cases:
            caseIds.append(case.id)
        return self.__execute(runOctaveScript=Cmd.RunOctaveScriptRequest(path=path,
                                                                       caseIds=caseIds))
        
    def setMainWindowSize(self, width, height):
        return self.__execute(setMainWindowSize=Cmd.SetMainWindowSizeParams(width=width, height=height))

    def computeCaseGroupStatistics(self, caseIds):
        if isinstance(caseIds, int):
            caseIds = [caseIds]
        return self.__execute(computeCaseGroupStatistics=Cmd.ComputeCaseGroupStatRequest(caseIds=caseIds))

    def setTimeStep(self, caseId, timeStep):
        return self.__execute(setTimeStep=Cmd.SetTimeStepParams(caseId=caseId, timeStep=timeStep))

    def scaleFractureTemplate(self, id, halfLength, height, dFactor, conductivity):
        return self.__execute(scaleFractureTemplate=Cmd.ScaleFractureTemplateRequest(id=id,
                                                                                   halfLength=halfLength,
                                                                                   height=height,
                                                                                   dFactor=dFactor,
                                                                                   conductivity=conductivity))

    def setFractureContainment(self, id, topLayer, baseLayer):
        return self.__execute(setFractureContainment=Cmd.SetFracContainmentRequest(id=id,
                                                                                 topLayer=topLayer,
                                                                                 baseLayer=baseLayer))

    def createMultipleFractures(self, caseId, templateId, wellPathNames, minDistFromWellTd,
                                maxFracturesPerWell, topLayer, baseLayer, spacing, action):
        if isinstance(wellPathNames, str):
            wellPathNames = [wellPathNames]
        return self.__execute(createMultipleFractures=Cmd.MultipleFracAction(caseId=caseId,
                                                                           templateId=templateId,
                                                                           wellPathNames=wellPathNames,
                                                                           minDistFromWellTd=minDistFromWellTd,
                                                                           maxFracturesPerWell=maxFracturesPerWell,
                                                                           topLayer=topLayer,
                                                                           baseLayer=baseLayer,
                                                                           spacing=spacing,
                                                                           action=action))

    def createLgrForCompletions(self, caseId, timeStep, wellPathNames, refinementI, refinementJ, refinementK, splitType):
        if isinstance(wellPathNames, str):
            wellPathNames = [wellPathNames]
        return self.__execute(createLgrForCompletions=Cmd.CreateLgrForCompRequest(caseId=caseId,
                                                                                timeStep=timeStep,
                                                                                wellPathNames=wellPathNames,
                                                                                refinementI=refinementI,
                                                                                refinementJ=refinementJ,
                                                                                refinementK=refinementK,
                                                                                splitType=splitType))

    def createSaturationPressurePlots(self, caseIds):
        if isinstance(caseIds, int):
            caseIds = [caseIds]
        return self.__execute(createSaturationPressurePlots=Cmd.CreateSatPressPlotRequest(caseIds=caseIds))