#!/usr/bin/env python
# encoding: utf-8

from generic import Stack,flatten_list
from fraction import Fraction

        

class Render(object):
    """A class which aims to create render functions from three dictionnaries:
        - op_infix: dict of caracters
        - op_postfix: dict of 2 arguments functions
        - other: dict of caracters
    Those three dictionnaries while define how a postfix expression will be transform into a string.
    """

    PRIORITY = {"*" : 3, "/": 3, "+": 2, "-":2, "(": 1}

    def __init__(self, op_infix = {}, op_postfix = {}, other = {}, join = " ", type_render = {int: str, Fraction: str, str: str}):
        """Initiate the render
        
        @param op_infix: the dictionnary of infix operator with how they have to be render
        @param op_postfix: the dictionnary of postfix operator with how they have to be render
        @param other: other caracters like parenthesis.
        @param raw: the caracter for joining the list of tokens (if False then it returns the list of tokens)
        @param type_render: how to render number (str or tex for fractions for example)
        """

        self.op_infix = op_infix
        self.op_postfix = op_postfix
        self.other = other
        # TODO: there may be issues with PRIORITY if a sign does not appear in PRIORITY

        self.join = join
        self.type_render = type_render

        self.operators = list(self.op_infix.keys()) + list(self.op_postfix.keys()) + list(self.other.keys())

    def __call__(self, postfix_tokens):
        """Make the object acting like a function

        :param postfix_tokens: the list of postfix tokens to be render
        :returns: the render string

        """
        operandeStack = Stack()

        
        for token in postfix_tokens:
            if self.isOperator(token):

                op2 = operandeStack.pop()
                if self.needPar(op2, token, "after"):
                    op2 = [self.other["("] ,  op2 , self.other[")"]]

                op1 = operandeStack.pop()
                if self.needPar(op1, token, "before"):
                    op1 = [self.other["("] ,  op1 , self.other[")"]]

                if token in self.op_infix:
                    res = flist([op1 , self.op_infix[token] ,  op2])

                elif token in self.op_postfix:
                    res = flist([self.op_postfix[token](op1, op2)])

                # Trick to remember the main op when the render will be done!
                res.mainOp = token

                operandeStack.push(res)

            else:
                operandeStack.push(token)
            
        # Manip pour gerer les cas de listes imbriquées dans d'autres listes
        infix_tokens = operandeStack.pop()
        if type(infix_tokens) == list or type(infix_tokens) == flist:
            infix_tokens = flatten_list(infix_tokens)
        elif self.isNumber(infix_tokens):
            infix_tokens = [infix_tokens]

        if self.join:
            return self.join.join(flatten_list([self.render_from_type(t) for t in infix_tokens]))
        else:
            return infix_tokens

    def render_from_type(self, op):
        """ If the op is a number, it transforms it with type_render conditions

        :param op: the operator
        :returns: the op transformed if it's necessary

        """
        if self.isNumber(op):
            return self.type_render[type(op)](op)
        else:
            return op


    # ---------------------
    # Tools for placing parenthesis in infix notation

    def needPar(self, operande, operator, posi = "after"):
        """Says whether or not the operande needs parenthesis

        :param operande: the operande
        :param operator: the operator
        :param posi: "after"(default) if the operande will be after the operator, "before" othewise
        :returns: bollean
        """
        if self.isNumber(operande) \
                and type(operande) != str \
                and operande < 0:
            return 1
        elif not self.isNumber(operande):
            # Si c'est une grande expression ou un chiffre négatif
            stand_alone = self.get_main_op(operande)
            # Si la priorité de l'operande est plus faible que celle de l'opérateur
            minor_priority = self.PRIORITY[self.get_main_op(operande)] < self.PRIORITY[operator]
            # Si l'opérateur est -/ pour after ou juste / pour before
            special = (operator in "-/" and posi == "after") or (operator in "/" and posi == "before")

            return stand_alone and (minor_priority or special)
        else:
            return 0

    def get_main_op(self, tokens):
        """Getting the main operation of the list of tokens

        :param exp: the list of tokens
        :returns: the main operation (+, -, * or /) or 0 if the expression is only one element

        """
        if hasattr(tokens, "mainOp"):
            return tokens.mainOp

        if len(tokens) == 1:
            # Si l'expression n'est qu'un élément
            return 0

        parStack = Stack()
        main_op = []

        for token in tokens:
            if token == "(":
                parStack.push(token)
            elif token == ")":
                parStack.pop()
            elif self.isOperator(token) and parStack.isEmpty():
                main_op.append(token)

        return min(main_op, key = lambda s: self.PRIORITY[s])

    ## ---------------------
    ## Recognize numbers and operators

    @staticmethod
    def isNumber( exp):
        """Check if the expression can be a number which means that it is not a operator

        :param exp: an expression
        :returns: True if the expression can be a number and false otherwise

        """
        return type(exp) == int or \
                type(exp) == Fraction or \
                (type(exp) == str and exp.isalpha())
        #return type(exp) == int or type(exp) == Fraction

    def isOperator(self, exp):
        """Check if the expression is in self.operators

        :param exp: an expression
        :returns: boolean

        """
        return (type(exp) == str and exp in self.operators)
        
class flist(list):
    """Fake list- they are used to stock the main operation of an rendered expression"""
    pass


# ------------------------
# A console render

txt_infix = {"+": "+", "-": "-", "*": "*", "/" : "/"}
txt_postfix = {}
txt_other = {"(": "(", ")": ")"}

txt_render = Render(txt_infix, txt_postfix, txt_other)

# ------------------------
# A infix to postfix list convertor

p2i_infix = {"+": "+", "-": "-", "*": "*", "/" : "/"}
p2i_postfix = {}
p2i_other = {"(": "(", ")": ")"}

post2in_fix = Render(p2i_infix, p2i_postfix, p2i_other, join = False)

# ------------------------
# A latex render

def texSlash(op1, op2):
    if not Render.isNumber(op1) and op1[0] == "(" and op1[-1] == ")":
        op1 = op1[1:-1]
    if not Render.isNumber(op2) and op2[0] == "(" and op2[-1] == ")":
        op2 = op2[1:-1]
    return ["\\frac{" , op1 , "}{" , op2 , "}"]

def texFrac(frac):
    return ["\\frac{" , str(frac._num) , "}{" , str(frac._denom) , "}"]

tex_infix = {"+": " + ", "-": " - ", "*": " \\times "}
tex_postfix = {"/": texSlash}
tex_other = {"(": "(", ")": ")"}
tex_type_render = {int: str, Fraction: texFrac, str: str}

tex_render = Render(tex_infix, tex_postfix, tex_other, type_render = tex_type_render)



if __name__ == '__main__':
    exp = [2, 5, '+', 1, '-', 3, 4, '*', '/']
    print(txt(exp))
    exp = [2, 5, '+', 1, '-', 3, 4, '*', '/', 3, '+']
    print(tex(exp))
    exp = [2, 5, '+', 1, '-', 3, 4, '*', '/', 3, '+']
    print(post2in_fix(exp))
    

# -----------------------------
# Reglages pour 'vim'
# vim:set autoindent expandtab tabstop=4 shiftwidth=4:
# cursor: 16 del