#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <ctime>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

#include "nlsClient.h"
#include "nlsEvent.h"
#include "nlsToken.h"
#include "flowingSynthesizerRequest.h"

#define SAMPLE_RATE_16K 16000
#define DEFAULT_STRING_LEN 512
#define AUDIO_TEXT_LENGTH 2048

/**
 * 全局維護一個服務鑒權token和其對應的有效期時間戳，
 * 每次調用服務之前，首先判斷token是否已經過期，
 * 如果已經過期，則根據AccessKey ID和AccessKey
 * Secret重新生成一個token，并更新這個全局的token和其有效期時間戳。
 *
 * 注意：不要每次調用服務之前都重新生成新token，只需在token即將過期時重新生成即可。所有的服務并發可共用一個token。
 */
// 自定義線程參數
struct ParamStruct {
  char text[AUDIO_TEXT_LENGTH];
  char token[DEFAULT_STRING_LEN];
  char appkey[DEFAULT_STRING_LEN];
  char url[DEFAULT_STRING_LEN];

  pthread_mutex_t mtx;
};

// 自定義事件回調參數
struct ParamCallBack {
 public:
  explicit ParamCallBack(ParamStruct* param) {
    tParam = param;
    pthread_mutex_init(&mtxWord, NULL);
    pthread_cond_init(&cvWord, NULL);
  };
  ~ParamCallBack() {
    tParam = NULL;
    pthread_mutex_destroy(&mtxWord);
    pthread_cond_destroy(&cvWord);
  };

  pthread_mutex_t mtxWord;
  pthread_cond_t cvWord;

  ParamStruct* tParam;
};

std::string g_appkey = "";
std::string g_akId = "";
std::string g_akSecret = "";
std::string g_token = "";
std::string g_url = "";
std::string g_voice = "xiaoyun";
int g_threads = 1;
bool g_save_audio = true;
std::string g_text = "";
std::string g_format = "wav";
long g_expireTime = -1;
static int sample_rate = SAMPLE_RATE_16K;
static bool enableSubtitle = false;

std::vector<std::string> splitString(
    const std::string& str, const std::vector<std::string>& delimiters) {
  std::vector<std::string> result;
  size_t startPos = 0;

  // 查找字符串中的每個分隔符
  while (startPos < str.length()) {
    size_t minPos = std::string::npos;
    size_t delimiterLength = 0;

    for (std::vector<std::string>::const_iterator it = delimiters.begin();
         it != delimiters.end(); ++it) {
      std::size_t position = str.find(*it, startPos);
      // 查找最近的分隔符
      if (position != std::string::npos &&
          (minPos == std::string::npos || position < minPos)) {
        minPos = position;
        delimiterLength = it->size();
      }
    }

    // 如果找到分隔符，則提取前面的字符串
    if (minPos != std::string::npos) {
      result.push_back(str.substr(startPos, minPos - startPos));
      startPos = minPos + delimiterLength;
    } else {
      // 沒有更多分隔符，剩下的全部是一個部分
      result.push_back(str.substr(startPos));
      break;
    }
  }

  return result;
}

/**
 * 根據AccessKey ID和AccessKey Secret重新生成一個token，并獲取其有效期時間戳
 */
int generateToken(std::string akId, std::string akSecret, std::string* token,
                  long* expireTime) {
  AlibabaNlsCommon::NlsToken nlsTokenRequest;
  nlsTokenRequest.setAccessKeyId(akId);
  nlsTokenRequest.setKeySecret(akSecret);

  int retCode = nlsTokenRequest.applyNlsToken();
  /*獲取失敗原因*/
  if (retCode < 0) {
    std::cout << "Failed error code: " << retCode
              << "  error msg: " << nlsTokenRequest.getErrorMsg() << std::endl;
    return retCode;
  }

  *token = nlsTokenRequest.getToken();
  *expireTime = nlsTokenRequest.getExpireTime();

  return 0;
}

void OnSynthesisStarted(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout << "OnSynthesisStarted:"
            << "  status code: " << cbEvent->getStatusCode()
            << "  task id: " << cbEvent->getTaskId()
            << "  all response:" << cbEvent->getAllResponse() << std::endl;
}

/**
 * @brief sdk在接收到云端返回合成結束消息時, sdk內部線程上報Completed事件
 * @note 上報Completed事件之后，SDK內部會關閉識別連接通道.
 * @param cbEvent 回調事件結構, 詳見nlsEvent.h
 * @param cbParam 回調自定義參數，默認為NULL, 可以根據需求自定義參數
 * @return
 */
void OnSynthesisCompleted(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout
      << "OnSynthesisCompleted: "
      << ", status code: "
      << cbEvent
             ->getStatusCode()  // 獲取消息的狀態碼，成功為0或者20000000，失敗時對應失敗的錯誤碼
      << ", task id: "
      << cbEvent->getTaskId()  // 當前任務的task id，方便定位問題，建議輸出
      << std::endl;
  std::cout << "OnSynthesisCompleted: All response:"
            << cbEvent->getAllResponse()
            << std::endl;  // 獲取服務端返回的全部信息
}

/**
 * @brief 合成過程發生異常時, sdk內部線程上報TaskFailed事件
 * @note 上報TaskFailed事件之后，SDK內部會關閉識別連接通道.
 * @param cbEvent 回調事件結構, 詳見nlsEvent.h
 * @param cbParam 回調自定義參數，默認為NULL, 可以根據需求自定義參數
 * @return
 */
void OnSynthesisTaskFailed(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  FILE* failed_stream = fopen("synthesisTaskFailed.log", "a+");
  if (failed_stream) {
    char outbuf[1024] = {0};
    snprintf(outbuf, sizeof(outbuf),
             "OnSynthesisTaskFailed status code:%d task id:%s error mesg:%s\n",
             cbEvent->getStatusCode(), cbEvent->getTaskId(),
             cbEvent->getErrorMessage());
    std::cout << outbuf << std::endl;
    fwrite(outbuf, strlen(outbuf), 1, failed_stream);
    fclose(failed_stream);
  }
}

/**
 * @brief 識別結束或發生異常時，會關閉連接通道,
 * sdk內部線程上報ChannelCloseed事件
 * @param cbEvent 回調事件結構, 詳見nlsEvent.h
 * @param cbParam 回調自定義參數，默認為NULL, 可以根據需求自定義參數
 * @return
 */
void OnSynthesisChannelClosed(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  ParamCallBack* tmpParam = static_cast<ParamCallBack*>(cbParam);
  if (tmpParam) {
    std::cout << "OnSynthesisChannelClosed: "
              << ", All response: " << cbEvent->getAllResponse()
              << std::endl;  // 獲取服務端返回的全部信息
  }
}

/**
 * @brief 文本上報服務端之后, 收到服務端返回的二進制音頻數據,
 * SDK內部線程通過BinaryDataRecved事件上報給用戶
 * @param cbEvent 回調事件結構, 詳見nlsEvent.h
 * @param cbParam 回調自定義參數，默認為NULL, 可以根據需求自定義參數
 * @return
 * @notice 此處切記不可做block操作,只可做音頻數據轉存. 若在此回調中做過多操作,
 *         會阻塞后續的數據回調和completed事件回調.
 */
void OnBinaryDataRecved(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::vector<unsigned char> data =
      cbEvent->getBinaryData();  // getBinaryData() 獲取文本合成的二進制音頻數據
  std::cout
      << "  OnBinaryDataRecved: status code: "
      << cbEvent
             ->getStatusCode()  // 獲取消息的狀態碼，成功為0或者20000000，失敗時對應失敗的錯誤碼
      << ", taskId: "
      << cbEvent->getTaskId()  // 當前任務的task id，方便定位問題，建議輸出
      << ", data size: " << data.size()  // 數據的大小
      << std::endl;

  if (g_save_audio && data.size() > 0) {
    // 以追加形式將二進制音頻數據寫入文件
    std::string dir = "./tts_audio";
    if (access(dir.c_str(), 0) == -1) {
      mkdir(dir.c_str(), S_IRWXU);
    }
    char file_name[256] = {0};
    snprintf(file_name, 256, "%s/%s.%s", dir.c_str(), cbEvent->getTaskId(),
             g_format.c_str());
    FILE* tts_stream = fopen(file_name, "a+");
    if (tts_stream) {
      fwrite((char*)&data[0], data.size(), 1, tts_stream);
      fclose(tts_stream);
    }
  }
}

void OnSentenceBegin(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout
      << "OnSentenceBegin "
      << "Response: "
      << cbEvent
             ->getAllResponse()  // 獲取消息的狀態碼，成功為0或者20000000，失敗時對應失敗的錯誤碼
      << std::endl;
}

void OnSentenceEnd(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout
      << "OnSentenceEnd "
      << "Response: "
      << cbEvent
             ->getAllResponse()  // 獲取消息的狀態碼，成功為0或者20000000，失敗時對應失敗的錯誤碼
      << std::endl;
}

/**
 * @brief 返回 tts 文本對應的日志信息，增量返回對應的字幕信息
 * @param cbEvent 回調事件結構, 詳見nlsEvent.h
 * @param cbParam 回調自定義參數，默認為NULL, 可以根據需求自定義參數
 * @return
 */
void OnSentenceSynthesis(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout
      << "OnSentenceSynthesis "
      << "Response: "
      << cbEvent
             ->getAllResponse()  // 獲取消息的狀態碼，成功為0或者20000000，失敗時對應失敗的錯誤碼
      << std::endl;
}

/**
 * @brief 服務端返回的所有信息會通過此回調反饋,
 * @param cbEvent 回調事件結構, 詳見nlsEvent.h
 * @param cbParam 回調自定義參數，默認為NULL, 可以根據需求自定義參數
 * @return
 */
void onMessage(AlibabaNls::NlsEvent* cbEvent, void* cbParam) {
  std::cout << "onMessage: All response:" << cbEvent->getAllResponse()
            << std::endl;
}

/**
 * @brief 短鏈接模式下工作線程
 *        以 createFlowingSynthesizerRequest   <----|
 *                   |                              |
 *           request->start()                       |
 *                   |                              |
 *           request->sendText()                    |
 *                   |                              |
 *           request->stop()                        |
 *                   |                              |
 *           收到OnSynthesisChannelClosed回調        |
 *                   |                              |
 *      releaseFlowingSynthesizerRequest(request) --|
 *        進行循環。
 */
void* pthreadFunc(void* arg) {
  int testCount = 0;  // 運行次數計數，用于超過設置的loop次數后退出
  bool timedwait_flag = false;

  // 從自定義線程參數中獲取token, 配置文件等參數.
  ParamStruct* tst = static_cast<ParamStruct*>(arg);
  if (tst == NULL) {
    std::cout << "arg is not valid." << std::endl;
    return NULL;
  }

  pthread_mutex_init(&(tst->mtx), NULL);

  // 初始化自定義回調參數
  ParamCallBack cbParam(tst);

  /*
   * 1. 創建流式文本語音合成FlowingSynthesizerRequest對象.
   *
   * 流式文本語音合成文檔詳見:
   * http://bestwisewords.com/zh/isi/developer-reference/streaming-text-to-speech-synthesis/
   */

  AlibabaNls::FlowingSynthesizerRequest* request =
      AlibabaNls::NlsClient::getInstance()->createFlowingSynthesizerRequest();
  if (request == NULL) {
    std::cout << "createFlowingSynthesizerRequest failed." << std::endl;
    return NULL;
  }

  /*
   * 2. 設置用于接收結果的回調
   */
  // 設置音頻合成可以開始的回調函數
  request->setOnSynthesisStarted(OnSynthesisStarted, &cbParam);
  // 設置音頻合成結束回調函數
  request->setOnSynthesisCompleted(OnSynthesisCompleted, &cbParam);
  // 設置音頻合成通道關閉回調函數
  request->setOnChannelClosed(OnSynthesisChannelClosed, &cbParam);
  // 設置異常失敗回調函數
  request->setOnTaskFailed(OnSynthesisTaskFailed, &cbParam);
  // 設置文本音頻數據接收回調函數
  request->setOnBinaryDataReceived(OnBinaryDataRecved, &cbParam);
  // 設置字幕信息
  request->setOnSentenceSynthesis(OnSentenceSynthesis, &cbParam);
  // 一句話開始
  request->setOnSentenceBegin(OnSentenceBegin, &cbParam);
  // 一句話結束
  request->setOnSentenceEnd(OnSentenceEnd, &cbParam);
  // 設置所有服務端返回信息回調函數
  // request->setOnMessage(onMessage, &cbParam);
  // 開啟所有服務端返回信息回調函數, 其他回調(除了OnBinaryDataRecved)失效
  // request->setEnableOnMessage(true);

  /*
   * 3. 設置request的相關參數
   */
  // 發音人, 包含"xiaoyun", "ruoxi", "xiaogang"等. 可選參數, 默認是xiaoyun
  request->setVoice(g_voice.c_str());
  // 音量, 范圍是0~100, 可選參數, 默認50
  request->setVolume(50);
  // 音頻編碼格式, 可選參數, 默認是wav. 支持的格式pcm, wav, mp3
  request->setFormat("wav");
  // 音頻采樣率, 包含8000, 16000. 可選參數, 默認是16000
  request->setSampleRate(sample_rate);
  // 語速, 范圍是-500~500, 可選參數, 默認是0
  request->setSpeechRate(0);
  // 語調, 范圍是-500~500, 可選參數, 默認是0
  request->setPitchRate(0);
  // 開啟字幕
  request->setEnableSubtitle(enableSubtitle);

  // 設置AppKey, 必填參數, 請參照官網申請
  if (strlen(tst->appkey) > 0) {
    request->setAppKey(tst->appkey);
  }
  // 設置賬號校驗token, 必填參數
  if (strlen(tst->token) > 0) {
    request->setToken(tst->token);
  }

  if (strlen(tst->url) > 0) {
    request->setUrl(tst->url);
  }

  // 設置鏈接超時500ms
  // request->setTimeout(500);
  // 獲取返回文本的編碼格式
  // const char* output_format = request->getOutputFormat();
  // std::cout << "text format: " << output_format << std::endl;

  /*
   * 4.
   * start()為異步操作。成功則開始返回BinaryRecv事件。失敗返回TaskFailed事件。
   */
  std::cout << "start -> pid " << pthread_self() << std::endl;
  struct timespec outtime;
  struct timeval now;
  int ret = request->start();
  testCount++;
  if (ret < 0) {
    std::cout << "start failed. pid:" << pthread_self() << std::endl;
    const char* request_info = request->dumpAllInfo();
    if (request_info) {
      std::cout << "  all info: " << request_info << std::endl;
    }
    AlibabaNls::NlsClient::getInstance()->releaseFlowingSynthesizerRequest(
        request);  // start()失敗，釋放request對象
    return NULL;
  } else {
    std::cout << "start success. pid " << pthread_self() << std::endl;
    /*
     * 等待started事件返回表示start()成功, 然后再發送音頻數據。
     * 語音服務器存在來不及處理當前請求的情況, 10s內不返回任何回調的問題,
     * 然后在10s后返回一個TaskFailed回調, 所以需要設置一個超時機制。
     */
    std::cout << "wait started callback." << std::endl;
    gettimeofday(&now, NULL);
    outtime.tv_sec = now.tv_sec + 10;
    outtime.tv_nsec = now.tv_usec * 1000;
    pthread_mutex_lock(&(cbParam.mtxWord));
    if (ETIMEDOUT == pthread_cond_timedwait(&(cbParam.cvWord),
                                            &(cbParam.mtxWord), &outtime)) {
      std::cout << "start timeout" << std::endl;
      timedwait_flag = true;
      pthread_mutex_unlock(&(cbParam.mtxWord));
      // start()調用超時，cancel()取消當次請求。
      request->cancel();
      return NULL;
    }
    pthread_mutex_unlock(&(cbParam.mtxWord));
  }

  /*
   * 5. 模擬大模型流式返回文本結果，進行逐個語音合成
   */
  std::string text_str(tst->text);
  if (!text_str.empty()) {
    const char* delims[] = {"。", "！", "；", "？", "\n"};
    std::vector<std::string> delimiters(
        delims, delims + sizeof(delims) / sizeof(delims[0]));
    std::vector<std::string> sentences = splitString(text_str, delimiters);
    for (std::vector<std::string>::const_iterator it = sentences.begin();
         it != sentences.end(); ++it) {
      std::cout << "sendText: " << *it << std::endl;
      ret = request->sendText(it->c_str());
      if (ret < 0) {
        break;
      }
      usleep(500 * 1000);
    }  // for
    if (ret < 0) {
      std::cout << "sendText failed. pid:" << pthread_self() << std::endl;
      const char* request_info = request->dumpAllInfo();
      if (request_info) {
        std::cout << "  all info: " << request_info << std::endl;
      }
      AlibabaNls::NlsClient::getInstance()->releaseFlowingSynthesizerRequest(
          request);  // start()失敗，釋放request對象
      return NULL;
    }
  }

  /*
   * 6. start成功，開始等待接收完所有合成數據。
   *    stop()為無意義接口，調用與否都會跑完全程.
   *    cancel()立即停止工作, 且不會有回調返回, 失敗返回TaskFailed事件。
   */
  //    ret = request->cancel();
  ret = request->stop();

  /*
   * 開始等待接收完所有合成數據。
   */
  if (ret == 0) {
    /*
     * 等待started事件返回表示start()成功, 然后再發送音頻數據。
     * 語音服務器存在來不及處理當前請求的情況, 10s內不返回任何回調的問題,
     * 然后在10s后返回一個TaskFailed回調, 所以需要設置一個超時機制。
     */
    // 等待closed事件后再進行釋放, 否則會出現崩潰
    std::cout << "wait closed callback." << std::endl;
    /*
     * 語音服務器存在來不及處理當前請求, 10s內不返回任何回調的問題,
     * 然后在10s后返回一個TaskFailed回調, 錯誤信息為:
     * "Gateway:IDLE_TIMEOUT:Websocket session is idle for too long time,
     * the last directive is 'XXXX'!" 所以需要設置一個超時機制.
     */
    gettimeofday(&now, NULL);
    outtime.tv_sec = now.tv_sec + 30;
    outtime.tv_nsec = now.tv_usec * 1000;
    // 等待closed事件后再進行釋放, 否則會出現崩潰
    pthread_mutex_lock(&(cbParam.mtxWord));
    if (ETIMEDOUT == pthread_cond_timedwait(&(cbParam.cvWord),
                                            &(cbParam.mtxWord), &outtime)) {
      std::cout << "stop timeout" << std::endl;
      pthread_mutex_unlock(&(cbParam.mtxWord));
      return NULL;
    }
    pthread_mutex_unlock(&(cbParam.mtxWord));
  } else {
    std::cout << "ret is " << ret << ", pid " << pthread_self() << std::endl;
  }
  gettimeofday(&now, NULL);
  std::cout << "current request task_id:" << request->getTaskId() << std::endl;
  std::cout << "stop finished. pid " << pthread_self() << " tv: " << now.tv_sec
            << std::endl;

  /*
   * 7. 完成所有工作后釋放當前請求。
   *    請在closed事件(確定完成所有工作)后再釋放, 否則容易破壞內部狀態機,
   * 會強制卸載正在運行的請求。
   */
  const char* request_info = request->dumpAllInfo();
  if (request_info) {
    std::cout << "  all info: " << request_info << std::endl;
  }
  AlibabaNls::NlsClient::getInstance()->releaseFlowingSynthesizerRequest(
      request);
  std::cout << "release Synthesizer success. pid " << pthread_self()
            << std::endl;

  pthread_mutex_destroy(&(tst->mtx));

  return NULL;
}

/**
 * 合成多個文本數據;
 * sdk多線程指一個文本數據對應一個線程, 非一個文本數據對應多個線程.
 * 示例代碼為同時開啟4個線程合成4個文件;
 * 免費用戶并發連接不能超過2個;
 */
#define AUDIO_TEXT_NUMS 4
#define AUDIO_FILE_NAME_LENGTH 32
int flowingSynthesizerMultFile(const char* appkey, int threads) {
  /**
   * 獲取當前系統時間戳，判斷token是否過期
   */
  std::time_t curTime = std::time(0);
  if (g_token.empty()) {
    if (g_expireTime - curTime < 10) {
      std::cout << "the token will be expired, please generate new token by "
                   "AccessKey-ID and AccessKey-Secret."
                << std::endl;
      int ret = generateToken(g_akId, g_akSecret, &g_token, &g_expireTime);
      if (ret < 0) {
        std::cout << "generate token failed" << std::endl;
        return -1;
      } else {
        if (g_token.empty() || g_expireTime < 0) {
          std::cout << "generate empty token" << std::endl;
          return -2;
        }
        std::cout << "token: " << g_token << std::endl;
      }
    }
  }

  /* 不要超過AUDIO_TEXT_LENGTH */
  const char texts[AUDIO_TEXT_LENGTH] = {
      "唧唧復唧唧，木蘭當戶織。不聞機杼聲，唯聞女嘆息。問女何所思，問女何所憶。"
      "女亦無所思，女亦無所憶。昨夜見軍帖，可汗大點兵。軍書十二卷，卷卷有爺名。"
      "阿爺無大兒，木蘭無長兄。愿為市鞍馬，從此替爺征。東市買駿馬，西市買鞍韉，"
      "南市買轡頭，北市買長鞭。旦辭爺娘去，暮宿黃河邊。不聞爺娘喚女聲，但聞黃河"
      "流水鳴濺濺。旦辭黃河去，暮至黑山頭。不聞爺娘喚女聲，但聞燕山胡騎鳴啾啾。"
      " 萬里赴戎機，關山度若飛。朔氣傳金柝，寒光照鐵衣。將軍百戰死，壯士十年歸"
      "。 "
      "歸來見天子，天子坐明堂。策勛十二轉，賞賜百千強。可汗問所欲，木蘭不用尚書"
      "郎，愿馳千里足，送兒還故鄉。 "
      "爺娘聞女來，出郭相扶將；阿姊聞妹來，當戶理紅妝；小弟聞姊來，磨刀霍霍向豬"
      "羊。開我東閣門，坐我西閣床。脫我戰時袍，著我舊時裳。當窗理云鬢，對鏡帖花"
      "黃。出門看火伴，火伴皆驚忙：同行十二年，不知木蘭是女郎。 "
      "雄兔腳撲朔，雌兔眼迷離；雙兔傍地走，安能辨我是雄雌？"};

  ParamStruct pa[threads];

  for (int i = 0; i < threads; i++) {
    memset(pa[i].token, 0, DEFAULT_STRING_LEN);
    memcpy(pa[i].token, g_token.c_str(), g_token.length());

    memset(pa[i].appkey, 0, DEFAULT_STRING_LEN);
    memcpy(pa[i].appkey, appkey, strlen(appkey));

    memset(pa[i].text, 0, AUDIO_TEXT_LENGTH);
    if (g_text.empty()) {
      memcpy(pa[i].text, texts, strlen(texts));
    } else {
      memcpy(pa[i].text, g_text.data(), strlen(g_text.data()));
    }

    memset(pa[i].url, 0, DEFAULT_STRING_LEN);
    if (!g_url.empty()) {
      memcpy(pa[i].url, g_url.c_str(), g_url.length());
    }
  }

  std::vector<pthread_t> pthreadId(threads);
  // 啟動四個工作線程, 同時識別四個音頻文件
  for (int j = 0; j < threads; j++) {
    pthread_create(&pthreadId[j], NULL, &pthreadFunc, (void*)&(pa[j]));
  }

  std::cout << "start pthread_join..." << std::endl;

  for (int j = 0; j < threads; j++) {
    pthread_join(pthreadId[j], NULL);
  }

  std::cout << "flowingSynthesizerMultFile exit..." << std::endl;
  return 0;
}

int main(int argc, char* argv[]) {
  std::string g_appkey = getenv("NLS_APPKEY_ENV");
  g_akId = getenv("NLS_AK_ENV");
  g_akSecret = getenv("NLS_SK_ENV");

  std::cout << " appKey: " << g_appkey << std::endl;
  std::cout << " akId: " << g_akId << std::endl;
  std::cout << " akSecret: " << g_akSecret << std::endl;
  std::cout << " voice: " << g_voice << std::endl;
  std::cout << "\n" << std::endl;

  int ret = AlibabaNls::NlsClient::getInstance()->setLogConfig(
      "log-flowingSynthesizer", AlibabaNls::LogDebug, 400, 50, NULL);
  if (ret < 0) {
    std::cout << "set log failed." << std::endl;
    return -1;
  }

  // 設置運行環境需要的套接口地址類型, 默認為AF_INET
  // 必須在startWorkThread()前調用
  // AlibabaNls::NlsClient::getInstance()->setAddrInFamily("AF_INET");

  // 私有云部署的情況下進行直連IP的設置
  // 必須在startWorkThread()前調用
  // AlibabaNls::NlsClient::getInstance()->setDirectHost("xxx.xxx.xxx.xxx");

  std::cout << "startWorkThread begin... " << std::endl;

  // 啟動工作線程, 在創建請求和啟動前必須調用此函數
  // 入參為負時, 啟動當前系統中可用的核數
  // 高并發的情況下推薦4, 單請求的情況推薦為1
  // 若高并發CPU占用率較高, 則可填-1啟用所有CPU核
  AlibabaNls::NlsClient::getInstance()->startWorkThread(1);

  std::cout << "startWorkThread finish" << std::endl;

  // 合成多個文本
  ret = flowingSynthesizerMultFile(g_appkey.c_str(), g_threads);
  if (ret) {
    std::cout << "flowingSynthesizerMultFile failed." << std::endl;
    AlibabaNls::NlsClient::releaseInstance();
    return -2;
  }

  // 所有工作完成，進程退出前，釋放nlsClient.
  // 請注意, releaseInstance()非線程安全.
  std::cout << "releaseInstance -> " << std::endl;
  AlibabaNls::NlsClient::releaseInstance();
  std::cout << "releaseInstance done." << std::endl;

  return 0;
}