import time
from  generic.gn_request   import   Request # 
from  generic.gn_dare_sp    import   gn_dare_sp #
from datetime import datetime

import json
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)


class dare_sp(gn_dare_sp):
    
    def __init__(self, argv:list):
        self.response = None
        self.db = False
        self.output_count = 0
        self.suffix = "app_generic" 
        self.unparsed_data = {}
        self.setup(argv)
        
        self.rote_handler()
        
        apiKey        =   self.get_token_data('apiKey')
        
        environment = 'homolog' if self.environment_config.get('ambiente') == 'H' else ''
        
        urls   = self.get_url_environment(environment=environment)
        
        self.dare_sp_request = Request(
                base_url = urls.get('base_url')
            ,   params   = {},
                verify= False,
                headers={
                    'api-key': f"{apiKey}",
                }
        )
         
        super(dare_sp, self, ).__init__(argv)
        
        
        print('Fim')
        
    
    def get_url_environment(self, environment='homolog'):
        # PAREI AQUI
        base = f'{environment}'
        
        """
        As URLs da API são:
		HOMOLOGAÇÃO: https://apigateway-hml.fazenda.sp.gov.br/dare-icms 
		PRODUÇÃO:  https://apigateway.fazenda.sp.gov.br/dare-icms
		"""	
        
        if environment == 'homolog':
            base = "-hml"
        else:
            base = ""

        return {
            "base_url"  :f"https://apigateway{base}.fazenda.sp.gov.br/dare-icms/"
        }
    


     ####    #####    ######     ##     #####
    ##  ##   ##  ##     ##      ####    ##  ##
    ##       ##  ##     ##     ##  ##   ##  ##
    ##       #####      ##     ##  ##   #####
    ##  ##   ## ##      ##     ######   ## ##
     ####    ##  ##   ######   ##  ##   ##  ##

    
    def post_route_handler_dare_unitario_emitir(self):
        #""" Rota de inclusao e alteracao de boleto tratamento de envio"""
        data = self.txt_to_dict()
        for request in data.get('C'):
            self.unparsed_data  = request
            request_structure   = self.atualWs.get('request')
            data_parsed  = self.parser(request, request_structure)
            self.dados_requisicao = request
            #data_parsed  = self.parser(request, request_structure)
            self.handle_send(data_parsed)

    def handle_output_dare_unitario_emitir(self, data):
        
        retorno_cobol = ""

        if self.api_request.req.ok: 
            dare_json = self.api_request.req.json()

            if dare_json.get('erro', {}).get('estaOk', False) is False:
                mensagens = dare_json.get('erro', {}).get('mensagens', ['Erro desconhecido'])
                if isinstance(mensagens, list):
                    mensagens_texto = ", ".join(mensagens)
                else:
                    mensagens_texto = str(mensagens)
                retorno_cobol = "ER|" + mensagens_texto + "|"
            elif dare_json.get('erro', {}).get('estaOk', False):

                dare_get = self.create_getter(dare_json)

                retorno = [
                    dare_get("codigoBarra44"),
                    dare_get("codigoBarra48"),
                    dare_get("observacao"),
                    dare_get("pixCopiaCola"),
                    dare_get("valor"),
                    dare_get("valorMulta"),
                    dare_get("valorTotal"),
                    self.rote_data['path']['saida_pdf']
                ]

                retorno_cobol = "OK||"

                self.base64_para_pdf(dare_get("documentoImpressao"), self.rote_data['path']['saida_pdf'])

                retorno_cobol += "|".join(retorno) + "|"
        else: 
            retorno_cobol = "ER|" + self.api_request.req.text + "|"

        flag = "w+" if self.output_count == 0 else "a+"
        self.write_file(retorno_cobol, self.saida_cobol, flag=flag, encoding='iso-8859-1')

    def create_getter(self, obj):
        """ 
        Cria uma função getter personalizada para um objeto específico
        """
        def get(path, default=None):
            try:
                keys = path.split('.')
                current = obj
                
                for key in keys:
                    current = current[key]
                
                return self.treat_value(current)
            except (KeyError, TypeError, AttributeError):
                return default
        
        return get
    
    def treat_value(self, value):
        if isinstance(value, (bool)):
            return "S" if value else "N"
        elif value is None:
            return ""
        elif value == False and not isinstance(value, (int, float)):
            return "N"
        elif value == True and not isinstance(value, (int, float)):
            return "S"
        elif value == 'False':
            return "N"
        elif value == 'True':
            return "S"
        elif isinstance(value, (int, float)):
            return str(value)
        elif isinstance(value, str):
            return value
        elif isinstance(value, (list, tuple)):
            return value if value else ""
        else:
            return str(value)

    def to_boolean(self, value, path):
        if value == "S":
            return True
        elif value == "N":
            return False
        
    def base64_para_pdf(self, base64_string, saida_pdf):
        import base64
        import os
        """
        Converte uma string base64 em arquivo PDF e salva na pasta especificada.
        
        Args:
            base64_string (str): String base64 do arquivo PDF
            pasta_destino (str): Caminho da pasta onde salvar o PDF
            nome_arquivo (str, optional): Nome do arquivo (sem extensão). 
                                        Se None, usa timestamp atual.
        
        Returns:
            str: Caminho completo do arquivo salvo
            
        Raises:
            ValueError: Se o base64 for inválido
            OSError: Se houver problemas com o diretório ou salvamento
        """
        try:
            # Remove o prefixo "data:application/pdf;base64," se existir
            if base64_string.startswith('data:'):
                base64_string = base64_string.split(',')[1]
            
            # Decodifica o base64
            pdf_data = base64.b64decode(base64_string)
            
            # Salva o arquivo PDF
            with open(saida_pdf, 'wb') as arquivo_pdf:
                arquivo_pdf.write(pdf_data)
            
            print(f"PDF salvo com sucesso em: {saida_pdf}")
            return saida_pdf
            
        except base64.binascii.Error:
            raise ValueError("String base64 inválida")
        except Exception as e:
            raise OSError(f"Erro ao salvar o arquivo: {str(e)}")