"""
Module that allows latex output notebooks to be conditioned before 
they are converted.
"""
from __future__ import absolute_import

# Configurable traitlets
from IPython.utils.traitlets import Unicode, Bool

# Needed to override transformer
from .transformers import (ActivatableTransformer)

class LatexTransformer(ActivatableTransformer):
    """
    Converter for latex destined documents.
    """    

    def cell_transform(self, cell, other, index):
        """
        Apply a transformation on each cell,

        receive the current cell, the resource dict and the index of current cell as parameter.

        Returns modified cell and resource dict.
        """
        if hasattr(cell, "source") and cell.cell_type == "markdown":
            cell.source = self.remove_math_space(cell.source)
        return cell, other

    def remove_math_space(self, text):
        """
        Remove the space between latex math commands and enclosing $ symbols.
        """
        
        # First, scan through the markdown looking for $.  If
        # a $ symbol is found, without a preceding \, assume
        # it is the start of a math block.  UNLESS that $ is
        # not followed by another within two math_lines.
        math_regions = []
        math_lines = 0
        within_math = False
        math_start_index = 0
        index = 0
        last_character = ""
        for char in text: #Loop through each character in the text.
            
            #Make sure the character isn't preceeded by a backslash
            if (char == "$" and last_character != "\\"):
                
                # Close the math region if this is an ending $
                if within_math:
                    within_math = False
                    math_regions.append([math_start_index, index+1])
                else:
                    
                    # Start a new math region
                    within_math = True
                    math_start_index = index
                    math_lines = 0
                    
            # If we are in a math region, count the number of lines parsed.
            # Cancel the math region if we find two line breaks!
            elif char == "\n":
                if within_math:
                    math_lines += 1
                    if math_lines > 1:
                        within_math = False
                        
            # Remember the last character so we can easily watch
            # for backslashes
            last_character = char
            
            # Next index
            index += 1
        
        # Reset the index and last char
        index = 0
        
        # Now that we know what regions of the text are math and
        # what regions aren't, we can separate them into "blocks"
        text_blocks=[]
        math_blocks=[]
        was_math_block = False
        current_block = ""
        for char in text:
            
            # Check if this is a math region.
            ismath = False
            for keypair in math_regions:
                if (keypair[0] <= index and index <=  keypair[1]):
                    ismath = True
            
            # If the region type has changed since the last
            # iteration, commit all read characters to that
            # region type and reset the buffer.
            if (ismath and not was_math_block):
                was_math_block = True
                text_blocks.append(current_block)
                current_block=""
            elif ((not ismath) and was_math_block):
                was_math_block = False
                math_blocks.append(current_block)
                current_block=""
            
            # Store the character
            current_block += char
            
            # Next index
            index += 1
            
        # Save whatever remains in the buffer that hasn't yet been saved.
        if was_math_block:
            math_blocks.append(current_block)
        else:
            text_blocks.append(current_block)
            
        # Recombine the regions, while processing every math region, removing
        # the spaces between the math and the $ symbols.
        output = ""
        for index in range(0,len(text_blocks) + len(math_blocks)):
            if index % 2 == 0:
                output += text_blocks[index/2]
            else:
                mathblock = math_blocks[(index -1)/2]
                mathblock = mathblock[1:len(mathblock)-2]
                output += "$" + mathblock.strip() + "$"
        return output