from lib.ClienteLinux import TipoConexao, obter_cliente_linux
from lib.echo import echo
import sys
from lib.obter_configuracoes import obter_configuracoes
from lib.criptografia_senha import descriptografar
from lib.executar_validacoes_servidor_linux import executar_validacoes_servidor_linux
from lib.backup_volume import fazer_backup_volume_docker, restaurar_backup_volume_docker
from lib.shared_network import garantir_shared_network, conectar_container_shared_network
from lib.nomes_containers import (
    obter_nome_container_api_gateway,
    obter_nome_container_enterprise,
    obter_nome_container_enterprise_event_handler,
    obter_nome_container_enterprise_renderizador,
)
from lib.rede_externa import (
    deve_forcar_uso_rede_externa,
    obter_host_microkafka_para_enterprise,
    obter_host_porta_mu_whatsapp_para_enterprise,
)
from lib.substituir_placeholders import substituir_placeholders_arquivo
import os
import shutil


VERSAO_ENTERPRISE_MASTER = "5.3.0-linux"
PORTA_ENTERPRISE_MASTER = "5000"
PORTA_AUXILIAR_ENTERPRISE_PADRAO = "6000"
PORTA_AUXILIAR_ENTERPRISE_MASTER = "6001"
PORTA_RENDERIZADOR_ENTERPRISE_MASTER = "7002"
PROJETO_COMPOSE_ENTERPRISE_MASTER = "enterprise-master"
NOME_CONTAINER_ENTERPRISE_MASTER = "enterprise-master"
NOME_CONTAINER_ENTERPRISE_EVENT_HANDLER_MASTER = "enterprise-event-handler-master"
NOME_CONTAINER_ENTERPRISE_RENDERIZADOR_MASTER = "enterprise-renderizador-master"


arquivo_configuracao = None if len(sys.argv) < 2 else sys.argv[1]
diretorio_scripts_implantacao = r'c:\microuniversoWeb' if len(sys.argv) < 3 else sys.argv[2]

configuracoes = obter_configuracoes(arquivo_configuracao)

if not configuracoes:
    echo(f"Falha ao carregar configuracoes do arquivo {arquivo_configuracao}", "error")
    exit(1)

if not configuracoes["acessos"]["servidorLinux"]["configurar"]:
    echo("Dados do servidor linux nao informados. API Enterprise nao sera configurada")
    exit(0)

if not configuracoes["enterprise"]["configurar"]:
    echo("Configuracao da API Enterprise desativada via configuracao")
    exit(0)

mensagem_erro = executar_validacoes_servidor_linux(arquivo_configuracao, diretorio_scripts_implantacao)

if mensagem_erro:
    echo(mensagem_erro, "error")
    exit(1)

cliente_linux = obter_cliente_linux(arquivo_configuracao)
usuario = configuracoes['acessos']['servidorLinux']['usuario']

configurar_renderizador = configuracoes["enterprise"]["renderizador"]["configurar"]
configurar_event_handler = configuracoes["enterprise"]["eventHandler"]["configurar"]
configurar_api_mu_whatsapp = configuracoes["muWhatsapp"]["configurarApi"]

compose_normal = "docker-compose-enterprise-linux.yml"
compose_renderizador = "docker-compose-renderizador.yml"

host_banco = configuracoes["acessos"]["banco"]["host"]
usuario_banco = configuracoes["acessos"]["banco"]["usuario"]
senha_banco = descriptografar(configuracoes["acessos"]["banco"]["senha"])
nome_banco = configuracoes["acessos"]["banco"]["nomeBanco"]
ip_host = configuracoes["enderecos"]["ipHost"]
porta_mu_dll_rest = configuracoes["muDllRest"]["porta"]
porta_enterprise_interna = str(configuracoes["enterprise"].get("portaInterna", 5000))
neocredit_envio_processamento_url = configuracoes["enterprise"]["neocredit"]["urlProcessamento"]
neocredit_token = configuracoes["enterprise"]["neocredit"]["tokenNeocredit"]
neocredit_url_webhook = configuracoes["enterprise"]["neocredit"]["urlWebhook"]
porta_rest_legado = configuracoes["servicos"]["rest"]["porta"]
sql_server_2008 = "S" if configuracoes["enterprise"]["usarSQLServer2008"] else "N"
usuario_registro_docker = configuracoes["acessos"]["registroDocker"]["usuario"]
senha_registro_docker = configuracoes["acessos"]["registroDocker"]["senha"]
ativar_reprocessamento_custo_medio_online = "S" if configuracoes["enterprise"]["reprocessamentoCustoMedioOnline"]["ativar"] else "N"
hora_reprocessamento_custo_medio_online = configuracoes["enterprise"]["reprocessamentoCustoMedioOnline"]["hora"]
minuto_reprocessamento_custo_medio_online = configuracoes["enterprise"]["reprocessamentoCustoMedioOnline"]["minuto"]
ativar_job_retorno_coleta_preco_sigepro = "S" if configuracoes["coletaPrecos"]["agenda"]["ativar"] else "N"
valor_hora_cron_job_retorno_coleta_preco_sigepro = configuracoes["coletaPrecos"]["agenda"]["hora"]
token_acesso_logs = configuracoes["enterprise"]["tokenAcessoLogs"]
api_key_integracao_tecnospeed = configuracoes["enterprise"]["tecnospeed"]["apikey"]
ip_enterprise = configuracoes["servicos"]["rest"]["hostEnterprise"]
memoria_minima_em_mb_heap_renderizador = configuracoes["enterprise"]["renderizador"]["memoriaMinimaEmMB"]
memoria_maxima_em_mb_heap_renderizador = configuracoes["enterprise"]["renderizador"]["memoriaMaximaEmMB"]
certificados_pix_configurados = configuracoes["enterprise"]["certificadosPix"]["configurado"]
certificados_pix_ambiente_teste = "S" if configuracoes["enterprise"]["certificadosPix"]["ambienteTeste"] else "N"
licenciamento_timeout_sessao_segundos = configuracoes["enterprise"]["licenciamento"]["timeoutSessaoSegundos"]
ativar_job_encerrar_sessoes_zumbis = configuracoes["enterprise"]["licenciamento"]["ativarJobEncerrarSessoesZumbis"]
valor_hora_cron_job_encerrar_sessoes_zumbis = configuracoes["enterprise"]["licenciamento"]["horaJobEncerrarSessoesZumbis"]
valor_minuto_cron_job_encerrar_sessoes_zumbis = configuracoes["enterprise"]["licenciamento"]["minutoJobEncerrarSessoesZumbis"]
tempo_cache_validacao_token_usuario_segundos = configuracoes["enterprise"]["tempoCacheValidacaoTokenUsuarioSegundos"]
ip_linux = configuracoes["acessos"]["servidorLinux"]["host"] if configuracoes["acessos"]["servidorLinux"]["host"] else ip_enterprise

garantir_shared_network(cliente_linux)

host_mu_whatsapp, porta_mu_whatsapp = obter_host_porta_mu_whatsapp_para_enterprise(configuracoes)
microkafka_host = obter_host_microkafka_para_enterprise(configuracoes)
nome_container_api_gateway = obter_nome_container_api_gateway(configuracoes)

cliente_linux.executar_comando(
    fr'docker login gitlab.microuniverso.com.br:5050 -u {usuario_registro_docker} -p {senha_registro_docker}',
    disparar_excecao_se_retorno_nao_zero=False
)


def obter_autenticacao_usuario(versao_enterprise):
    versao_real = versao_enterprise.replace("-linux", "")
    partes = versao_real.split(".")
    eh_versao_oficial = len(partes) == 3 and all(parte.isdigit() for parte in partes)

    if not eh_versao_oficial:
        return configuracoes["enterprise"]["autenticacaoUsuario"]

    versao_com_geracao_de_token = (5, 1, 7)
    versao_atual = tuple(int(parte) for parte in partes)

    if versao_atual >= versao_com_geracao_de_token:
        return configuracoes["enterprise"]["autenticacaoUsuario"]

    return "REST_LEGADO"


def obter_porta_renderizador_master(porta_renderizador_normal):
    porta_renderizador_master = str(PORTA_RENDERIZADOR_ENTERPRISE_MASTER)

    if str(porta_renderizador_normal) != porta_renderizador_master:
        return porta_renderizador_master

    return str(int(porta_renderizador_master) + 1)


def argumento_projeto_compose(projeto_compose):
    return f"-p {projeto_compose} " if projeto_compose else ""


def executar_docker_compose(instancia, arquivo_compose, comando):
    cliente_linux.executar_comando(
        f"docker compose {argumento_projeto_compose(instancia['projeto_compose'])}"
        f"-f {instancia['diretorio_remoto']}/{arquivo_compose} {comando}"
    )


def substituir_placeholders_composes(instancia):
    imagem_enterprise = configuracoes["enterprise"]["imagem"]["nome"] + ":" + instancia["versao"]
    imagem_renderizador = configuracoes["enterprise"]["renderizador"]["imagem"]["nome"] + ":" + instancia["versao"]

    substituicoes_api = {
        r"\$IMAGEM": imagem_enterprise,
        r"\$NOME_CONTAINER_ENTERPRISE": instancia["nome_container_enterprise"],
        r"\$NOME_CONTAINER_ENTERPRISE_EVENT_HANDLER": instancia["nome_container_enterprise_event_handler"],
        r"\$PORTA": instancia["porta_enterprise"],
        r"\$PORTA_INTERNA": porta_enterprise_interna,
        r"\$PORTA_AUXILIAR": instancia["porta_auxiliar"],
        r"\$MICROKAFKA_HOST": microkafka_host,
    }

    substituir_placeholders_arquivo(
        cliente_linux,
        f"{instancia['diretorio_remoto']}/{compose_normal}",
        substituicoes_api
    )

    substituicoes_renderizador = dict(substituicoes_api)
    substituicoes_renderizador.update({
        r"\$RENDERIZADOR_IMAGEM": imagem_renderizador,
        r"\$NOME_CONTAINER_ENTERPRISE_RENDERIZADOR": instancia["nome_container_enterprise_renderizador"],
        r"\$RENDERIZADOR_PORTA": instancia["porta_renderizador"],
        r"\$MEMORIA_MINIMA_RENDERIZADOR": memoria_minima_em_mb_heap_renderizador,
        r"\$MEMORIA_MAXIMA_RENDERIZADOR": memoria_maxima_em_mb_heap_renderizador,
    })

    substituir_placeholders_arquivo(
        cliente_linux,
        f"{instancia['diretorio_remoto']}/{compose_renderizador}",
        substituicoes_renderizador
    )


def substituir_config_env(instancia):
    caminho_config_env = f"{instancia['diretorio_remoto']}/config.env"
    autenticacao_usuario = obter_autenticacao_usuario(instancia["versao"])

    cliente_linux.copiar_arquivo(
        fr'{diretorio_scripts_implantacao}\enterprise\config.env',
        caminho_config_env
    )

    cliente_linux.executar_comando(fr"sed -i 's,\$AUTENTICACAO_USUARIO,{autenticacao_usuario},g' {caminho_config_env}")
    host_banco_ajustado = host_banco.replace("\\", "#@#")
    cliente_linux.executar_comando(fr"sed -i 's,\$DB_HOST,{host_banco_ajustado},g' {caminho_config_env}")

    if cliente_linux.tipo_conexao == TipoConexao.SSH:
        cliente_linux.executar_comando(fr"sed -i 's/#@#/\\/g' {caminho_config_env}")
    if cliente_linux.tipo_conexao == TipoConexao.WSL:
        cliente_linux.executar_comando(fr"sed -i 's/#@#/\\\\/g' {caminho_config_env}")

    cliente_linux.executar_comando(fr"sed -i 's,\$DB_NAME,{nome_banco},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$DB_PASSWORD,{senha_banco},g' {caminho_config_env}", echoar=False, descricao="Alterando senha do banco")
    cliente_linux.executar_comando(fr"sed -i 's,\$DB_PORT,1433,g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$DB_USER,{usuario_banco},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$MU_DLL_REST_API_ADDRESS,{ip_host},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$MU_DLL_REST_API_PORT,{porta_mu_dll_rest},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$NEOCREDIT_ENVIO_PROCESSAMENTO_URL,{neocredit_envio_processamento_url},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$NEOCREDIT_TOKEN,{neocredit_token},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$REST_LEGADO_HOST,{ip_host},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$REST_LEGADO_PORTA,{porta_rest_legado},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$WEB_HOOK_URL,{neocredit_url_webhook},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$USANDO_SQLSERVER_2008,{sql_server_2008},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$ATIVAR_JOB_REPROCESSAMENTO_CUSTO_MEDIO_ONLINE,{ativar_reprocessamento_custo_medio_online},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$VALOR_HORA_CRON_JOB_REPROCESSAMENTO_CUSTO_MEDIO_ONLINE,{hora_reprocessamento_custo_medio_online},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$VALOR_MINUTO_CRON_JOB_REPROCESSAMENTO_CUSTO_MEDIO_ONLINE,{minuto_reprocessamento_custo_medio_online},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$ATIVAR_JOB_RETORNO_COLETA_PRECO_SIGEPRO,{ativar_job_retorno_coleta_preco_sigepro},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$VALOR_HORA_CRON_JOB_RETORNO_COLETA_PRECO_SIGEPRO,{valor_hora_cron_job_retorno_coleta_preco_sigepro},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$TOKEN_ACESSO_LOGS,{token_acesso_logs},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$MU_WHATSAPP_API_HOST,{host_mu_whatsapp},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$MU_WHATSAPP_API_PORT,{porta_mu_whatsapp},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$API_KEY_INTEGRACAO_TECNOSPEED,{api_key_integracao_tecnospeed},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$AMBIENTE_TESTE_INTEGRACAO_PIX_PRAZO,{certificados_pix_ambiente_teste},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$LICENCIAMENTO_TIMEOUT_SESSAO_SEGUNDOS,{licenciamento_timeout_sessao_segundos},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$ATIVAR_JOB_ENCERRAR_SESSOES_ZUMBIS,{ativar_job_encerrar_sessoes_zumbis},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$VALOR_HORA_CRON_JOB_ENCERRAR_SESSOES_ZUMBIS,{valor_hora_cron_job_encerrar_sessoes_zumbis},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$VALOR_MINUTO_CRON_JOB_ENCERRAR_SESSOES_ZUMBIS,{valor_minuto_cron_job_encerrar_sessoes_zumbis},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$VALIDAR_TOKEN_USUARIO_CACHE_TTL_SEGUNDOS,{tempo_cache_validacao_token_usuario_segundos},g' {caminho_config_env}")
    cliente_linux.executar_comando(fr"sed -i 's,\$IP_SERVIDOR_LINUX,{ip_linux},g' {caminho_config_env}")


def preparar_instancia(instancia):
    echo(
        f"Configurando {instancia['descricao']} da API Enterprise "
        f"({instancia['versao']}) na porta {instancia['porta_enterprise']}"
    )

    cliente_linux.executar_comando(f"mkdir -p {instancia['diretorio_remoto']}")
    cliente_linux.copiar_arquivo(
        fr'{diretorio_scripts_implantacao}\enterprise\docker-compose-enterprise-linux.yml',
        f"{instancia['diretorio_remoto']}/{compose_normal}"
    )
    cliente_linux.copiar_arquivo(
        fr'{diretorio_scripts_implantacao}\enterprise\docker-compose-renderizador.yml',
        f"{instancia['diretorio_remoto']}/{compose_renderizador}"
    )

    substituir_placeholders_composes(instancia)
    substituir_config_env(instancia)


def subir_instancia(instancia):
    try:
        fazer_backup_volume_docker(instancia["volume_tokens"], arquivo_configuracao)
    except Exception as e:
        echo(f"[WARN] Falha ao fazer backup do volume '{instancia['volume_tokens']}': {str(e)}", "info")

    try:
        executar_docker_compose(instancia, compose_renderizador, "down")
    except Exception as e:
        echo(f"[WARN] Falha ao dar down no compose renderizador ({instancia['descricao']}): {str(e)}", "info")

    try:
        executar_docker_compose(instancia, compose_normal, "down")
    except Exception as e:
        echo(f"[WARN] Falha ao dar down no compose normal ({instancia['descricao']}): {str(e)}", "info")

    arquivo_docker_compose = compose_renderizador if configurar_renderizador else compose_normal

    try:
        executar_docker_compose(instancia, arquivo_docker_compose, "pull")
        executar_docker_compose(instancia, arquivo_docker_compose, "up -d")
    except Exception as e:
        echo(
            "Nao foi possivel configurar a Api Enterprise com o Renderizador. "
            f"Configurando apenas a Api Enterprise no lugar. Detalhe do erro: {str(e)}",
            "info"
        )
        arquivo_docker_compose = compose_normal
        executar_docker_compose(instancia, compose_normal, "pull")
        executar_docker_compose(instancia, compose_normal, "up -d")

    if instancia["conectar_api_gateway"] and not deve_forcar_uso_rede_externa(configuracoes):
        conectar_container_shared_network(cliente_linux, nome_container_api_gateway, reiniciar_apos_conexao=True)

    if not configurar_event_handler:
        executar_docker_compose(instancia, arquivo_docker_compose, "rm -fs enterprise-event-handler")

    try:
        if configurar_api_mu_whatsapp:
            restaurar_backup_volume_docker(instancia["volume_tokens"], arquivo_configuracao)
    except Exception as e:
        echo(f"[WARN] Falha ao restaurar backup do volume '{instancia['volume_tokens']}' apos a configuracao: {str(e)}", "info")


def aplicar_certificados_pix(instancias):
    pasta_temporaria_itau_certs = configuracoes["enterprise"]["certificadosPix"]["pastaTemporaria"]

    if not pasta_temporaria_itau_certs:
        echo("Pasta temporaria dos certificados Pix nao informada. Nao sera copiada para o servidor Linux.", "info")

    arquivos_enc = (
        [f for f in os.listdir(pasta_temporaria_itau_certs) if f.endswith('.enc')]
        if pasta_temporaria_itau_certs and os.path.exists(pasta_temporaria_itau_certs)
        else []
    )

    if len(arquivos_enc) % 2 != 0 and len(arquivos_enc) <= 2:
        echo("Pasta temporaria dos certificados Pix invalida. Devem existir os dois arquivos ou nenhum deles.", "error")
        exit(1)

    certificados_configurados = certificados_pix_configurados

    if pasta_temporaria_itau_certs and os.path.exists(pasta_temporaria_itau_certs) and len(arquivos_enc) == 2:
        try:
            cliente_linux.executar_comando(f"rm -rf /home/{usuario}/certificadoPix")
        except Exception as e:
            echo(f"[WARN] Falha ao remover pasta /home/{usuario}/certificadoPix no servidor Linux: {str(e)}", "info")

        cliente_linux.executar_comando(f"mkdir -p /home/{usuario}/certificadoPix")

        for arquivo in arquivos_enc:
            cliente_linux.copiar_arquivo(
                fr'{pasta_temporaria_itau_certs}\{arquivo}',
                f"/home/{usuario}/certificadoPix/{arquivo}"
            )

        for instancia in instancias:
            cliente_linux.executar_comando(f"docker stop {instancia['nome_container_enterprise']}")
            cliente_linux.executar_comando(
                f"docker run --rm "
                f"-v {instancia['volume_certs']}:/certs "
                f"-v /home/{usuario}/certificadoPix:/from "
                f"busybox sh -c 'cp /from/*.enc /certs/'"
            )
            cliente_linux.executar_comando(f"docker start {instancia['nome_container_enterprise']}")

        certificados_configurados = True

    elif certificados_configurados:
        cliente_linux.executar_comando(
            f"docker run --rm "
            f"-v enterprise_certs_volume:/from "
            f"-v {PROJETO_COMPOSE_ENTERPRISE_MASTER}_certs_volume:/to "
            f"busybox sh -c 'cp -a /from/. /to/ 2>/dev/null || true'"
        )

    if not certificados_configurados:
        for instancia in instancias:
            cliente_linux.executar_comando(
                f"docker run --rm "
                f"-v {instancia['volume_certs']}:/certs "
                f"-v /home/{usuario}/certificadoPix:/from "
                f"busybox sh -c 'rm -f /certs/*.enc'"
            )

    if pasta_temporaria_itau_certs and os.path.exists(pasta_temporaria_itau_certs):
        try:
            shutil.rmtree(pasta_temporaria_itau_certs)
        except Exception as e:
            echo(f"[WARN] Falha ao remover pasta temporaria dos certificados Pix: {str(e)}", "info")

    try:
        cliente_linux.executar_comando(f"rm -rf /home/{usuario}/certificadoPix")
    except Exception as e:
        echo(f"[WARN] Falha ao remover pasta /home/{usuario}/certificadoPix no servidor Linux: {str(e)}", "info")


instancia_normal = {
    "descricao": "instancia normal",
    "diretorio_remoto": f"/home/{usuario}/enterprise",
    "projeto_compose": None,
    "versao": configuracoes["enterprise"]["imagem"]["versao"],
    "porta_enterprise": configuracoes["enterprise"]["porta"],
    "porta_auxiliar": PORTA_AUXILIAR_ENTERPRISE_PADRAO,
    "porta_renderizador": configuracoes["enterprise"]["renderizador"]["porta"],
    "nome_container_enterprise": obter_nome_container_enterprise(configuracoes),
    "nome_container_enterprise_event_handler": obter_nome_container_enterprise_event_handler(configuracoes),
    "nome_container_enterprise_renderizador": obter_nome_container_enterprise_renderizador(configuracoes),
    "volume_tokens": "enterprise_tokens-muwhatsapp-volume",
    "volume_certs": "enterprise_certs_volume",
    "conectar_api_gateway": True,
}

instancia_master = {
    "descricao": "replica master",
    "diretorio_remoto": f"/home/{usuario}/{PROJETO_COMPOSE_ENTERPRISE_MASTER}",
    "projeto_compose": PROJETO_COMPOSE_ENTERPRISE_MASTER,
    "versao": VERSAO_ENTERPRISE_MASTER,
    "porta_enterprise": PORTA_ENTERPRISE_MASTER,
    "porta_auxiliar": PORTA_AUXILIAR_ENTERPRISE_MASTER,
    "porta_renderizador": obter_porta_renderizador_master(configuracoes["enterprise"]["renderizador"]["porta"]),
    "nome_container_enterprise": NOME_CONTAINER_ENTERPRISE_MASTER,
    "nome_container_enterprise_event_handler": NOME_CONTAINER_ENTERPRISE_EVENT_HANDLER_MASTER,
    "nome_container_enterprise_renderizador": NOME_CONTAINER_ENTERPRISE_RENDERIZADOR_MASTER,
    "volume_tokens": f"{PROJETO_COMPOSE_ENTERPRISE_MASTER}_tokens-muwhatsapp-volume",
    "volume_certs": f"{PROJETO_COMPOSE_ENTERPRISE_MASTER}_certs_volume",
    "conectar_api_gateway": False,
}

instancias = [instancia_normal, instancia_master]

for instancia in instancias:
    preparar_instancia(instancia)
    subir_instancia(instancia)

aplicar_certificados_pix(instancias)

exit(0)
