import sys
import json
import requests
from requests.exceptions import HTTPError
import re
from datetime import date
from datetime import datetime
import xml.etree.ElementTree as ET


argsv = sys.argv

now = datetime.now()
current_time = now.strftime("%H:%M:%S")
#parametros =  "36525743000122;04376556000138;1;89204324;06712430;VINIL;210;105x016x016;15;7615.00"
#parametros =  "09278286000146;76080738000178;2;93115110;93115110;roupas;1;1x1x1x1;1;1;quilo"
parametros = argsv[1]
aPar = parametros.split(";")

cnpj_remetente  = aPar[0]
cnpj_destinatario  = aPar[1]
tipo_frete  = aPar[2]
cep_remetente  = aPar[3]
cep_destinatario  = aPar[4]
#tipo_mercadoria  = aPar[5]
#peso_nota_fiscal  = aPar[6]
#medida  = aPar[7].replace(",",".")
#qtde_volumes  = aPar[8]
#valor_nota_fiscal  = aPar[9]
#tipoPeso = aPar[10]
#cnpj_pagador = aPar[11]

ENDERECO_SERVIDOR = "http://localhost:8080" 
DOMINIO = "EUC"
MOTOR_RASPAGEM = "http://localhost"
USERNAME =  "nettcom"
SECRET = "nettcom@cotacao@motor"

cotacaoPendente = {}

try:

    cnpj_remetente = "".join(char for char in cnpj_remetente if char.isdigit())
    cnpj_destinatario = "".join(char for char in cnpj_destinatario if char.isdigit())
    cnpj_pagador = "".join(char for char in cnpj_pagador if char.isdigit())
    
    cep_remetente = "".join(char for char in cep_remetente if char.isdigit())
    cep_destinatario = "".join(char for char in cep_destinatario if char.isdigit())
    
    if tipo_frete.upper() == "REMETENTE":
        tipo_frete = "1"
        
    if tipo_frete.upper() == "DESTINATARIO":
        tipo_frete = "2"
        
    tipo_mercadoria = tipo_mercadoria.strip().upper()
   
    """_summary_
    peso_nota_fiscal = peso_nota_fiscal.strip().replace(".","").replace(",",".")
    peso_nota_fiscal = "".join(char for char in peso_nota_fiscal if char.isdigit() or str(char) == "." )
    peso_nota_fiscal = float(peso_nota_fiscal)
    """
    #valor = peso_nota_fiscal
    #valor = re.sub(r'[^\d.,]',"", valor)
    #valor = valor.replace(",", ".")
    #peso_nota_fiscal = float(valor)
    
    #tipoPeso = tipoPeso.strip()
    #if tipoPeso == "tonelada":
    #    peso_nota_fiscal = peso_nota_fiscal * 1000
    
    
    #qtde_volumes = qtde_volumes.strip()
    #qtde_volumes = re.sub(r'[^\d.,]', "", qtde_volumes)
    #qtde_volumes = int(qtde_volumes.strip().replace(".","").replace(",","."))
    
    ##medida = qtde_volumes + "X" + medida.strip()
    #medida = medida.strip()
    
    #valor_nota_fiscal = re.sub(r'[^\d.,]',"", valor_nota_fiscal.strip())
    ##valor_nota_fiscal = valor_nota_fiscal.replace(".","")
    #valor_nota_fiscal = valor_nota_fiscal.replace(",",".")
    #valor_nota_fiscal = float(valor_nota_fiscal)

    cotacaoPendente = {
            "cotacao": {
                    "cnpj_remetente": cnpj_remetente,
                    "cnpj_destinatario": cnpj_destinatario,
                    "tipo_frete": tipo_frete,
                    "cep_remetente": cep_remetente,
                    "cep_destinatario": cep_destinatario
                }
            }
    
except Exception as error:
    erro_str = str(error)
    mes_erro_str = "Erro técnico, favor entrar em contato com atendimento -> " + erro_str
    VariavelLista = [{"nome": "status_frete", "valor": "erro"},
                    {"nome": "valor_frete", "valor": ""},
                    {"nome": "erro_validacao", "valor": mes_erro_str },
                    {"nome": "cotacao", "valor": ""}]
    obj = {"variavelLista":VariavelLista}
    sys.exit()

def Carregar_Usuario_e_Dominio():
    url = ENDERECO_SERVIDOR + "/dominio/acesso/" + DOMINIO
    headers = {'Content-Type': 'application/json'}
    response = requests.get(url, headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Carregar_Usuario_e_Dominio', "Dominio não encontrato / Status: " + str(code))
    
    return response.json()

def Solicitar_e_Definir_Tokens_Utilizados():
    url = "https://ssw.inf.br/api/generateToken"
    headers = {'Content-Type': 'application/json'}
    payload = { 'domain': 'ACV',
                'username': 'Clara',
                'password': 'cbloatra',
                'cnpj_edi': '81560047000101'
            }     
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Solicitar_e_Definir_Tokens_Utilizados', "Token SSW / Status: " + str(code))
        
    tokenSSW = response.json()
    tokenCnpjJa = "fed78d20-b2f3-42b5-add9-d1779aecab22-3892c6f0-173b-42f8-9f9b-f2f8506246a8"
    tokenClara = "qualquer"
    tokenBlip = "Key YXRlbmRpbWVudG9kaWdpdGFsMzpyRUl0MkRPN1VNNDZVS0VTU2RBYw=="
    
    return {
                'tokenSSW':tokenSSW['token'],
                'tokenCnpjJa': tokenCnpjJa,
                'tokenClara': tokenClara,
                'tokenBlip': tokenBlip
           }
 

def Consulta_Cotacao_Pendente_de_Precificacao(token, id_):
    url = ENDERECO_SERVIDOR +  "/cotacaocliente/busca"
    headers = {'Content-Type': 'application/json'}
    payload = {
          		"domínio":  DOMINIO ,
          		"token": token,
          		"id_cotacao": id_
              } 
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consulta_Cotacao_Pendente_de_Precificacao', "Consulta cotação pendente / Status: " + str(code))
        
    return response.json()
    
def Localizar_Remetente_destinatario(tipo, cnpj, token):
    url = "https://ssw.inf.br/api/consultaGenerica/consultaClientes?idCliente=" + cnpj
    headers = {
                'Content-Type': 'application/json',
                'Authorization': token
               }
    response = requests.get(url, headers=headers)
  
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Localizar_Remetente_destinatario', "Localiza remente ou destinatário no SSW / Status: " + str(code))
    
    retorno = response.json()
    
    if tipo == "REMETENTE":
        cotacaoPendente["cotacao"]["cep_remetente"] = retorno["cep"]
    if tipo == "DESTINATARIO":    
        cotacaoPendente["cotacao"]["cep_destinatario"] = retorno["cep"]
    
    return response.json()
 
def Verificar_Bloqueio(cliente, cnpj):
    if (cliente['transportar'] != 'S'):
        raise Exception('Verificar_Bloqueio_Remetente', '3- Remetente ' + cnpj + ' favor entrar em contato com o nosso setor comercial.')
        #raise Exception('Verificar_Bloqueio_Remetente', '3- Remetente ' + cnpj + ' está bloqueado para transporte na Aceville')

def Consultar_CNPJ_Remetente_Destinatario_CNPJJA(cnpj, token):
    url = "https://api.cnpja.com.br/companies/" + cnpj
    headers = {
                'Content-Type': 'application/json',
                'Authorization': token 
                }
    response = requests.get(url, headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consultar_CNPJ_Remetente_CNPJJA', "Mensagem CNPJ Já Fora do AR / Status " + str(code))
    
    retorno = response.json()
    
    if (len(retorno['name']) == 0):
        raise Exception('Consultar_CNPJ_Remetente_CNPJJA', "Cnpj não encontrato no CnpjJa ")
    
    
    return retorno

def Consulta_Cidade_Remetente_Destinatario(cep, token):
    url = "https://ssw.inf.br/api/consultaGenerica/consultaCep?idCep=" + cep
    headers = {
                'Content-Type': 'application/json',
                'Authorization': token
               }
    response = requests.get(url, headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consulta_Cidade_Remetente', "Cidade origem não encontrata no SSW / Status: " + str(code))
    
    return response.json()

def Verificar_Cidade(cidade):
    if (cidade['mensagem'] != 'OK'):
        raise Exception('Verificar_Cidade_Remetente', "5 - Cidade não atendidata para o remetente. " + 
                        " Cidade: " + cidade['cidade'] + " CEP: " + 
                        cidade['cepCidade'] )
    
def Verificar_Logradouro(cliente, cotacaoPendente):
    #Comparar o endereço do remetente e o endereção da contação pendente
    print("Verificar_Logradouro_do_Remetente")
    
def Definir_Endereco_de_Coleta(cliente):
    rua = re.sub("/([\u0300-\u036f]|[^0-9a-zA-Z\s])/g","",cliente['endereco'])
    numero = cliente['numero']
    complemento = re.sub("/([\u0300-\u036f]|[^0-9a-zA-Z\s])/g","",cliente['complemento'])
    bairro =  re.sub("/([\u0300-\u036f]|[^0-9a-zA-Z\s])/g","",cliente['bairro'])
    endereco = ""
    endereco += rua + "," + numero
    if (len(complemento) > 0 and complemento != "0"):
        endereco += "," + complemento
    if (len(bairro) > 0 ):
        endereco += "," + bairro   
    return endereco
    
def Gravar_Novo_Cliente(token, cliente, cotacao, cnpjja):
    url = ENDERECO_SERVIDOR +  "/cliente/grava/" + DOMINIO + "/" + token
    headers = {'Content-Type': 'application/json'}
    dataAtual = str(date.today())
    payload = {
                    "cnpj": cotacao['cotacao']['cnpj_remetente'],
                    "razao_social": cliente['nome'],
                    "ultimo_contato": dataAtual,
                    "inscricao_estadual": "", #cnpjja['sintegra']['home_state_registration'],
                    "cfop": "", #"{{CFOPRemetente}}",
                    "simples": "", #"{{SimplesRemetente}}",
                    "logradouro": cliente['endereco'],
                    "numero": cliente['numero'][-5:],
                    "complemento": cliente['complemento'],
                    "bairro": cliente['bairro'],
                    "cep": cotacao['cotacao']['cep_remetente'],
                    "cidade": cliente['cidade'],
                    "uf": cliente['uf'],
                    "fone": cotacao['cotacao']['ddd_remetente'] + cotacao['cotacao']['fone_remetente'],
                    "contato_financeiro": "",
                    "email_financeiro": "", #"{{EmailFaturamentoRemetente}}",
                    "contato_comercial": "", #"{{NomeSolicitante}}",
                    "email_comercial": "", #"{{EmailSolicitante}}",
                    "cubagem": 300,
                    "apartir": 0,
                    "grava_erp": "S"
                }
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Gravar_Novo', "Erro gravação do cliente / Status: " + str(code))
        
    return response.json()

def Consultar_Cubagem_do_Pagador_do_Frete(token, cotacao):
    url = ENDERECO_SERVIDOR +  "/bot/cubagem"
    headers = {'Content-Type': 'application/json'}
    #1-CIF
    tipoFrete = cotacao['cotacao']['tipo_frete']
    cnpjPagador = cotacao['cotacao']['cnpj_destinatario']
    if (tipoFrete == "1"):
        cnpjPagador = cotacao['cotacao']['cnpj_remetente']
    payload = {
                    "dominio": DOMINIO,
                	"token": token,
                	"cnpj": cnpjPagador
                }
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consultar_Cubagem_do_Pagador_do_Frete', "Erro para buscar a cupagem do pagador / Status: " + str(code))
    
    retorno = response.json()
    fator = retorno['fator']
    if (fator == 0):
        retorno['fator'] = 300
    
    return retorno

def Consultar_Situacao_Mercadoria(token, cotacao):
    tipoMercadoria = cotacao['cotacao']['tipo_mercadoria'].upper()
    url = ENDERECO_SERVIDOR + "/situacaomercadoria/busca/" + DOMINIO + "/" + token + "/" + tipoMercadoria
    headers = {'Content-Type': 'application/json'}
    response = requests.get(url, headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consultar_Situacao_Mercadoria', "Erro para consultar a situação da mercadoria / Status: " + str(code))
    
    retorno = response.json()
   
    naoTransporta = False
    devolucao = False
    exigeIsencao = False
    
    #if (retorno['embalagem'] == 'true' or retorno['carta_isencao'] == 'true' or 
    #    retorno['cotacao_manual'] == 'true' or retorno['fragil'] == 'true'):
    #    naoTransporta = True
    
    #VERIFICAR REGRA DE NEOGICIO
    #if (cotacao['cotacao']['devolucao'] == 'S'):
    #    devolucao = True
        
    #if (cotacao['cotacao']['estado_mercadoria'] == 'U'):
    #    exigeIsencao = True
      
    #liberar depois dos teste    
    #if (retorno['cotacao_manual'] == 'true'):
    #    raise Exception('Consultar_Situacao_Mercadoria', 
    #                    "8- Mercadorias do tipo " + tipoMercadoria + " exigem Cotação manual")
    
    #if (exigeIsencao):
    #    raise Exception('Consultar_Situacao_Mercadoria', "9- Mercadorias do tipo " + tipoMercadoria + " exigem Carta de Isenção e exigem Cotação manual")
    
    if (retorno['erro'] != 'ok'):
        raise Exception('Consultar_Situacao_Mercadoria', "Não transportamos esse tipo de mercadoria.")
    
    mercadoriaFragil = retorno['fragil']
     
    return { 'situacao': retorno,
             'naoTransporta': naoTransporta,
             'exiteCotacao': devolucao,
             'exigeIsencao': exigeIsencao,
             'mercadoriaFragil': mercadoriaFragil
           }

def Verifica_Medida_Metro_Cubico(cotacao):
    medida = cotacao['cotacao']['medida']
    qtdeMedidas = len(medida.split(" "))
    return qtdeMedidas

def Verificar_Medidas_Informadas(cotacao):
    medida = cotacao['cotacao']['medida'].strip()
    restricao = 300
    meditaExtrapolada = 0
    totalMedidas = 0
    qtdeVolumes = 0
 
    
    if (len(medida) > 10):
        
        medidaArray = medida.split(" ")
        #if (len(medidaArray) < 3):
        #     raise Exception('Verificar_Medidas_Informadas', "12- Media incompleta")
        
        for medida in medidaArray:
        
            if (medida.upper().find('X') == -1):
                raise Exception('Verificar_Medidas_Informadas', "11- A  medida informada (" + medida + ") não está de acordo com o padrão exigido.")
        
           
            qtdeVolumes = cotacao['cotacao']['qtde_volumes']
            pm = medida.upper().replace(" ", "").split('X')
            
            if (len(pm) > 4 or len(pm) < 4 ):
                raise Exception('Verificar_Medidas_Informadas', "11- A  medida informada (" + medida + ") não está de acordo com o padrão exigido")
        
       
            pmTamanho = int(pm[0])
           
            totalMedidas += pmTamanho
            #if (qtdeVolumes != totalMedidas):
            #    raise Exception('Verificar_Medidas_Informadas', "14- A quantidade de volumes informado é diferente da quantidade informada nas medidas")
          
            pmComprimento = float(pm[3].replace(",","").replace(".",""))
            if (pmComprimento > 1700):
                raise Exception('Verificar_Medidas_Informadas', "26 - A terceira medida informada, referente ao Comprimento, tem limite é de 17 metros")
          
            pmLargura = float(pm[2].replace(",","").replace(".",""))
            if (pmLargura > 245):
                raise Exception('Verificar_Medidas_Informadas', "25 - A segunda medida informada, referente a Largura, tem limite é de 2.45 metros")
          
            pmAltura = float(pm[1].replace(",","").replace(".",""))
            if (pmAltura > 260):
                raise Exception('Verificar_Medidas_Informadas', "24 - A primeira medida informada, referente a Altura, tem limite de 2.6 metros")
          
       
            #Largura
            if (pmLargura > restricao and pmLargura > meditaExtrapolada):
                meditaExtrapolada = pmLargura
            
           
            #Comprimento    
            if (pmComprimento > restricao and pmComprimento > meditaExtrapolada):
                meditaExtrapolada = pmComprimento
           
    if (int(qtdeVolumes) != int(totalMedidas)):
        raise Exception('Verificar_Medidas_Informadas', "14- A quantidade de volumes informado é diferente da quantidade informada nas medidas")
          
    return meditaExtrapolada 
    
def Consultar_Restricao_Comprimento(token,unidadeOrigem,medidaExtrapolada):
    url = ENDERECO_SERVIDOR + "/restricaocomprimento/busca/" + DOMINIO + "/" + token + "/" + unidadeOrigem + "/" + str(medidaExtrapolada)
    headers = {'Content-Type': 'application/json'}
    response = requests.get(url, headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consultar_Restricao_Comprimento', "Restrição de comprimento não encontrato para o medida  " + medidaExtrapolada + " e a unidade " + unidadeOrigem +  " / Status: " + str(code))
    
    return response.json()
  
def Valida_Restricao(restricao):
    if (float(restricao['medida']) >= 600):
       raise Exception('Valida_Restricao', "17- Há uma restrição de comprimento ou largura superior a 6 metros nas medidas dessa Cotação")
    if (float(restricao['medida']) >= 450):
       raise Exception('Valida_Restricao', "16- Há uma restrição de comprimento ou largura superior a 4,5 metros nas medidas dessa Cotação")  
    if (float(restricao['medida']) >= 300):
       raise Exception('Valida_Restricao', "15- Há uma restrição de comprimento ou largura superior a 3 metros nas medidas dessa Cotação")  
 
def Verificar_Peso_Elevado(tipoToneladaQuilo, cotacao):
    peso = cotacao['cotacao']['peso_nota_fiscal']
    mensagem = "19- O peso dessa carga XX (" + str(peso)  + ") ultrapassou o limite para carga fracionada"
    if (tipoToneladaQuilo == 2 and peso > 40):
        raise Exception('Verificar_Peso_Elevado', mensagem)  
    if (tipoToneladaQuilo == 1 and peso > 40000):
        raise Exception('Verificar_Peso_Elevado', mensagem)  
    if (tipoToneladaQuilo == 3 and peso > 25):
        raise Exception('Verificar_Peso_Elevado', mensagem)  

def Calcular_Cubagem_e_PesoCubado(cotacao, cubagem):
    medida = cotacao['cotacao']['medida'].strip()
    pesoNota = cotacao['cotacao']['peso_nota_fiscal']
    fator = float(cubagem['fator'].replace(",","."))
    apartir = float(cubagem['apartir'].replace(",","."))
    
    cubico = 0
    pesoCalculado = 0
    medida = medida.replace(" ", "")
    medidas = medida.split(" ")
    
    #if (len(medida) > 10):
    if  "X" in  medida.upper():
        for m in medidas:
            pm = m.upper().split('X')
            pmCubico = float(pm[0]) * float(pm[1].replace(",",".")) * float(pm[2].replace(",",".")) * float(pm[3].replace(",","."))
            # cubico += (pmCubico/1000000)
            cubico += pmCubico
    else:
        # cubico = (float(medida)/1000000) 
        cubico = float(medida)
        
    if (pesoNota > apartir and cubico > 0):
        pesoCalculado = cubico * fator
    
    if (pesoCalculado > pesoNota):
        pesoCalculado = round(pesoCalculado,2)
    else:
        pesoCalculado = pesoNota
     
    pesoCalculado = pesoNota
      
    return {"pesoCalculado": pesoCalculado, "metroCubico": cubico}
    
def Verifica_Volumetria_da_Carga(metroCubicoPesoFrete):
    metroCubico = metroCubicoPesoFrete['metroCubico']
    if (metroCubico > 110):
        raise Exception('Verificar_Peso_Elevado', '22- A volumetria (99) total da carga ultrapassou o limite de nossa capacidade de carga')  

def Consultar_Generalidades(token):
    url = ENDERECO_SERVIDOR + "/generalidade/busca/" + DOMINIO + "/" + token 
    headers = {'Content-Type': 'application/json'}
    response = requests.get(url, headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consultar_Generalidades', "Erro ao consultar as generalidades / Status: " + str(code))
    
    return response.json()
  
def Verificar_Peso_para_Carga_Lotacao(generalidade, cotacao, metroCubicoPeso):
    pesoMinimo = float(generalidade['pesomin'])
    pesoNota = cotacao['cotacao']['peso_nota_fiscal']
    qtdeVolumes = cotacao['cotacao']['qtde_volumes']
    pesoVolume = pesoNota / qtdeVolumes
    #if (pesoVolume > pesoMinimo):
    if (metroCubicoPeso['metroCubico'] > pesoMinimo):
       raise Exception('Verificar_Peso_para_Carga_Lotacao', '22 - ')  
  
def Verificar_Fragilidade_da_Mercadoria(situacao, cotacao):
    tipoMercadoria = cotacao['cotacao']['tipo_mercadoria']
    if(situacao['mercadoriaFragil'] == 'true'):
       raise Exception('Verificar_Fragilidade_da_Mercadoria', 'A mercadoria (' + tipoMercadoria + ') é considerada frágil, com restrição de embarque')  
  
def Verificar_Valor_Elevado(valorNotaFiscal, valorLimiteApolice):
    if (valorNotaFiscal < valorLimiteApolice):
        raise Exception('Verificar_Valor_Elevado', "O valor (" + str(valorNotaFiscal) + ") total da carga ultrapassou o limite de nossa apólice de seguros")  

def Consultar_Codigos_de_Mercadoria_do_Cliente(token, cotacao):
    url = ENDERECO_SERVIDOR +  "/bot/mercadorias/"
    
    #1-CIF
    tipoFrete = cotacao['cotacao']['tipo_frete']
    cnpjPagador = cotacao['cotacao']['cnpj_destinatario']
    if (tipoFrete == "1"):
        cnpjPagador = cotacao['cotacao']['cnpj_remetente']
        
    headers = {'Content-Type': 'application/json'}
    payload = {     "dominio": DOMINIO ,
                	"token": token,
                	"cnpj": cnpjPagador
                }
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consultar_Codigos_de_Mercadoria_do_Cliente', "Erro para consultar os códigos de Mercadoria / Status: " + str(code))
        
    mercadoria = response.json()
    
    codigoMercadoria = '000'
    if (mercadoria['codigo1'] != '000'):
        codigoMercadoria = mercadoria['codigo1']
    else:
         if (mercadoria['codigo2'] != '000'):
           codigoMercadoria = mercadoria['codigo2']   
         else:
             if (mercadoria['codigo3'] != '000'):
                 codigoMercadoria = mercadoria['codigo3'] 
     
    if (codigoMercadoria == '000'):
        raise Exception('Consultar_Codigos_de_Mercadoria_do_Cliente', "Não foi encontrado o código da Mercadoria, favor entrar em contato com um de nossos atendentes!")
         
    codigoMercadoriaDig = str(int(codigoMercadoria))
    
    return codigoMercadoriaDig

def Consultar_o_Valor_do_Frete_Mercadoria(token, cotacao, mercadoria, metroCubicoPeso):
    url = ENDERECO_SERVIDOR +  "/bot/valorfrete/"
    headers = {'Content-Type': 'application/json'}
    #1-CIF
    tipoFrete = cotacao['cotacao']['tipo_frete']
    cnpjPagador = cotacao['cotacao']['cnpj_destinatario']
    if (tipoFrete == "1"):
        cnpjPagador = cotacao['cotacao']['cnpj_remetente']
        
    payload = {
                    "dominio": DOMINIO ,
                	"token": token,
                	"cnpjpagador": cnpjPagador,
                	"codigoMercadoria": mercadoria,
                	"cepremetente": cotacao['cotacao']['cep_remetente'],
                	"cepdestinatario": cotacao['cotacao']['cep_destinatario'],
                	"cnpjremetente": cotacao['cotacao']['cnpj_remetente'],
                	"tipodeFrete": tipoFrete,
                	"cnpjdestinatario": cotacao['cotacao']['cnpj_destinatario'],
                	"valorMercadoria": cotacao['cotacao']['valor_nota_fiscal'],
                	"qtdeVolumes": cotacao['cotacao']['qtde_volumes'],
                	"pesodaNota": metroCubicoPeso['pesoCalculado'],
                	"metroCubico": metroCubicoPeso['metroCubico']
                }
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Consultar_o_Valor_do_Frete_Mercadoria_1', "Erro para buscar o valor do frete, codigo mercadoria " + mercadoria + " / Status: " + str(code))
    
    retorno = response.json()
    
    if (retorno['valorfrete'] == '0'):
         raise Exception('Consultar_o_Valor_do_Frete_Mercadoria_1', "24-Problema com a tabela de preços, contate o nosso setor comercial.")
    
    return retorno

def Consultar_o_Valor_do_Frete_Mercadoria_novo(token, cotacao, mercadoria, metroCubicoPeso):
    print("Consultar_o_Valor_do_Frete_Mercadoria_novo")
    url = MOTOR_RASPAGEM +  "/api/cotacao.php"
    headers = {
        'Content-Type': 'application/json',
        'username': USERNAME,
        'secret': SECRET
        }
    #1-CIF
    tipoFrete = cotacao['cotacao']['tipo_frete']
    cnpjPagador = cotacao['cotacao']['cnpj_destinatario']
    if (tipoFrete == "1"):
        cnpjPagador = cotacao['cotacao']['cnpj_remetente']
     
    cnpjPagadorParam = cotacao['cotacao']['cnpj_pagador']
     
    param = "?cnpj=" 
    param = param + cnpjPagadorParam
    param = param + "&dominio=" + DOMINIO
    param = param + "&cep_origem=" + cotacao['cotacao']['cep_remetente']
    param = param + "&cep_destino=" + cotacao['cotacao']['cep_destinatario']
    param = param + "&tp_frete=" + tipoFrete
    param = param + "&coletar=" + "N" #CONFIRMAR PARAMETRO
    param = param + "&cnpj_remetente=" + cotacao['cotacao']['cnpj_remetente']
    param = param + "&cnpj_destinatario=" + cotacao['cotacao']['cnpj_destinatario']
    param = param + "&dest_contribuinte=" + "N" #CONFIRMAR PARAMETRO
    param = param + "&dest_entr_dificil=" + "N" #CONFIRMAR PARAMETRO
    param = param + "&vlr_merc=" + str(cotacao['cotacao']['valor_nota_fiscal'])
    param = param + "&qtde_vol=" + str(cotacao['cotacao']['qtde_volumes'])
    param = param + "&peso_real=" + str(metroCubicoPeso['pesoCalculado'])
    param = param + "&cubagem=" + str(metroCubicoPeso['metroCubico'])
    
    url = url + param
    print(url)
    response = requests.get(url, headers=headers)
    retorno = response.json()
    json_str = json.dumps(retorno, indent=4)
    print(json_str)

    code = response.status_code
    if (response.status_code > 299):
        print(retorno)
        raise Exception('Consultar_o_Valor_do_Frete_Mercadoria_1', "Erro para buscar o valor do frete, codigo mercadoria " + mercadoria + " / Status: " + str(code))
    

    if "erroValidacao" in retorno:
        # Pega o conteúdo da chave 'erroValidacao'
        raise Exception('Consultar_o_Valor_do_Frete_Mercadoria_1', retorno["erroValidacao"])
        

    if (retorno['frete']['totalFrete'] == '0,00'):
         raise Exception('Consultar_o_Valor_do_Frete_Mercadoria_1', "24-Problema com a tabela de preços, contate o nosso setor comercial.")
    
    frete_xml = retorno['frete']
    total_frete = frete_xml['totalFrete']

    #print(f"Total Frete: {total_frete}")


    if total_frete == '0,00':
        raise Exception('Consultar_o_Valor_do_Frete_Mercadoria_1', "24-Problema com a tabela de preços, contate o nosso setor comercial.")

    return retorno

   
def Gravar_Cotacao_no_SSW(token, mercadoria, metroCubicoPesoFrete, cotacao, valorFrete, TaxaRestricaoOrigem, TaxaRestricaoDestino):
    
    url = ENDERECO_SERVIDOR +  "/ws/registraCotacao/" + DOMINIO + "/" + token
    headers = {'Content-Type': 'application/json'}
   
    #1-CIF
    tipoFrete = cotacao['cotacao']['tipo_frete']
    cnpjPagador = cotacao['cotacao']['cnpj_destinatario']
    if (tipoFrete == "1"):
        cnpjPagador = cotacao['cotacao']['cnpj_remetente']
      
    totalDoFrete = 0 #valorFrete + TaxaRestricaoOrigem + TaxaRestricaoDestino
     
    payload = {
                    "cnpjPagador": cnpjPagador,
                    "cepOrigem": cotacao['cotacao']['cep_remetente'],
                    "cepDestino": cotacao['cotacao']['cep_destinatario'],
                    "valorNF": cotacao['cotacao']['valor_nota_fiscal'],
                    "quantidade": cotacao['cotacao']['qtde_volumes'],
                    "peso": str(metroCubicoPesoFrete['pesoCalculado']),
                    "volume": str(metroCubicoPesoFrete['metroCubico']),
                    "mercadoria": str(mercadoria),
                    "ciffob": cotacao['cotacao']['tipo_frete'],
                    "nota_fiscal": cotacao['cotacao']['nota_fiscal'],
                    "cnpjRemetente": cotacao['cotacao']['cnpj_remetente'], 
                    "cnpjDestinatario": cotacao['cotacao']['cnpj_destinatario'],
                    "medida": cotacao['cotacao']['medida'],
                    "observacao": cotacao['cotacao']['obscoleta'],
                    "valor_frete": str(totalDoFrete)
                }
    
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Gravar_Cotacao_no_SSW', "Erro para gravar a cotação no SSW  / Status: " + str(code))
    
    retorno = response.json()
    return retorno

def Gravar_Cotacao_Permanente(token, valorFrete,  cotacao, cotacaoSSW, taxaRestricaoOrigem, taxaRestricaoDestino, retorno):
   
    url = ENDERECO_SERVIDOR +  "/cotacaocliente/grava"
    headers = {'Content-Type': 'application/json'}
    
    dataAtual = str(date.today())
    #CAMPOS DESABILITADOS PARA TESTE
    payload = {
                   "dominio": DOMINIO, 
                    "token": token,
                    "codigo": "486",
                    "id_cotacao": id_cotacao,
                    "cnpj_remetente": cotacao['cotacao']['cnpj_remetente'], 
                    "cnpj_destinatario":cotacao['cotacao']['cnpj_destinatario'],
                    "qtde_volumes": cotacao['cotacao']['qtde_volumes'],
                    "valor_nota_fiscal": cotacao['cotacao']['valor_nota_fiscal'],
                    "peso_nota_fiscal": cotacao['cotacao']['peso_nota_fiscal'],
                    "cotacao": cotacaoSSW['cotacao'],
                    "taxa_origem": taxaRestricaoOrigem.replace(",","."),
                    "taxa_destino": taxaRestricaoDestino.replace(",","."),
                    "valor_permanente": cotacaoSSW['frete'].replace(",","."),
                    "data_permanente": dataAtual,
                    "token_cotacao": cotacaoSSW['token'],
                    "retorno": retorno
                }
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    code = response.status_code
    if (response.status_code > 299):
        raise Exception('Gravar_Cotacao_Permanente', "Erro para gravar a cotação permanente: " + " / Status: " + str(code))
    
    return response.json()


def Enviar_Email(token, codEmail, para, assunto, conteudo, codigoAssinatura):
    url = ENDERECO_SERVIDOR +  "/bot/enviaemail/" + DOMINIO + "/" + token 
    headers = {'Content-Type': 'application/json'}
    
    payload = {
                     "para": para,
                     "assunto": assunto,
                     "conteudo": conteudo,
                     "codigoResposta": codEmail,
                     "codigoAssinatura": codigoAssinatura,
                }
    
    response = requests.post(url, data=json.dumps(payload), headers=headers)
    retorno = response.json()
    return retorno


# TODO: A PARTIR DESTE PONTO COMEÇA O PROCESSAMENTO DAS REGRAS

valorFrete = ""
valorErroValidacao = ""
valorCotacao = ""
statusFrete = "ok"
desconto1 = ""
desconto2 = ""
desconto3 = ""
prazo = ""
prazoDia = ""
unidadeOrigem = ""
unidadeDestino = ""
try:
   
    #print("Inicia validação")
    #dominio = Carregar_Usuario_e_Dominio()
    
    #token ssw
    tokens =  Solicitar_e_Definir_Tokens_Utilizados()
    print(tokens)

    #solicitante = Autenticador()
    #print(solicitante)
    
    #print("Consulta_Cotacao_Pendente_de_Precificacao")
    ##cotacaoPendente = Consulta_Cotacao_Pendente_de_Precificacao(tokens['tokenClara'], id_cotacao)
    
    #REMETENTE
    if tipo_frete == 1:
        
        #print("REMETENTE")
        
        print("Localizar_Remetente_destinatario")
        remetente = Localizar_Remetente_destinatario("REMETENTE",cotacaoPendente['cotacao']['cnpj_remetente'], tokens['tokenSSW'])
        print("Verificar_Bloqueio")
        verificaBloqueio = Verificar_Bloqueio(remetente,cotacaoPendente['cotacao']['cnpj_destinatario'])
        #remetente: Carregar Dados do Remetente encontrato 
    
        cnpjJa = {}
        #já está sendo verificado na gravação da temporaria 481
        #cnpjJa = Consultar_CNPJ_Remetente_Destinatario_CNPJJA(cotacaoPendente['cotacao']['cnpj_remetente'], tokens['tokenCnpjJa'])
        
        print("Consulta_Cidade_Remetente_Destinatario")
        cidadeRemetente = Consulta_Cidade_Remetente_Destinatario(cotacaoPendente['cotacao']['cep_remetente'], tokens['tokenSSW'])
        
        print("Verificar_Cidade")
        Verificar_Cidade(cidadeRemetente)
        
        #print("Verificar_Logradouro")
        #Verificar_Logradouro(remetente, cotacaoPendente)
        
        print("Definir_Endereco_de_Coleta")
        enderecoCompletoRemetente = Definir_Endereco_de_Coleta(remetente)
        
        #print("Gravar_Novo_Cliente")
        #gravaRemetente = Gravar_Novo_Cliente(tokens['tokenClara'], remetente, cotacaoPendente, cnpjJa)
    
    #DESTINATARIO
    if tipo_frete == 2:
        
        #print("DESTINATARIO")
        
        print("Localizar_Remetente_destinatario")
        destinatario = Localizar_Remetente_destinatario("DESTINATARIO",cotacaoPendente['cotacao']['cnpj_destinatario'], tokens['tokenSSW'])
        
        print("Verificar_Bloqueio")
        verificaBloqueio = Verificar_Bloqueio(remetente,cotacaoPendente['cotacao']['cnpj_destinatario'])
        #remetente: Carregar Dados do Remetente encontrato 
    
        #já está sendo verificado na gravação da temporaria 481
        #cnpjJa = Consultar_CNPJ_Remetente_Destinatario_CNPJJA(cotacaoPendente['cotacao']['cnpj_destinatario'], tokens['tokenCnpjJa'])
    
        print("Consulta_Cidade_Remetente_Destinatario")
        cidadeDestinatario = Consulta_Cidade_Remetente_Destinatario(cotacaoPendente['cotacao']['cep_destinatario'], tokens['tokenSSW'])
        
        print("cidadeDestinatario")
        Verificar_Cidade(cidadeDestinatario)
        
        #print("Verificar_Logradouro")
        #Verificar_Logradouro(destinatario, cotacaoPendente)
       
        print("Definir_Endereco_de_Coleta")
        enderecoCompletoRemetente = Definir_Endereco_de_Coleta(destinatario)
       
        #print("Gravar_Novo_Cliente")
        #gravaDestinatario = Gravar_Novo_Cliente(tokens['tokenClara'], destinatario, cotacaoPendente, cnpjJa)
    
    # #CALCULOS
    
    # #print("CALCULOS")
    # #print("Consultar_Cubagem_do_Pagador_do_Frete")
    # #cubagem = Consultar_Cubagem_do_Pagador_do_Frete(tokens['tokenClara'], cotacaoPendente)
 
    # cubagem = {
    #     "fator": "0",
    #     "apartir": "0"
    # }
    
    # #print("Consultar_Situacao_Mercadoria")
    # #situacaoMercadoria =  Consultar_Situacao_Mercadoria(tokens['tokenClara'], cotacaoPendente)
    
    # print("Verifica_Medida_Metro_Cubico")
    # qtdeMedidas = Verifica_Medida_Metro_Cubico(cotacaoPendente)
 
    # print("Verificar_Medidas_Informadas")
    # medidaExtrapolada = Verificar_Medidas_Informadas(cotacaoPendente)
    
    # if (len(cotacaoPendente['cotacao']['medida']) > 10):
    #     print("Consultar_Restricao_Comprimento")
    #     #restricaoComprimentoOrigem = Consultar_Restricao_Comprimento(tokens['tokenClara'],"JVEP",medidaExtrapolada)
        
    #     #print("Valida_Restricao")
    #     #Valida_Restricao(restricaoComprimentoOrigem)
        
    #     #print("Consultar_Restricao_Comprimento")
    #     #restricaoComprimentoDestino = Consultar_Restricao_Comprimento(tokens['tokenClara'],"JVEP",medidaExtrapolada)
        
    #     #print("Valida_Restricao")
    #     #Valida_Restricao(restricaoComprimentoDestino)
    # else:
    #     restricaoComprimentoOrigem = {
    #         "taxa": "0"
    #         }
    #     restricaoComprimentoDestino = {
    #         "taxa": "0"
    #         }
            
    # print("Verificar_Peso_Elevado")                                                       
    # Verificar_Peso_Elevado(1, cotacaoPendente)
    
    # print("Calcular_Cubagem_e_PesoCubado")  
    # metroCubicoPesoFrete = Calcular_Cubagem_e_PesoCubado(cotacaoPendente, cubagem)
    
    # print("Verifica_Volumetria_da_Carga")  
    # Verifica_Volumetria_da_Carga(metroCubicoPesoFrete)
    
    # print("Consultar_Generalidades")  
    # #generalidades = Consultar_Generalidades(tokens['tokenClara'])
    
    # print("Verificar_Peso_para_Carga_Lotacao")
    # #Verificar_Peso_para_Carga_Lotacao(generalidades, cotacaoPendente, metroCubicoPesoFrete)
   
    # #VOLTAR ESSE CODIGO, DESABILITADO PARA TESTE
    # #print("Verificar_Fragilidade_da_Mercadoria")
    # #Verificar_Fragilidade_da_Mercadoria(situacaoMercadoria , cotacaoPendente)
   
    # print("Verificar_Valor_Elevado")
    # Verificar_Valor_Elevado(cotacaoPendente['cotacao']['valor_nota_fiscal'], 0.0)
   
    # #print("Consultar_Codigos_de_Mercadoria_do_Cliente")
    # #consultarCodigoMercadoria = Consultar_Codigos_de_Mercadoria_do_Cliente(tokens['tokenClara'], cotacaoPendente)
    # consultarCodigoMercadoria = {}
   
    # print("Consultar_o_Valor_do_Frete_Mercadoria")
    # #consultarValorMercadoria = Consultar_o_Valor_do_Frete_Mercadoria(tokens['tokenClara'], cotacaoPendente, consultarCodigoMercadoria, metroCubicoPesoFrete)
    # consultarValorMercadoria = Consultar_o_Valor_do_Frete_Mercadoria_novo(tokens['tokenClara'], cotacaoPendente, "", metroCubicoPesoFrete)
    
    # print(consultarValorMercadoria)

    # valorFrete = consultarValorMercadoria['frete']['totalFrete']
    # valorFrete = "R$ " + consultarValorMercadoria["frete"]["totalFrete"]
    # valorCotacao = consultarValorMercadoria["frete"]["nro_cotacao"]
    

    # valorFreteInt = float(consultarValorMercadoria["frete"]["totalFrete"].replace(".","").replace(",","."))
    
    # desconto1Int = valorFreteInt - ((valorFreteInt * 5) / 100) # primeiro desconto
    # desconto2Int = valorFreteInt - ((valorFreteInt * 7) / 100) # segundo desconto
    # desconto3Int = valorFreteInt - ((valorFreteInt * 10) / 100) # terceiro desconto
    
    # desconto1 = f'R$ {desconto1Int:_.2f}'
    # desconto2 = f'R$ {desconto2Int:_.2f}'
    # desconto3 = f'R$ {desconto3Int:_.2f}'
    
    # desconto1 = desconto1.replace(".", ",").replace("_",".")
    # desconto2 = desconto2.replace(".", ",").replace("_",".")

    # prazo = consultarValorMercadoria["frete"]["prazo"]
    # prazoDia = consultarValorMercadoria["prazo"]
    
    # #TODO: VERIFICAR API DO "VALDEIR"
    # #unidadeOrigem = consultarValorMercadoria["Unidade_origem"]
    # #unidadeDestino = consultarValorMercadoria["Unidade_destino"]

    status = "ok"
    
except HTTPError as http_err:
    print(f'HTTP error occurred: {http_err}')
    valor = "Problemas técnico, vamos encaminhar para problema um de nossos atendentes"
    variavel = "erro_validacao"
    statusFrete = "erro"
   
except Exception as err:
    #conteudo = "Função:" + err.args[0] + "<br/>Erro: " + err.args[1]
    print(err)

    try:
        valorErroValidacao = err.args[1] 
    except:
        valorErroValidacao = err.args[0] 
        
    variavel = "erro_validacao"
    status = "erro"
    statusFrete = "erro"
    print(err)
   
#print(peso_nota_fiscal)
print("FIM!!")
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
print("Current Time =", current_time)

obj = { "statusFrete": statusFrete,
        "valorFrete":valorFrete,
        "erroValidacao":valorErroValidacao,
        "cotacao":valorCotacao,
        "desconto1":desconto1,
        "desconto2":desconto2,
        "desconto3":desconto3,
        "prazo":prazo,
        "prazoDia":prazoDia,
        "unidadeOrigem":unidadeOrigem,
        "unidadeDestino":unidadeDestino
    }

print("|" + json.dumps(obj))