<?php

/**
 * @param BackupInfo $bkp
 * @param            $erroDef
 *
 * @return array
 */
function GetErroBkp(BackupInfo $bkp, $erroDef) {
    $msg = $msgreal = null;
    if (isset($bkp)) {
        $msg = $bkp->GetMessage();
        $msgreal = $bkp->GetRealMessage();
    }

    $erros = error_get_last();
    $msg = $msg ? $msg : "Erro ao realizar o backup!";
    $msgreal = $msgreal ? $msgreal : $erroDef;
    $msgreal .= " Sys: " . $erros["message"];

    return array("msg" => $msg, "real" => $msgreal);
}

function ServidorAtivo() {
    $data = time();
    $filename = "/tmp/backup_server.reg";
    $dataFile = file_exists($filename) ? file_get_contents($filename) : $data;

    return ($data - $dataFile) < TEMPO_EXPIRA;
}

function RegServidor() {
    $filename = "/tmp/backup_server.reg";
    $handle = fopen($filename, "w");
    fwrite($handle, time());
    fclose($handle);
}

function GetConfiguracoes($isManual = false) {
    global $tpId, $horaAtual;
    $query = GetQueryBkp($isManual);
    $result = pg_query($query);

    if (!$result) {
        Excpt("Não foi possível selecionar as configurações no banco: $query", __FUNCTION__);
    }

    $return = array();

    while ($dados = pg_fetch_array($result, null, PGSQL_ASSOC)) {
        $cfg_id = $dados["cfg_id"];
        /*
         * Qdo bkp manual ? possível indicar o tipo(audio, configuracaoes, etc) pela linha de comando.
         */
        if ($isManual && $tpId) {
            $dados["tp_id"] = $tpId;
        }
        $return[$cfg_id]['config'] = $dados;

        /*
         * Horario de agendamento do bakcup.
         */
        $agd = explode(';', $dados["qt_agenda"]);
        $return[$cfg_id]['agenda'] = $isManual ? array($horaAtual) : $agd;

        $email = explode(';', $dados["cfg_email"]);
        $return[$cfg_id]['email'] = $email;
        //b.dst_host, b.dst_porta, b.dst_user_anonimo, b.dst_user, b.dst_senha, dst_diretorio
        $return[$cfg_id]['destino'] = array
            (
            "proto" => $dados["prt_id"],
            "host" => $dados["dst_host"],
            "port" => $dados["dst_porta"],
            "anon" => $dados["dst_user_anonimo"],
            "user" => $dados["dst_user"],
            "pass" => $dados["dst_senha"],
            "dir" => $dados["dst_diretorio"],
            "timeout" => 15
        );
    }
    return $return;
}

function GetQueryBkp($isManual = 0) {
    //case when(b.prt_id = 4)then b.dst_diretorio_local else b.dst_diretorio_remoto end as dst_diretorio
//    $param = $isManual ? " and a.cfg_id = 0 " : " and a.cfg_status <> 9 ";
    $param = " and a.cfg_status <> 9 ";

    return "SELECT a.cfg_id, a.cfg_descricao,  a.cfg_deleta_antigo, a.cfg_email, a.tp_id, a.frq_id, a.qt_id, f.qt_agenda,
                     b.prt_id, b.dst_host, b.dst_porta, b.dst_user_anonimo, b.dst_user, b.dst_senha, b.dst_diretorio_remoto AS dst_diretorio                    
                FROM pbx_backup_configuracao a, pbx_backup_destino b, pbx_backup_protocolo c, pbx_backup_tipo d,
                     pbx_backup_frequencia e, pbx_backup_frequencia_qtde f
               WHERE b.dst_id = a.dst_id
                 AND c.prt_id = b.prt_id
                 AND d.tp_id = a.tp_id
                 AND e.frq_id = a.frq_id
                 AND f.qt_id = a.qt_id" . $param;
}

function VerificaBkpReg($cfg_id, $data, $hora) {
    global $isManual, $debug;
    if ($isManual || $debug) {
//		return true;
    }

    $query = "select count(*) from pbx_backup where cfg_id = '$cfg_id' and bkp_data = '$data' and bkp_hora = '$hora' and bkp_status = 0";
    $result = pg_query($query);
    if (!$result) {
        Excpt("Não foi possível verificar o registro do backup: $query", __FUNCTION__, ErrorGetLast());
    }
    $row = pg_fetch_row($result);

    return !$row[0];
}

function RegistraBkp($db, $bkpInfo, $bkpFile, $erros = array()) {
    global $configDestinoUid;
    try {
        $regErro = count($erros);
        $result = pg_query($db, 'begin');
        $query = "INSERT INTO pbx_backup(cfg_id, tp_id, bkp_arquivo, bkp_tamanho, bkp_data, bkp_hora, bkp_minuto, bkp_status,bkp_log, bkp_log_erro) VALUES(%s,%s,%s,%s,%s,%s,'0',%s,%s,%s)";

        $query = sprintf($query, QuotedStr($bkpInfo["cfg_id"]), QuotedStr($bkpInfo["tp_id"]), QuotedStr($bkpInfo["dir"]), QuotedStr($bkpInfo['size_bkp']), QuotedStr($bkpInfo["data"]), QuotedStr($bkpInfo["hora"]), ($regErro ? "'1'" : "'0'"), ($regErro ? QuotedStr($erros['msg']) : "null"), ($regErro ? QuotedStr($erros['real']) : "null"));
        $result = pg_query($db, $query);
        if (!$result) {
            Excpt("Erro ao registrar os arquivos do backup", __FUNCTION__, "Cmd-> " . $query . "Erro->" .
                    ErrorGetLast());
        }

        if (!$regErro) {
            $result = false;
            $bkp_id = GetCurrVal('pbx_backup');
            if (!$bkp_id) {
                Excpt(sprintf("Não foi possivel recuperar o id do backup: %s Data: %s Hora: %s", $bkpInfo["cfg_descricao"], $bkpInfo["data"], $bkpInfo["hora"]), __FUNCTION__);
            }

            foreach ($bkpFile as $userField => $arFils) {
                $query = "INSERT INTO pbx_backup_arquivos(cfg_id, bkp_id, arq_nome, arq_size, arq_destino, uniqueid,arq_hash)VALUES(%s,%s,%s,%s,%s,%s,%s)\n";
                $uniqueId = isset($configDestinoUid[$userField]) ? $configDestinoUid[$userField] : "null";
                $query = sprintf($query, QuotedStr($bkpInfo["cfg_id"]), QuotedStr($bkp_id), QuotedStr($arFils["origem"]), QuotedStr($arFils["size"]), QuotedStr($arFils["destino"]), QuotedStr($uniqueId), QuotedStr($arFils["hash"]));

                $result = pg_query($db, $query);
                if (!$result) {
                    break;
                }
            }
            if (!$result) {
                Excpt("Erro ao registrar os arquivos do backup", __FUNCTION__, "Cmd-> " . $query . "Erro->" .
                        ErrorGetLast());
            }
        }

        if ($result) {
            $result = pg_query($db, 'commit');
        }
        if (!$result) {
            Excpt("Não foi possivel concluir a transa??o!", __FUNCTION__, "Cmd-> " . $query . "Erro->" .
                    ErrorGetLast());
        }
        logBkp(sprintf("O backup: %s foi registrado com sucesso!", $bkpInfo["cfg_descricao"]), true, false);
    } catch (Exception $e) {
        @pg_query($db, 'rollback');
        logBkp($e->getMessage(), true, false);
    }
}

function GetBkpFiles($cfg_id, $hora, $type, BackupConfig $bkpConfig) {
    global $configDestinoUid, $dataAtualBD;

    $isManual = $bkpConfig->isManual;
    $dataManual = $bkpConfig->data;

    $listFiles = array();
    $base_bkp = $isManual ? BACKUP_PATH_BASE_MANUAL : BACKUP_PATH_BASE;

    if (!file_exists($base_bkp)) {
        $cmd = "mkdir -p $base_bkp";
        system($cmd);
        if (!file_exists($base_bkp)) {
            Excpt("Não foi possível criar o diretório base! Msg: $cmd", __FUNCTION__);
        }
    }

    $baseLocalAudio = BACKUP_PATH_AUDIO;

    $fileSqlDados = sprintf("bkp_dados_%s_%s_%s.sql", $cfg_id, $hora, Date('dmY_H'));
    $fileDadosComp = sprintf("bkp_dados_%s_%s_%s.tar.gz", $cfg_id, $hora, Date('dmY_H'));
    $fileConfig = sprintf("bkp_config_%s_%s_%s.tar.gz", $cfg_id, $hora, Date('dmY_H'));


    $cmdTarConfig = sprintf("tar -czf %s%s /etc/asterisk/* /etc/dahdi/* /var/lib/asterisk/*", $base_bkp, $fileConfig);
    $cmdDatabase = sprintf("pg_dump  pbx > %s%s", $base_bkp, $fileSqlDados);
    $cmdTarDatabase = sprintf("tar -czf %s%s -C %s %s", $base_bkp, $fileDadosComp, $base_bkp, $fileSqlDados);

    if ($type == BKP_TIPO_AUDIO) {
        if ($isManual) {
            $dataAtualBD = $dataManual;
        }

        $query = "select userfield, uniqueid from pbx_bilhetes a where data_bilhete = '$dataAtualBD'\n";
        if ($bkpConfig->isDiferencial) {
            $query .= "and not exists(select '' from pbx_backup_arquivos where uniqueid = a.uniqueid and cfg_id = '$cfg_id')\n";
        }
        $query .= "and coalesce(trim(userfield), '') <> ''\n";
        $result = pg_query($query);

        if (!$result) {
            Excpt("Não foi possível listar os arquivos de backup", __FUNCTION__);
        }
        if (!pg_num_rows($result)) {
            logBkp("Não existem arquivos para realizar o backup.");

            return false;
        }
        while ($row = pg_fetch_row($result)) {
            if (file_exists($baseLocalAudio . $row[0])) {
                $listFiles[$row[0]] = $baseLocalAudio . $row[0];
                $configDestinoUid[$row[0]] = $row[1];
            }
        }
    } else {
        if (($type == BKP_TIPO_CONFIG_DADOS) || ($type == BKP_TIPO_DADOS)) {
            /*
             * Dump da base de dados.
             */
            $ret = '';
            //system($cmdDatabase, $ret);
            $ret = ExecutaComando($cmdDatabase);
            $arquivoSqlBackup = $base_bkp . $fileSqlDados;
            if (!file_exists($arquivoSqlBackup)) {
                Excpt("Não foi possível fazer o dump da base de dados! Msg: $ret cmd: $cmdDatabase", __FUNCTION__);
            }

            /*
             * Compacta o dump.
             */
            $ret = '';
            system($cmdTarDatabase, $ret);
            $arquivoSqlComp = $base_bkp . $fileDadosComp;
            if (!file_exists($arquivoSqlComp)) {
                Excpt("Não foi possível compactar o dump da base de dados! Msg: $ret", __FUNCTION__);
            }
            $hash = hash_file("sha1", $arquivoSqlComp);
            $listFiles[$fileDadosComp] = array('file' => $arquivoSqlComp, 'hash' => $hash);
            /*
             * Exclui o dump sql.
             */
            @unlink($arquivoSqlBackup);
        }

        if (($type == BKP_TIPO_CONFIG_DADOS) || ($type == BKP_TIPO_CONFIG)) {
            /*
             * Compacta os arquivos de configura??o.
             */
            $ret = '';
            system($cmdTarConfig, $ret);
            $arquivoConfigBackup = $base_bkp . $fileConfig;
            if (!file_exists($arquivoConfigBackup)) {
                Excpt("Não foi possível compactar os aquivos de configuração! Msg: $ret", __FUNCTION__);
            }
            $hash = hash_file("sha1", $arquivoConfigBackup);
            $listFiles[$fileConfig] = array('file' => $arquivoConfigBackup, 'hash' => $hash);
        }
    }

    return $listFiles;
}

function ApagaBkp($db) {

    $nomeFile = '';
    /*
     * Armazena os backups apagados.
     */
    $bkp = array();
    $query = " SELECT a.arq_nome, c.cfg_descricao, b.bkp_data, c.tp_id, b.bkp_id
                    FROM pbx_backup_arquivos a, pbx_backup b,  pbx_backup_configuracao c
                WHERE b.bkp_id = a.bkp_id 
                AND c.cfg_id = b.cfg_id
                AND b.bkp_status = 2
                AND c.tp_id <> 1";
    $result = pg_query($db, $query);
    if (!$result) {
        Excpt("Não foi possível listar os arquivos a serem excluidos!", __FUNCTION__);
    }

    while ($dados = pg_fetch_array($result)) {
        $nomeFile = trim($dados["arq_nome"]);
        @unlink($nomeFile);
        $bkp[$dados["bkp_id"]] = 1;
    }

    $erroMsg = array();
    foreach ($bkp as $key => $value) {
        $query = "update pbx_backup set bkp_status = '3'  where bkp_id = '$key'";
        $result = pg_query($db, $query);
        if (!$result) {
            $erro = error_get_last();
            $erroMsg[] = ($query . "Erro: " . $erro["message"] . "\n");
        }
    }

    if ($erroMsg) {
        Excpt(implode($erroMsg), __FUNCTION__);
    }
}

function ApagaBkpTmp($db) {
    $nomeFile = '';
    /*
     * Armazena os backups apagados.
     */
    $bkp = array();
    $query = "SELECT a.arq_nome, c.cfg_descricao, b.bkp_data, c.tp_id, b.bkp_id 
                FROM pbx_backup_arquivos a, pbx_backup b,  pbx_backup_configuracao c
               WHERE b.bkp_id = a.bkp_id 
                 AND c.cfg_id = b.cfg_id
                 AND b.bkp_status NOT IN(2,3)
                 AND c.tp_id <> 1   
                 AND (now()::DATE - b.bkp_data) >= c.cfg_deleta_antigo
                 AND c.cfg_deleta_antigo > 0";

    $result = pg_query($db, $query);
    if (!$result) {
        Excpt("Não foi possível listar os arquivos a serem excluidos!", __FUNCTION__);
    }

    while ($dados = pg_fetch_array($result)) {
        $nomeFile = trim($dados["arq_nome"]);
        if (file_exists($nomeFile)) {
            @unlink($nomeFile);
        }
        $bkp[$dados["bkp_id"]] = 1;
    }

    $erroMsg = array();
    foreach ($bkp as $key => $value) {
        $query = "update pbx_backup set bkp_status = '4'  where bkp_id = '$key'";
        $result = pg_query($db, $query);
        if (!$result) {
            $erro = error_get_last();
            $erroMsg[] = ($query . "Erro: " . $erro["message"] . "\n");
        }
    }

    if ($erroMsg) {
        Excpt(implode($erroMsg), __FUNCTION__);
    }
}

function GetDataServer($soma = 0, $fmt = '') {
    $data = new CalcDataHora();
    if ($soma) {
        $data->somaDia($soma);
    }

    return $data->getData($fmt);
}

function GetDataHoraServer($soma = 0, $fmt = '') {
    $data = new CalcDataHora();
    if ($soma) {
        $data->somaDia($soma);
    }

    return $data->getDataHora($fmt);
}

function GetParamEmail($db) {
    $query = "SELECT wkf_smtp, wkf_smtp_port, wkf_smtp_user, wkf_smtp_senha FROM pbx_workflow_parametros";
    $result = @pg_query($db, $query);
    $row = pg_fetch_array($result);

    return $row;
}

function EnviaEmail($db, $bkpInfo, $alerta = false) {
    global $wkfParam, $isManual;

    if ($isManual) {
        return true;
    }

    $query = sprintf("SELECT cfg_email FROM pbx_backup_configuracao WHERE cfg_id = '%s'", $bkpInfo['cfg_id']);
    $result = pg_query($db, $query);
    if (!pg_num_rows($result)) {
        Excpt("Não existem emails configurados para este backup!", __FUNCTION__);
    }

    $row = pg_fetch_row($result);
    $mail = trim($row[0]);
    if (!$mail) {
        Excpt("Não existem emails configurados para este backup!", __FUNCTION__);
    }

    $emails = preg_split('/[\,,;]/', $mail);

    if (!$wkfParam) {
        $wkfParam = GetParamEmail($db);
    }
    $body = GetBody($db, $bkpInfo, $alerta);
    if (!$body) {
        Excpt("Não foi possível carregar o corpo do email!", __FUNCTION__);
    }

    $dataEnvio = date('d/m/Y');

    foreach ($emails as $email) {
        $emailNome = '';

        /*
         * Carrega parametros para o array:
         * $wkfParam[  wkf_smtp,
         * wkf_smtp_user, wkf_smtp_senha, wkf_smtp_port,  wkf_smtp_requer_aut]
         */
        $mail = new PHPMailer();
        $mail->IsSMTP();
        $mail->Host = $wkfParam["wkf_smtp"];
        $mail->Port = $wkfParam["wkf_smtp_port"];
        $mail->SMTPAuth = $wkfParam["wkf_smtp_user"] != "";

        if ($mail->SMTPAuth) {
            /*
             * Autentica??o smtp
             */
            $mail->Username = $wkfParam["wkf_smtp_user"];
            $mail->Password = $wkfParam["wkf_smtp_senha"];
        }

        $mail->From = $wkfParam["wkf_smtp_user"];
        $mail->FromName = "Backup Simples IP";

        if (!empty($emailNome)) {
            $mail->AddAddress($email, $emailNome);
        } else {
            $mail->AddAddress($email);
        }

        $mail->AddCC($wkfParam["wkf_smtp_user"], 'WorkFlow');
        $mail->IsHTML(true);
        $mail->CharSet = 'iso-8859-1';
        $mail->Subject = "Registro de Backup";

        /*
         * Adciona imagens do html
         */
        $mail->AddEmbeddedImage("/var/www/html/aplicativo/img/miniLogo.gif", "miniLogo");

        $mail->Body = $body;
        $mail->AltBody = $body;
        $enviado = $mail->Send();
        $mail->ClearAllRecipients();
        $erro = $mail->ErrorInfo;

        if (!$enviado) {
            $msg = "Email: $email n?o pode ser enviado Data Envio: $dataEnvio!";
            Excpt($msg, "EnviaEmail", $erro);
        }

        $msg = "Email: $email enviado com sucesso! Data Envio: $dataEnvio\n";
        logBkp($msg);
    }

    return true;
}

function GetBody($db, $bkpInfo, $alerta) {
    global $origem;
    $filename = "/var/lib/asterisk/scripts/backup/backup.htm";
    $arq = file_get_contents($filename);

    /*
     *  Verifica se conseguiu carregar o arquivo para compor a mensagem html a ser enviada.
     */
    if (empty($arq)) {
        Excpt("Não foi possível carregar o template do email!", __FUNCTION__);
    };

    $query = sprintf("SELECT a.cfg_descricao, b.dst_nome, b.dst_host, b.dst_diretorio_remoto, c.prt_descricao, d.tp_desc,
                             b.prt_id
                        FROM pbx_backup_configuracao a, pbx_backup_destino b, pbx_backup_protocolo c, pbx_backup_tipo d
                       WHERE b.dst_id = a.dst_id
                         AND c.prt_id = b.prt_id
                         AND d.tp_id = a.tp_id
                         AND a.cfg_id = '%s'", $bkpInfo['cfg_id']);
    $result = @pg_query($db, $query);

    /*
     *  Verifica se a consulta foi executada com sucesso.
     */
    if (!$result) {
        Excpt("Erro carregar as informa??es de configura??o do backup! Cmd: $query", __FUNCTION__, ErrorGetLast());
    };

    /*
     * Verifica se existem informa??es sobre o backup informado.
     */
    if (!pg_num_rows($result)) {
        Excpt("Não foi possível carregar as informa??es de configura??o! Cmd: $query", __FUNCTION__);
    };

    $row = pg_fetch_array($result);
    $info = array();
    $info["origem"] = $origem;
    $info["cfg_descricao"] = $row["cfg_descricao"];
    $info["data"] = $bkpInfo["data"];
    $info["hora"] = $bkpInfo["hora"];
    $info["prt_descricao"] = $row["prt_descricao"];
    $info["dst_descricao"] = ($row["prt_id"] == PROTO_LOCAL) ? "Local" : sprintf("[%s][%s][%s]", $row["dst_nome"], $row["dst_host"], $row["dst_diretorio_remoto"]);
    $info["bkp_tamanho"] = $bkpInfo["bkp_tamanho"] . "(b)";
    $info["tp_desc"] = $row["tp_desc"];
    $msg = trim($bkpInfo["log"]);

    if (!$msg) {
        $msg = trim($bkpInfo["realLog"]);
    }
    if ($alerta) {
        if (!$msg) {
            $info["msg"] = "Erro ao realizar o backup!";
        } else {
            $info["msg"] = "Erro: $msg";
        }
    } else {
        $info["msg"] = "Backup conclu?do com sucesso!";
    }

    foreach ($info as $key => $value) {
        $arq = str_replace('{' . $key . '}', $value, $arq);
    }

    return $arq;
}

function ExecutaComando($comando) {
    $query = "SELECT usuario_servidor, senha_servidor, porta_servidor FROM pbx_conf_padrao";
    $result = pg_query($query);

    $dados = pg_fetch_array($result);
    $usuario_servidor = $dados['usuario_servidor'];
    $senha_servidor = $dados['senha_servidor'];
    $porta_servidor = $dados['porta_servidor'];

    //endereco do servidor onde ser? executado o comando
    $ssh = new Net_SSH2('127.0.0.1', $porta_servidor);
    if (!$ssh->login($usuario_servidor, $senha_servidor)) {
        return false;
    }
    logBkp("Iniciando dump da base de dados");

    return $ssh->exec($comando);
}