import sys
from lib.configurar_api_gateway import executar_configuracao_completa
from lib.obter_configuracoes import obter_configuracoes
from lib.echo import echo
from lib.executar_validacoes_servidor_linux import executar_validacoes_servidor_linux
from lib.ClienteLinux import obter_cliente_linux
import os

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. Servidor Linux nao sera configurado")
    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)
if not cliente_linux:
    echo("Não foi possível obter ClienteLinux a partir das configurações.", "error")
    exit(1)

# -------------------------------------------------------------
# SENHA SUDO (usuário tem senha; vamos usar sudo -S com stdin)
# -------------------------------------------------------------
from lib.criptografia_senha import descriptografar

senha_sudo = descriptografar(configuracoes["acessos"]["servidorLinux"]["senha"])

def executar_sudo(comando: str, echoar: bool = True, descricao: str = "", disparar_excecao_se_retorno_nao_zero: bool = True):
    """
    Executa comando com sudo usando a senha via stdin (-S).
    ATENÇÃO: se echoar=True, o comando (com senha embutida) pode aparecer no log.
    """
    cmd = f"echo '{senha_sudo}' | sudo -S -p '' {comando}"
    return cliente_linux.executar_comando(
        cmd,
        echoar=echoar,
        descricao=descricao,
        disparar_excecao_se_retorno_nao_zero=disparar_excecao_se_retorno_nao_zero
    )

def validar_sudo():
    r = cliente_linux.executar_comando(
        f"echo '{senha_sudo}' | sudo -S -p '' true",
        disparar_excecao_se_retorno_nao_zero=False,
        echoar=False
    )
    if r.codigo_retorno != 0:
        raise Exception("Falha ao executar sudo com a senha fornecida (verifique se o usuário é sudoer e a senha está correta).")

# -------------------------------------------------------------------
# LIMPEZA SEMANAL DE IMAGENS DO DOCKER (DECLARATIVO PELO YAML)
# -------------------------------------------------------------------
import tempfile
from pathlib import Path

SERVICE_NAME = "microuniverso-limpeza-docker-images"
SERVICE_PATH = f"/etc/systemd/system/{SERVICE_NAME}.service"
TIMER_PATH = f"/etc/systemd/system/{SERVICE_NAME}.timer"

ON_CALENDAR_DEFAULT = "Sun *-*-* 03:00:00"

usuario_linux = configuracoes.get("acessos", {}).get("servidorLinux", {}).get("usuario", "")
if not usuario_linux:
    echo("Usuario do servidor Linux não informado em configuracoes['acessos']['servidorLinux']['usuario']", "error")
    exit(1)

PASTA_BASE_LIMPEZA = f"/home/{usuario_linux}/limpezaImagensDocker"

def _on_calendar_do_yaml():
    v = (configuracoes.get("acessos", {})
                    .get("servidorLinux", {})
                    .get("limpezaImagensDocker", {})
                    .get("onCalendar", None))
    return v or ON_CALENDAR_DEFAULT

def _service_content():
    return """[Unit]
Description=Limpeza Semanal de imagens Docker (remove Imagens não utilizadas)
Wants=network-online.target
After=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/bin/docker image prune -a -f
"""

def _timer_content(on_calendar: str):
    return f"""[Unit]
Description=Executa {SERVICE_NAME}.service semanalmente aos domingos

[Timer]
OnCalendar={on_calendar}
Persistent=true
Unit={SERVICE_NAME}.service

[Install]
WantedBy=timers.target
"""

def _validar_systemd():
    r = cliente_linux.executar_comando("command -v systemctl", disparar_excecao_se_retorno_nao_zero=False, echoar=False)
    if r.codigo_retorno != 0:
        raise Exception("systemctl não encontrado no Linux alvo (provavelmente sem systemd).")

def _validar_docker():
    r = cliente_linux.executar_comando("test -x /usr/bin/docker", disparar_excecao_se_retorno_nao_zero=False, echoar=False)
    if r.codigo_retorno != 0:
        raise Exception("docker não encontrado em /usr/bin/docker no Linux alvo. Ajuste o ExecStart se necessário.")

def _daemon_reload():
    executar_sudo("systemctl daemon-reload", echoar=False)

def _garantir_pasta_home():
    cliente_linux.executar_comando(
        f"mkdir -p {PASTA_BASE_LIMPEZA}",
        descricao="Criando pasta limpezaImagensDocker no home do usuário",
        echoar=True
    )

def _copiar_arquivo_sistema_root(conteudo: str, destino_root: str):
    nome = Path(destino_root).name
    destino_home = f"{PASTA_BASE_LIMPEZA}/{nome}"

    with tempfile.NamedTemporaryFile(mode="w", delete=False, encoding="utf-8", suffix=f".{nome}") as f:
        caminho_local = f.name
        f.write(conteudo)

    try:
        echo(f"Copiando para Linux: {destino_home}")
        cliente_linux.copiar_arquivo(caminho_local, destino_home)

        executar_sudo(f"mv -f {destino_home} {destino_root}", echoar=False)
        executar_sudo(f"chmod 644 {destino_root}", echoar=False)

    finally:
        try:
            Path(caminho_local).unlink(missing_ok=True)
        except:
            pass

def uninstall():
    echo("Removendo service/timer do prune semanal (tarefa agendada)...")

    _validar_systemd()
    validar_sudo()

    executar_sudo(f"systemctl disable --now {SERVICE_NAME}.timer", echoar=False, disparar_excecao_se_retorno_nao_zero=False)
    executar_sudo(f"systemctl stop {SERVICE_NAME}.service", echoar=False, disparar_excecao_se_retorno_nao_zero=False)

    executar_sudo(f"rm -f {TIMER_PATH} {SERVICE_PATH}", echoar=True, descricao="Removendo arquivos do systemd", disparar_excecao_se_retorno_nao_zero=False)

    _daemon_reload()

    cliente_linux.executar_comando(f"rm -rf {PASTA_BASE_LIMPEZA}", disparar_excecao_se_retorno_nao_zero=False, echoar=False)

    echo("OK: tarefa removida (ou já não existia).")

def install():
    echo("Instalando service/timer do prune semanal...")

    _validar_systemd()
    validar_sudo()
    _validar_docker()

    _garantir_pasta_home()

    on_calendar = _on_calendar_do_yaml()

    _copiar_arquivo_sistema_root(_service_content(), SERVICE_PATH)
    _copiar_arquivo_sistema_root(_timer_content(on_calendar), TIMER_PATH)

    _daemon_reload()

    executar_sudo(f"systemctl enable --now {SERVICE_NAME}.timer", echoar=True, descricao="Habilitando timer")

    cliente_linux.executar_comando(
        f"rm -f {PASTA_BASE_LIMPEZA}/*.service {PASTA_BASE_LIMPEZA}/*.timer",
        disparar_excecao_se_retorno_nao_zero=False,
        echoar=False
    )

    echo("OK: instalado e habilitado.")
    echo(f"Agenda: {on_calendar}")

def main():
    limpeza_habilitada = bool(
        configuracoes.get("acessos", {})
                    .get("servidorLinux", {})
                    .get("limpezaImagensDocker", {})
                    .get("configurar", False)
    )

    if limpeza_habilitada:
        echo("Limpeza de imagens Docker ATIVADA na configuracao. Garantindo tarefa agendada...", "info")
        install()
    else:
        echo("Limpeza de imagens Docker DESATIVADA na configuracao. Removendo tarefa agendada...", "info")
        uninstall()

if __name__ == "__main__":
    main()
