
import re, json
from   generic.gn_api       import   gn_api # 
from   generic.gn_request   import   Request # 

class lojainteg(gn_api):
    def __init__(self, argv:list):
        self.db = False
        
        setup   = self.setup(argv)
        
        #self.ApplicationToken  = setup[0][  'NMTOKEN1API']#002e6fc5f068d6323874
        #self.CompanyToken      = setup[0]['NMTOKEN1DADOS']#b42241b9-0f49-4177-814d-ba3d30883bb3
        
                        
        self.lojainteg_request = Request(
                base_url = 'https://api.awsli.com.br/v1/'
            ,   headers={
                'Content-Type'     : 'application/json'
            }
            ,   params   = {
                #    'format'            : 'json' 
                #    'chave_api'         : self.ApplicationToken #self.ApplicationToken
                #,   'chave_aplicacao'   : self.CompanyToken  #self.CompanyToken
                **self.get_token("chave_api"),
                **self.get_token("chave_aplicacao")
                
        }) 
        
        super(lojainteg, self, ).__init__()
        
        print('Fim')
        
    

    #--------------------------------------------------------#
    #--------------- TRATAMENTO CUSTOM ----------------------#
    #--------------------------------------------------------#
        
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO CUSTOM SQL  -----------------#
    #--------------------------------------------------------#
    def quantidade_estoque(self, data):
        return "( SELECT IF(TBPRODUTO.NMUNIDADE IN ('MT','M2'), TBPRODUTO.VLQTDEATUAL * 100, TBPRODUTO.VLQTDEATUAL ) )"
        
    def quantidade_em_estoque(self, data):
        return "( SELECT 2 )"
        
    def quantidade_sem_estoque(self, data):
        return "( SELECT IF(TBPRODUTO.VLTEMPOREPOSICAO > 0, TBPRODUTO.VLTEMPOREPOSICAO, -1) )"
        
    def produto_id(self, data):
        return "( SELECT IF(TBPRODUTO.CDIDAPI > 0, TBPRODUTO.CDIDAPI, 'None') )"
        


    
    def valor_produto(self, data):
        field = data.get('dbfield')
        return f"(SELECT IF(TBPRODUTO.NMUNIDADE IN ('MT','M2'), {field} / 100, {field} ) )"
        #if 'VLPROMOCIONAL' in field:
        #    sql = f" (SELECT IF({sql} > 0, {sql}, 'null' ))"
        #    
        #return sql
        
    
    def cliente_tipo(self, field) :
        return """(SELECT IF({}='J', 'PJ', 'PF') )""".format(field['dbfield'])
        
    
    def imagens_produto_principal(self, field) :
        return """(SELECT IF({}='S', 'true', 'false') )""".format(field['dbfield'])
        
    
    def situacao_pedido_pedido_id(self, field) :
        
        pass
        
    
    #--------------------------------------------------------#
    #--------------- TRATAMENTO BEFORESEND  -----------------#
    #--------------------------------------------------------#
    
    def beforeSend_categoria(self, data) :
        
        if self.current_data['sub_grupo'] == 0 :
            data['categoria_pai'] = None
            
        else :
            data['categoria_pai'] = '/api/v1/categoria/' + self.translate(id = data['categoria_pai'], table = "TBGRUPO")
            
            
        
        return data
        
    
    def beforeSend_cliente(self, data) :
        
        tipo = data['tipo']
        
        if tipo == 'PF' :
            
            data['cnpj'] = None
            data['nome'] = data['razao_social']  
            data['razao_social'] = None
            data['ie'] = None
            
        elif tipo == 'PJ':
            
            data['cpf'] = None
            data['rg'] = None
            
        return data
        
    
    def beforeSend_produto(self, data) :
        
        res = self.api_request.doRequest(
            rote = "produto/?sku={}".format(data.get('sku'))
        )
        
        if res and not res.json().get('objects'):
            return data
        
    
    def before_handle_db_data_(self, data):
        data = []
        print(data)
        return ""
        
    
    #--------------------------------------------------------#
    #------------------ TRATAMENTO RESPONSE  ----------------#
    #--------------------------------------------------------#
    
    def response_code_200(self, req) :
        return super().response_code_201(req)
        
    def response_code_400(self, req) :
        return super().response_code_400(req)
        
        
    #--------------------------------------------------------#
    #--------------- TRATAMENTO FILTROS DE ROTA -------------#
    #--------------------------------------------------------#
    
    def rote_filter_pedido_search(self):
        
        sql =  """
            SELECT 
                DTULTIMAALTERACAO 
            FROM 
                TBRELACIONAID
            WHERE 
                1=1 
            AND 
                NMTABELA = '{table}'
            ORDER BY 
                DTULTIMAALTERACAO DESC 
            LIMIT 1;
        """.format(table=self.atualWs['table'])
        
        fetch = self.getDb().select(sql)
        
        if len(fetch) :
            alterado_apos = fetch[0]['DTULTIMAALTERACAO']
        else :
            alterado_apos = "1980-01-01"
            
        ### return  self.mountRouteParams( { "since_numero": 11776    } )
        return  self.mountRouteParams(
            {
                     "situacao_id" : '4'
                 ,   "since_atualizado" : alterado_apos
                 # "since_numero": 42211
            }
        )
    
    
    #--------------------------------------------------------#
    #---------- TRATAMENTO AFTERSEND  & BEFORESEND ----------#
    #--------------------------------------------------------#
    
    def beforeSend_situacao_pedido_pedido_id(self, data) :
        codigo = data.get('codigo')
        if (codigo and codigo == 'pedido_cancelado') :
            self.atualWs['send'] = False
            
            
        return data
        
    
    def afterSend_situacao_pedido_pedido_id(self, data) :
        
        self.getDb().delete(
                    "TBPEDIDOSSTATUS"
            ,   ["IDTBPEDIDOSSTATUS={}".format(self.current_data['softdib_id'] )]
            )
        codigo = data.get('codigo')
        if (codigo and codigo == 'pedido_cancelado') :
            self.getDb().delete(
                    "TBPEDIDOSRETORNO"
            ,   [
                        "CDPEDIDOEXTERNO={}".format(self.current_data['pedido_id'] )
                    ,   "NMAPI='{}'".format(self.apiName)
                ]
            )
        
    
    #--- ----------------------------------------------------#
    #--------------- TRATAMENTO ITEMS/PEDIDO ----------------#
    #--------------------------------------------------------#
    
    def get_order_items(self, order):
        return [ self.extractValues(item, "itenscarrinho_fields") for item in order.get('itens',[])]
        
    
    def get_order_data(self, order) :
        
        req = self.lojainteg_request.doRequest(
            rote="pedido/{id}".format(id=order['numero'])
        )
        
        if req.status_code == 200 :
            self.current_order =  self.tryJson(req)
            data = [ self.extractValues(self.current_order, 'pedido_fields') ]

            if not data[0]['ENDERECO_NRO_ENT'].isdigit():

                endereco = data[0]['ENDERECO_NRO_ENT'] 
                complemento = data[0]['COMPLEMENTO_ENT']

                numb = ''.join(re.findall(r'\d+', endereco))  # Captura apenas os números
                # comp = ''.join(re.findall(r'[^\d]+', endereco)).strip()  # Captura os caracteres não numéricos e remove espaços extras

                data[0]['ENDERECO_NRO_ENT'] = numb
                data[0]['COMPLEMENTO_ENT']  = "{} - {}".format(endereco, complemento)

            return data
            
        return False
        
    # returne false caso queira sair
    def afterGet_pedido_search(self, data) :
        data = data.get('objects')
        return data
        
    
    def sku_to_codigo_produto(self, value) :
        # salvo codigo para usar em outras fucoes
        self.codigo_produto = value
        
        #code_pieces = self.codigo_produto.split('-')
        # Segundo o suporte sempre que existir um P tera um C no SKU
        # Por isso sempre testamos apenas o c
        
        
        #if (len(code_pieces) > 1 and re.match(r'^([cp]\d{1,3}){1,2}$',code_pieces[-1])):
        #    value = "-".join(code_pieces[:-1])
        value = value.upper()
        return re.sub(r'(-C([2-9]|1[0-2]?)(P([2-9]|1[0-2]?))?)$','',value)
        
    
    def carrinho_quantidade(self, value) :
        value = 0
        if re.match(r'.*-(C([2-9]|1[0]?)(P([2-9]|1[0]?))?)$', self.codigo_produto.upper()):
            value = 100
            
        return str(value)
        
    def only_numbers(self, data):
        return  re.sub(r'[^\d]','',data)
    # Apenas para recuperar o id externo do cliente
    def customer_data(self, data) :
        
        params = {
            "method" : "GET",
            "rote": f"cliente/{self.current_order['cliente']['id']}"
        }
        
        response = self.throttling(**params) 
        if response.ok :
            dados_cliente = response.json()
            endereco_principal = list(filter(lambda endereco: endereco['principal'],dados_cliente['enderecos']))
            if(endereco_principal):
                data["ENDERECO"      ] = endereco_principal[0].get("endereco",'')
                data["ENDERECO_NRO"  ] = endereco_principal[0].get("numero",'')
                data["COMPLEMENTO"   ] = endereco_principal[0].get("complemento",'')
                data["CEP"           ] = endereco_principal[0].get("cep",'')
                data["BAIRRO"        ] = endereco_principal[0].get("bairro",'')
                data["CIDADE"        ] = endereco_principal[0].get("cidade",'')
                data["ESTADO"        ] = endereco_principal[0].get("estado",'')
                
            
            rg_ie = dados_cliente.get('ie') or dados_cliente.get('rg') or ''
            data['RG_IE'] = self.only_numbers(rg_ie)

            #    Tratamento para endereços    #
            # ----- Endereço do cliente ----- #

            if not data['ENDERECO_NRO'].isdigit():
                endereco = data['ENDERECO_NRO'] 
                complemento = data['COMPLEMENTO']

                numb = ''.join(re.findall(r'\d+', endereco))  # Captura apenas os números
                # comp = ''.join(re.findall(r'[^\d]+', endereco)).strip()  # Captura os caracteres não numéricos e remove espaços extras

                data['ENDERECO_NRO'] = numb
                data['COMPLEMENTO']  = "{} - {}".format(endereco, complemento)
            
        #data['IDCLIENTEEXTERNO'] = self.current_order['cliente']['id']
        return data
        
        
    
    def tipo_pessoa(self, value) :
        return "J" if self.current_order['cliente'].get('cnpj') else "F"
        
        
    
    def previsao_entrega_pedido(self, value):
        if value:
            return max(map(lambda v: v.get('disponibilidade', 2), value))
            
        return 2
        
        
        
    
    
    
    #--------------------------------------------------------#
    #------------------- TRATAMENTO FORSETI -----------------#
    #--------------------------------------------------------#
    def observacao_forseti(self, data, props) :
        #print(data)
        return re.sub(r'\r\n',"|",data)
        
    
    def forma_envio_frete_forseti(self, value, props) :
        return "9" if value == "retirar_pessoalmente" else "1"
        
    
    def envios_forseti(self, data, props) :
        
        id   = data.get('id', '')
        code = data.get('code', '')
        
        if self.cliente_origem :
            id = self.cliente_origem
        
        #""" if id and self.nmlkgrupo.lower() == 'forseti' : """
        transportadoras = {
                '80869'     : 'T00879' # rte Rodonaves 
            ,   '1'         : 'T00192' # sedex
            ,   '2'         : 'T00013' # pac
            ,   '12015'     : 'T00020' # Retirar na loja
            ,   '80896'     : 'T00012' # Maex
            ,   '80901'     : 'T00008' # MHLog 
            ,   '80905'     : 'T00026' # Meridional 
            ,   '54680'     : { # fretnet
                    'ETOT_1'        : 'T00019' # total express
                ,   'OWN-CUSTOM'    : 'T00019' # Proprio
                ,   'RTE1'          : 'T00879' # Rodonaves
                ,   'TNTVIP'        : 'T00041' # TNT - Pecas com ate 3000mm (3 metros)
                ,   '3'             : 'T00040' # Jadlog
                ,   'MTB_S'         : 'T00032' # Motoboy 
                ,   '04014'         : 'T00192' # sedex 
                ,   '04596'         : 'T00013' # pac 
                ,   'R'             : 'T00004' # Jamef  
                ,   'ISP_1_3260'    : 'T00020' # Retirar na loja 
                ,   'SFX_01'        : 'T00097' # SFX_01
                ,   '03220'         : 'T00192' # Sedex
                
            }
            #,   'mercadolivre'      : 'T00037' #Mercado livre
            ,   'mercadolivre'      : 'T00134' #Mercado livre
            ,   'shopee'            : 'T00065' #shopee
            ,   'magalu'            : 'T00088' #magalu
            ,   'via'               : 'T00091' #Via Varejo
            ,   'americanas'        : 'T00096' #americanas
            ,   'olist'             : 'T00077' #olist
            ,   'amazon'            : 'T00203' #amazon
            ,   'SEDEX'             : "T00027" 
            ,   'PAC'               : "T00013" 
            
        }
        # Procura o codido no dicionario
        softcode = transportadoras.get(str(id),0)
        
        # Codigo Fretnet
        if (id == 54680) :
            softcode = softcode.get(data['code'],0)
            
        if (softcode == 0):
            softcode = transportadoras.get(str(code),0)
            if (softcode == 0):
               self.createLog("999", "transportadora nao relacionada: {} ".format(data))
            
        
        return softcode
            
        #return self.translate(id=id, table='TBTRANSPORTADOR', reverse=True)
        
    
    def pagamentos_forseti(self, value, props) :
        
        #"""  if value and self.nmlkgrupo.lower() == 'forseti' : """
        
            
        
        parcelamentos   = value['parcelamento'].get('numero_parcelas')
        forma_pagamento = value['forma_pagamento'].get('codigo')
        
        if self.cliente_origem :
            forma_pagamento = self.cliente_origem
            
        
        dictionary = {
                'pagsegurov2'               : "Cartao Lj Virtual" 
            ,   'paypal'                    : "Paypal" 
            ,   'mercadopago'               : "Mercado Pago" 
            ,   'mercadopagov1'             : "Mercado Pago" 
            ,   'paghiper'                  : "BOLETO PAGHIPER" 
            ,   'pagseguro'                 : "PAGSEGURO" 
            ,   'pagarmev2'                 : "PAGAR.ME" 
            ,   'proxy-pagarme-v2-cartao'   : "PAGAR.ME" 
            ,   'proxy-pagarme-v3-cartao'   : "PAGAR.ME" 
            ,   'proxy-pagarme-v4-cartao'   : "PAGAR.ME" 
            ,   'proxy-pagarme-v5-cartao'   : "PAGAR.ME" 
            ,   'proxy-pagarme-v6-cartao'   : "PAGAR.ME" 
            ,   'proxy-pagarme-v7-cartao'   : "PAGAR.ME" 
            ,   'proxy-pagarme-v8-cartao'   : "PAGAR.ME" 
            ,   'proxy-pagarme-v9-cartao'   : "PAGAR.ME" 
            ,   'proxy-pagarme-v10-cartao'  : "PAGAR.ME" 
            ,   'proxy-pagarme-v11-cartao'  : "PAGAR.ME" 
            ,   'proxy-pagarme-v12-cartao'  : "PAGAR.ME" 
            ,   'pmboletov2'                : "BOLETO PAGAR.ME" 
            ,   'proxy-pagarme-v4-boleto'   : "BOLETO PAGAR.ME" 
            ,   'shopee'                    : "SHOPEE" 
            ,   'mercadolivre'              : "Mercado Pago" 
            ,   'magalu'                    : "MAGAZINE LUIZA" 
            ,   'americanas'                : "AMERICANAS" 
            ,   'olist'                     : "OLIST" 
            ,   'via'                       : "VIA VAREJO" 
            ,   'pagali-pix'                : "PIX - PAGALI"
            ,   'proxy-pagali-v2-pix'       : "PIX - PAGALI"
            ,   'amazon'                    : "AMAZON"
        }
        
        
        forma_pagamento = dictionary.get(forma_pagamento) or ''
        parcelamentos   = " {}X".format(parcelamentos or '1')
        
        # 'BOLETO' in  forma_pagamento or 'SHOPEE' in forma_pagamento or 'PIX' in forma_pagamento  :
        #if forma_pagamento in ['BOLETO', 'VIA VAREJO', 'SHOPEE','PIX','AMERICANAS'] :
        if re.findall(r'(BOLETO|VIA VAREJO|SHOPEE|PIX - PAGALI|AMERICANAS|MAGAZINE LUIZA|OLIST)', forma_pagamento):
            parcelamentos = ''
        
        desc_pagamento = f"{forma_pagamento}{parcelamentos}"
        
        result =  self.getDb().simple_select(
            fields=["CDCONDPGTO"]
            , table="TBCONDPGTO"
            , where=["DSCONDPGTO='{}'".format(desc_pagamento)], onlyFirst=True)
        
        return result.get('CDCONDPGTO','0')
        
    
    # ---------------------------------------- #
    # ---------------------------------------- #
    # ---------------------------------------- #
    
    def origem_forseti(self, value, props):
        origem_map = {
            "mercadolivre": "193",
            "shopee": "194",
            "magalu": "196",
            "via": "197",
            "olist": "195",
            "americanas": "198",#  = 2 dias uteis,
            "amazon": "191"
        }
        self.cliente_origem = self.get_origem(value)
        
        return origem_map.get(self.cliente_origem, '203')
        
    
    
    def get_origem(self, value=''):
        if "@mail.mercadolivre.com" in value or "@mercadolibre.com" in value:
            return 'mercadolivre'
            
        if "@shopee.com.br" in value:
            return 'shopee'
        
        if "@marketplace.amazon.com.br" in value:
            return 'amazon'
        
        if "@alias.integracommerce.com.br" in value:
            return 'magalu'
            
        if "@mktp.extra.com.br" in value:
            return 'via'
            
        if "@olist.com" in value :
            return 'olist'
            
        if "@email.com.br" in value :
            return 'americanas'
            
        return ''
        
    
    
    """ def custom_control_id_produto_estoque_produto_id(self, response):
        response        = self.tryJson(response)
        return response.get('produto', '').split('/')[-1] """
        
        
    
    
    
    def __del__(self):
        self.createLog("999","Final da exportacao")
    
    
    
    
    
    
    
    
    
