from lib.obter_configuracoes import obter_configuracoes
import sys
from lib.echo import echo
from lib.executar_validacoes_servidor_linux import executar_validacoes_servidor_linux
from lib.ClienteLinux import obter_cliente_linux

VERSAO_CENTRAL_DE_RELATORIOS_MASTER = "1.4.1"
PORTA_CENTRAL_DE_RELATORIOS_MASTER = "3000"
PORTA_ENTERPRISE_MASTER = "5000"
PORTA_RENDERIZADOR_ENTERPRISE_MASTER = "7002"
NOME_CONTAINER_CENTRAL_DE_RELATORIOS = "central-de-relatorios"
NOME_CONTAINER_CENTRAL_DE_RELATORIOS_MASTER = "central-de-relatorios-master"
PROJETO_COMPOSE_CENTRAL_DE_RELATORIOS_MASTER = "central-de-relatorios-master"

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

configuracoes = obter_configuracoes(arquivo_configuracao)

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

if not configuracoes["centralDeRelatorios"]["configurar"]:
    echo("Configuracao da Central de Relatorios 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']

usuario_registro_docker = configuracoes["acessos"]["registroDocker"]["usuario"]
senha_registro_docker = configuracoes["acessos"]["registroDocker"]["senha"]

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 executar_docker_compose(caminho_compose, comando, projeto=None):
    argumento_projeto = f"-p {projeto} " if projeto else ""
    cliente_linux.executar_comando(
        f"docker compose {argumento_projeto}-f {caminho_compose} {comando}"
    )


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 configurar_central_de_relatorios(
    descricao,
    diretorio_remoto,
    nome_container,
    versao,
    porta,
    porta_enterprise,
    porta_renderizador,
    projeto_compose=None
):
    caminho_compose = f'{diretorio_remoto}/docker-compose.yml'

    echo(f"Configurando {descricao} da Central de Relatorios ({versao}) na porta {porta}")

    cliente_linux.executar_comando(f'mkdir -p {diretorio_remoto}')
    cliente_linux.copiar_arquivo(
        fr'{diretorio_scripts_implantacao}\centralDeRelatorios\docker-compose-central-de-relatorios.yml',
        caminho_compose
    )

    url_api_enterprise = "{protocolo}://{host}:{porta}".format(
        protocolo="http",
        host=configuracoes["centralDeRelatorios"]["enterprise"]["host"],
        porta=porta_enterprise
    )

    url_rest_legado = "{protocolo}://{host}:{porta}".format(
        protocolo="http",
        host=configuracoes["centralDeRelatorios"]["rest"]["host"],
        porta=configuracoes["centralDeRelatorios"]["rest"]["porta"]
    )

    url_api_renderizacao = "{protocolo}://{host}:{porta}".format(
        protocolo="http",
        host=configuracoes["centralDeRelatorios"]["enterprise"]["host"],
        porta=porta_renderizador
    )

    cliente_linux.executar_comando(fr"sed -i 's,\$URL_API_ENTERPRISE,{url_api_enterprise},g' {caminho_compose}")
    cliente_linux.executar_comando(fr"sed -i 's,\$URL_API_REST,{url_rest_legado},g' {caminho_compose}")
    cliente_linux.executar_comando(fr"sed -i 's,\$URL_API_RENDERIZACAO,{url_api_renderizacao},g' {caminho_compose}")
    cliente_linux.executar_comando(fr"sed -i 's,\$VERSAO_CENTRAL_DE_RELATORIOS,{versao},g' {caminho_compose}")
    cliente_linux.executar_comando(fr"sed -i 's,\$PORTA,{porta},g' {caminho_compose}")
    cliente_linux.executar_comando(fr"sed -i 's,\$NOME_CONTAINER_CENTRAL_DE_RELATORIOS,{nome_container},g' {caminho_compose}")

    executar_docker_compose(caminho_compose, "down", projeto_compose)
    executar_docker_compose(caminho_compose, "up -d", projeto_compose)


porta_renderizador_normal = configuracoes["enterprise"]["renderizador"]["porta"]
porta_renderizador_master = (
    obter_porta_renderizador_master(porta_renderizador_normal)
    if configuracoes["enterprise"]["renderizador"]["configurar"]
    else porta_renderizador_normal
)

configurar_central_de_relatorios(
    "instancia normal",
    f'/home/{usuario}/CentralDeRelatorios',
    NOME_CONTAINER_CENTRAL_DE_RELATORIOS,
    configuracoes["centralDeRelatorios"]["versao"],
    configuracoes["centralDeRelatorios"]["porta"],
    configuracoes["centralDeRelatorios"]["enterprise"]["porta"],
    porta_renderizador_normal
)

configurar_central_de_relatorios(
    "replica master",
    f'/home/{usuario}/CentralDeRelatorios-master',
    NOME_CONTAINER_CENTRAL_DE_RELATORIOS_MASTER,
    VERSAO_CENTRAL_DE_RELATORIOS_MASTER,
    PORTA_CENTRAL_DE_RELATORIOS_MASTER,
    PORTA_ENTERPRISE_MASTER,
    porta_renderizador_master,
    PROJETO_COMPOSE_CENTRAL_DE_RELATORIOS_MASTER
)

exit(0)
