import re, hashlib, datetime, os, constant

class FileGenerator:

    """
        tipo do arquivo template
    """
    fileType = ''

    """
        Diretório onde ficam os templates
    """
    fileBase = ''
    
    fileCode = {
        0:False,
        1:'teste',
    }

    rootAddr = '/var/www/%s' % constant.hostname


    filePrefix = ''
    fileText = ''
    fileName = False
    fileAddr = False
    fileVars = {}

    fileHash = False

    """
        Usado para montar um PDF com vários HTMLs
    """
    fileLoop = []

    def __init__(self,**kwargs):
        """
            Define o tipo de arquivo a ser processado
        """
        self.fileType = kwargs.get('type','pdf')

        """
            Define onde fica a rais de arquivos
        """
        self.fileBase = kwargs.get('base','html')

        prefix = kwargs.get('prefix',False)
 
        if prefix:
            self.setPrefix(prefix)

    def setPrefix(self,prefix):
        self.filePrefix = '%s/%s_' % (prefix,prefix)
        return self.filePrefix

    def setCode(self,code):
        """
            Código do arquivo arquivo
            Define qual modelo arquivo será utilizado.
            Recomendado para arquivos unicos
        """

        self.fileName = self.fileCode.get(code,0)
        self.fileAddr = self.getFileAddr()
        return True

    def setLoop(self,loop):
        """
            Loop do arquivo arquivo
            Define quais modelos PDF serão utilizados.
            Recomendado para arquivos em pedaços
        """

        loop.insert(0,'start')
        loop.append('end')
        self.fileLoop = loop
        return True

    def setVars(self,vars):
        """
            Variáveis a serem utilizadas na criação do arquivo
        """
        self.fileVars = vars
        return True
    
    def getFileAddr(self,**kwargs):
        """
            Retorna endereço relativo do arquivo
        """
        if not self.fileName:
            self.fileName = kwargs.get('name',False)

            if not self.fileName:
                raise Exception("Filename")

        addrVars = {
            'root': self.rootAddr,
            'type': self.fileType,
            'name': self.fileName,
            'base': self.fileBase,
            #MOD-001 | 'typeUpper': self.fileType.capitalize(),
            'category':kwargs.get('category','').capitalize(),
            'prefix':self.filePrefix
        }

        

        #MOD-001 | return './%(base)s/%(type)s/%(name)s%(category)s%(typeUpper)s.%(type)s' % addrVars
        addr = '%(root)s/%(base)s/%(type)s/%(prefix)s%(name)s%(category)s.%(type)s' % addrVars

        print('=============+>',addr)
        
        return addr

    def getFileTemp(self):
        return './_tmp/%s' % self.getFileHashName()

    def erros(self):
        """
            Checa se o arquivo existe
        """

        fileExists = os.path.isfile(self.getFileTemp())

        if not fileExists:
            """
                Caso o arquivo não exista
                Há erro
            """
            return True

        return False

    def getTextFromFile(self,name):
        
        file = False

        if self.fileType == 'pdf':
            text = file.read()

        if self.fileType == 'conf' or self.fileType == 'html':
            self.fileName = name
            file = open(self.getFileAddr(name=name), "r")
            text = file.read()

        if file:
            file.close()

        return text

    def getFileHashName(self):
        """
            Cria ou retorna o nome temporário do arquivo
        """

        if not self.fileHash:
            date = str(datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')).encode('UTF-8')
            self.fileHash = hashlib.sha1(date).hexdigest()
        
        return self.fileHash

    def make(self):
        """
            Gera o ARQUIVO
        """

        text = ''

        if len(self.fileLoop):
            for loop in self.fileLoop:
                text += self.getTextFromFile(loop)
                
        for k,v in self.fileVars.items():
            
            delimiterA = '{'
            delimiterB = '}'

            if isinstance(v,list):
                """
                    Detecta blocos.
                    Não sai do loop, enquanto não concluir todas as entries
                """
                delimiterA = '['
                delimiterB = ']'
                i = 0
                blockDataText = '' 
                blockFileList = list()
                while i < len(v):
                    
                    blockFileName = '%sBlock' % k
                    blockFileText = self.getTextFromFile(blockFileName)

                    self.debug.writeAlert('VALUE TYPE',type(v[i]),'for',blockFileName)

                    if not isinstance(v[i],list):

                        for blockKey,blockVal in v[i].items():
                            """
                                Para cada Key e Valor da entry
                                "idResumo" : 1,
                                "textResumo" : "Testando o resumo"
                            """

                            if blockVal is None:
                                """
                                    Deixa valor vazio caso não seja encontrado
                                """
                                blockVal = '-'

                            ##self.debug.write("BLOCK VAL",type(blockVal))
                            ##self.debug.write("BLOCK KEY",type(blockKey))

                            if isinstance(blockVal,dict):
                                """
                                    Se o valor da key for um objeto
                                    ...
                                    "contaCli" : {
                                        "id":123,
                                        "name":"teste"
                                    },
                                    ...
                                """

                                i2 = 0
                                ##self.debug.write("blockVal",blockVal)

                                for blockKey2,blockVal2 in blockVal.items():
                                    """
                                        Procura por KEY_KEY2
                                    """
                                    #self.debug.writeAlert('BUSCANDO','%s_%s' % (blockKey,blockKey2))
                                    #self.debug.writeAlert('TROCA POR','%s' % str(blockVal2))
                                    blockFileText = re.sub(r'\_%s{2}\_(%s\_%s)\_%s{2}\_' % (delimiterA,blockKey,blockKey2,delimiterB),str(blockVal2),blockFileText,10,re.IGNORECASE)
                        
                                    i2 += 1

                            blockFileText = re.sub(r'\_%s{2}\_(%s)\_%s{2}\_' % (delimiterA,blockKey,delimiterB),str(blockVal),blockFileText,10,re.IGNORECASE)

                    else:
                        self.debug.writeAlert("V ITEM IS A LIST",v[i])
                    
                    blockDataText += blockFileText
                    i += 1
                
                v = blockDataText

            if isinstance(v,dict):
                """
                    Se o valor da key for um objeto
                    ...
                    "contaCli" : {
                        "id":123,
                        "name":"teste"
                    },
                    ...
                """

                i2 = 0
                ##self.debug.write("blockVal",blockVal)

                for blockKey2,blockVal2 in v.items():
                    """
                        Procura por KEY_KEY2
                    """
                    #self.debug.writeAlert('BUSCANDO','%s_%s' % (blockKey,blockKey2))
                    #self.debug.writeAlert('TROCA POR','%s' % str(blockVal2))
                    text = re.sub(r'\_%s{2}\_(%s\_%s)\_%s{2}\_' % (delimiterA,k,blockKey2,delimiterB),str(blockVal2),text,10,re.IGNORECASE)
        
                    i2 += 1

                v = text

            text = re.sub(r'\_\%s{2}\_(%s)\_\%s{2}\_' % (delimiterA,k,delimiterB),str(v),text,10,re.IGNORECASE)

        """
            Limpa variaveis não preenchidas
        """
        text = re.sub(r'(\{|\[|\(){4}.*(\}|\]|\)){4}','',text)
         
        self.fileText = text
        
        return text