#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

"""
Class that can turn traversals back into Gremlin Groovy format text queries.
Those queries can then be run in the Gremlin console or using the GLV submit(<String>) API or
sent to any TinkerPop compliant HTTP endpoint.
"""
__author__ = 'Kelvin R. Lawrence (gfxman)'

import math
import numbers
import re

from gremlin_python.process.traversal import *
from gremlin_python.process.strategies import *
from gremlin_python.structure.graph import Vertex, Edge, VertexProperty
from datetime import datetime


class Translator:
    """
    Turn a bytecode object back into a textual query (Gremlin Groovy script).
    """

    # Dictionary used to reverse-map token IDs to strings
    options = {
        WithOptions.tokens: 'tokens',
        WithOptions.none: 'none',
        WithOptions.ids: 'ids',
        WithOptions.labels: 'labels',
        WithOptions.keys: 'keys',
        WithOptions.values: 'values',
        WithOptions.all: 'all',
        WithOptions.indexer: 'indexer',
        WithOptions.list: 'list',
        WithOptions.map: 'map'
    }

    conn_p = ['and', 'or']

    def __init__(self, traversal_source=None):
        self.traversal_source = traversal_source

    def get_traversal_source(self):
        return self.traversal_source

    def get_target_language(self):
        return "gremlin-groovy"

    def of(self, traversal_source):
        self.traversal_source = traversal_source
        return self

    # Do any needed special processing for the representation
    # of strings and dates and boolean.
    def fixup(self, v):
        if isinstance(v, str):
            return f'{v!r}'  # use repr() format for canonical string rep
        elif type(v) == datetime:
            return self.process_date(v)
        elif type(v) == bool:
            return 'true' if v else 'false'
        elif isinstance(v, numbers.Number):
            return self.process_number(v)
        elif isinstance(v, set):
            return f'[{str(v)[1:-1]}]'
        elif isinstance(v, P):
            return self.process_predicate(v)
        elif type(v) == Vertex:
            return self.process_vertex(v)
        elif type(v) == Edge:
            return self.process_edge(v)
        elif type(v) in [Merge]:  # on_create on_match out_v in_v
            tmp = str(v)
            return f'{tmp.split("_")[0]}{tmp.split("_")[1].capitalize()}' if tmp.find('_') else tmp
        elif v is None:
            return 'null'
        else:
            return str(v)

    # Turn a Python datetime into the equivalent new Date(...)
    def process_date(self, date):
        y = date.year - 1900
        mo = date.month
        d = date.day
        h = date.hour
        mi = date.minute
        s = date.second
        return f'new Date({y},{mo},{d},{h},{mi},{s})'

    # Do special processing needed to format predicates that come in
    # such as "gt(a)" correctly.
    def process_predicate(self, p):
        res = ''
        if p.operator in self.conn_p:
            res += f'{self.process_predicate(p.value)}.{p.operator}({self.process_predicate(p.other)})'
        else:
            res += f'{self.process_p_value(p)}'
        return res

    # process the value of the predicates
    def process_p_value(self, p):
        res = str(p).split('(')[0] + '('
        if type(p.value) == list:
            res += '['
            for v in p.value:
                res += self.fixup(v) + ','
            res = (res[0:-1] + ']') if len(p.value) > 0 else (res + ']')
        else:
            res += self.fixup(p.value)
            if p.other is not None:
                res += f',{self.fixup(p.other)}'
        res += ')'
        return res

    # Special processing to handle strategies
    def process_strategy(self, s):
        c = 0
        res = ''
        # if parameter is empty, only pass class name (referenced GroovyTranslator.java)
        if not s.configuration:
            res += s.strategy_name
        else:
            res = f'new {str(s)}('
            for key in s.configuration:
                res += ',' if c > 0 else ''
                res += key + ':'
                val = s.configuration[key]
                if isinstance(val, Traversal):
                    res += self.translate(val.bytecode, child=True)
                else:
                    res += self.fixup(val)
                c += 1
            res += ')'
        return res
        pass

    # Special processing to handle vertices
    def process_vertex(self, vertex):
        return f'new ReferenceVertex({self.fixup(vertex.id)},\'{vertex.label}\')'

    # Special processing to handle edges
    def process_edge(self, edge):
        return f'new ReferenceEdge({str(edge.id)},\'{edge.label}\',' \
               f'new ReferenceVertex({str(edge.inV.id)},\'{edge.inV.label}\'),' \
               f'new ReferenceVertex({str(edge.outV.id)},\'{edge.outV.label}\'))'

    # Special processing to handle vertex property
    def process_vertex_property(self, vp):
        return f'new ReferenceVertexProperty({str(vp.id)},\'{vp.label}\',{self.fixup(vp.value)})'

    # Special processing to handle lambda
    def process_lambda(self, lam):
        lambda_result = lam()
        script = lambda_result if isinstance(lambda_result, str) else lambda_result[0]
        return f'{script}' if re.match(r"^\{.*\}$", script, flags=re.DOTALL) else f'{{{script}}}'

    def process_dict(self, d):
        c = 0
        res = '['
        if len(d) == 0:
            res += ':'
        else:
            for k, v in d.items():
                wrap = not isinstance(k, str)
                res += ',' if c > 0 else ''
                res += '(' if wrap else ''
                res += self.fixup(k)
                res += ')' if wrap else ''
                res += f':{self.fixup(v)}'
                c += 1
        res += ']'
        return res

    def process_number(self, n):
        if isinstance(n, float):
            # converting floats into doubles for script since python doesn't distinguish and java defaults to double
            if math.isnan(n):
                return "Double.NaN"
            elif math.isinf(n) and n > 0:
                return "Double.POSITIVE_INFINITY"
            elif math.isinf(n) and n < 0:
                return "Double.NEGATIVE_INFINITY"
            else:
                return f'{n}d'
        return f'{n}'

    def process_list(self, l):
        c = 0
        res = '['
        for i in l:
            res += ',' if c > 0 else ''
            res += self.fixup(i)
            c += 1
        res += ']'
        return res

    # Special processing to handle bindings inside of traversals
    def process_binding(self, binding):
        return f'Bindings.instance().of(\'{binding.key}\', {str(binding.value)})'

    # Main driver of the translation. Different parts of
    # a Traversal are handled appropriately.
    def do_translation(self, step):
        script = ''
        params = step[1:]
        script += '.' + step[0] + '('
        if len(params) > 0:
            c = 0
            with_opts = False
            is_merge_op = (step[0] == 'mergeV') or (step[0] == 'mergeE')
            for p in params:
                script += ',' if c > 0 else ''
                if with_opts:
                    script += f'WithOptions.{self.options[p]}'
                elif type(p) == Bytecode:
                    script += self.translate(p, True)
                elif isinstance(p, P):
                    script += self.process_predicate(p)
                elif type(p) == Vertex:
                    script += self.process_vertex(p)
                elif type(p) == Edge:
                    script += self.process_edge(p)
                elif type(p) == VertexProperty:
                    script += self.process_vertex_property(p)
                elif type(p) in [Cardinality, Pop, Operator, Scope, T]:
                    tmp = str(p)
                    script += tmp[0:-1] if tmp.endswith('_') else tmp
                elif type(p) in [Merge]:  # on_create on_match out_v in_v
                    is_merge_op = True
                    tmp = str(p)
                    script += f'{tmp.split("_")[0]}{tmp.split("_")[1].capitalize()}' if tmp.find('_') else tmp
                elif isinstance(p, TraversalStrategy):  # this will capture all strategies
                    script += self.process_strategy(p)
                elif type(p) == datetime:
                    script += self.process_date(p)
                elif p == WithOptions.tokens:
                    script += 'WithOptions.tokens'
                    with_opts = True
                elif isinstance(p, str):
                    script += f'{p!r}'  # use repr() format for canonical string rep
                elif type(p) == bool:
                    script += 'true' if p else 'false'
                elif isinstance(p, type(lambda: None)) and p.__name__ == (lambda: None).__name__:
                    script += self.process_lambda(p)
                elif type(p) == Binding:
                    script += self.process_binding(p)
                elif p is None:
                    script += '(Traversal) null' if is_merge_op else 'null'
                elif isinstance(p, type):
                    script += p.__name__
                elif isinstance(p, dict):
                    script += self.process_dict(p)
                elif isinstance(p, numbers.Number):
                    script += self.process_number(p)
                elif isinstance(p, set):
                    script += f'[{str(p)[1:-1]}] as Set' if len(p) > 0 else '[] as Set'
                elif isinstance(p, list):
                    script += self.process_list(p)
                else:
                    script += str(p)
                c += 1
        script += ')'
        return script

    # Translation starts here. There are two main parts to a 
    # traversal. Source instructions such as "withSideEffect"
    # and "withStrategies", and step instructions such as 
    # "addV" and "repeat". If child is True we will generate
    # anonymous traversal style syntax.
    def translate(self, bytecode, child=False):
        script = '__' if child else self.traversal_source

        for step in bytecode.source_instructions:
            script += self.do_translation(step)

        for step in bytecode.step_instructions:
            script += self.do_translation(step)

        return script
