from  generic.gn_request   import   Request # 
from  generic.gn_neocredit    import   gn_neocredit #
from datetime import datetime

import json
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

#Link da documentação API
# https://integracao.neocredit.com.br/docs#/

#Link API
# https://integracao.neocredit.com.br/


#Link API Historico Financeiro
# https://neocredit.movidesk.com/kb/pt-br/article/498128/api-documentacao-da-api-de-historico-financeiro?ticketId=&q=



class neocredit(gn_neocredit):
    
    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.token = ""
        
        self.rote_handler()
        #client_id       =   self.get_token('client_id')
        token            =   self.get_token('token')
        
        environment = '' if self.environment_config.get('ambiente') == 'H' else ''
        urls    = self.get_url_environment(environment=environment)
        #auth   = self.generateOAuth2Token(urls.get('oAuth2'), client_id, client_secret )
        
        self.neocredit_request = Request(
                base_url = urls.get('base_url')
            ,   params   = {
                **self.get_token('gw-dev-app-key')
                #'gw-dev-app-key': 'd27b677902ffabb01369e17d00050a56b991a5b9'
            },
            verify= False,
            headers={
                'Accept-Type': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': 'Bearer {token}'.format(**token)
                
            }
        )
        super(neocredit, self, ).__init__(argv)
        
        
        print('Fim')
        
    
    def get_url_environment(self, environment=''):
        base = f'{environment}app-api.neocredit.com.br'
        return {
            "oAuth2"    :f"https://oauth{base}/oauth/token",
            "base_url"  :f"https://{base}/"
        }
    
    
    def generateOAuth2Token(self, url, client_id, client_secret):
        # """Api do banco do brasil requeer autenticacao OAuth2 - 
        # Args:
        #     url (str): endpoit de authenticacao 
        #     client_id (str): cliente id fornecido dentro do do portal BB
        #     client_secret (str): cliente secret fornecido dentro do portal BB
        # """
        import base64
        Authorization = "Basic "+base64.b64encode(
            bytes('{client_id}:{client_secret}'.format(
                    **client_id, **client_secret
                    ), encoding='utf8'
                )
        ).decode("utf-8")
        
        
        OAuth2 = Request(
            #auth     = (client_id, client_secret)
            method='POST',
            verify=False,
            headers  = {
                "Authorization": Authorization,
                "Content-Type":"application/x-www-form-urlencoded",
            },
            data= {
                "grant_type": "client_credentials",
                "scope": "cobrancas.boletos-requisicao cobrancas.boletos-info"
            }
            
        ).doRequest(url=url+"/");
        
        
        if not OAuth2.ok: 
            self.createLog('APIERROR',f"ERRO ao criar token - Necessario criacao de novo token {OAuth2.text}")
            exit(1)
        
        return OAuth2.json()
        
    
    def post_route_handler_solicitacao_analise_credito(self):
        #""" Rota de inclusao e alteracao de boleto tratamento de envio"""
        
        use_softdib_api = self.atualWs.get('use_softdib_api')
        
        if use_softdib_api == None or use_softdib_api: 
            self.define_sd_request('/app/callback/authentication/')
            
        self.token = self.softdib_request .kwargs["headers"]["x-access-token"]
        
        self.template = self.getTemplate()
        
        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)
            #data_parsed  = self.parser(request, request_structure)
            response = self.handle_send(data_parsed)
            
            self.afterSend_solicitacao_analise_credito(data.get('C'), response)
            
    def afterSend_solicitacao_analise_credito(self, data, response):
        
        self.relatement({
            'NMTABELA': 'NEOCREDIT_API',
            'IDSOFTDIB': data[0].get('IDSOFTDIB').get('valor'),
            'NMNOMEAPI': 'neocredit',
            'IDAPI': response.get('id_analise'),
            "DTULTIMAALTERACAO" : "now()"
        })
        
    def beforeSend_solicitacao_analise_credito(self,data):
        self.current_rote="solicitacao/analise-credito"
        
    def handle_output_solicitacao_analise_credito(self, data):
        #"""Tratamento de retorno dos metodos PATCH e POST """
        output = "|".join([ str(value) for key,value in data.items()]) + "\n"
        
        if(output):
            flag = "w+" if self.output_count == 0 else "a+"
            self.write_file(output, self.saida_cobol ,flag= flag, encoding='iso-8859-1' )
            self.output_count = +1
            
        return data
        
    
    def format_date_bb(self, value):
        """ Metodo para formatacao de dadas para o BB"""
        if value:
            date = datetime.strptime(value,"%Y-%m-%d")
            return  datetime.strftime(date,"%d.%m.%Y")
            
        return ""
        
    
    def custom_flag_status(self, value, key):
        return "OK"  if self.neocredit_request.req.status_code==200 else "ER"
     
        
    #"Metodos com valores padrao"
    def custom_default_value(self, data, item):
        default_values = {
                "documento"                    : 'documento'
            
        }
        
        return data or self.current_data.get(default_values.get(item.get('from',''),''),'')
        
        
    def custom_headers_callback_Authorization(self, item):
        return  self.token
            
    def custom_parametros_adicionais(self, value):
        json_dumps = f'["filial: {value}"]'
        return json.loads(json_dumps)
    
    
            
    def custom_body(self, value, item):
        print (value)
        print (item)
        
        keys = item['from'].split(' || ')
        data = json.loads(value)
        
        item_value = data[keys[1]]
        
        return item_value
    
    

        
    #! NÃO SERA PRECISO GERAR O QRCODE POR AQUI
    """ def gerarCrc16(self, payload):
        crc16 = crcmod.mkCrcFun(poly=0x11021, initCrc=0xFFFF, rev=False, xorOut=0x0000)
        self.crc16Code = hex(crc16(str(payload).encode('utf-8')))
        self.crc16Code_formatado = str(self.crc16Code).replace('0x', '').upper()
        self.payload_completa = f'{payload}{self.crc16Code_formatado}'
        self.gerarQrCode(self.payload_completa)
        
    
    def gerarQrCode(self, payload):
        import qrcode
        self.qrcode = qrcode.make(payload)
        self.qrcode.save('logs/pixqrcode.png')
        
        return print(payload) """