#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <unistd.h>
#include <ctime>
#include <sys/resource.h>
#include "hrsc_sdk.h"

static std::vector<std::string> g_asr;
static struct timespec g_t0;
static double g_last_ms = 0;
static int g_n = 0;
static double now_ms() { struct timespec n; clock_gettime(CLOCK_MONOTONIC,&n); return (n.tv_sec-g_t0.tv_sec)*1000.0+(n.tv_nsec-g_t0.tv_nsec)/1e6; }

static void AsrCallback(const void *, const char *asr) {
  if (asr && *asr) { double t=now_ms(); g_last_ms=t; g_n++; printf("\n[ASR +%.0fms] %s\n", t, asr); fflush(stdout); g_asr.push_back(asr); }
}
static void AsrDataCallback(const void *, const HrscCallbackData *d) {
  if (d && d->result && *d->result) std::cout << "\n[DATA] " << d->result << std::endl;
}
static void EventCallback(const void *, HrscEventType e) { std::cout << "\n[EVENT] " << (int)e << std::endl; }
static void CmdCallback(const void *, const char *c) { if (c && *c) std::cout << "\n[CMD] " << c << std::endl; }
static void DoaCallback(const void *, int) {}
static void WkpCallback(const void *, const HrscCallbackData *, const int) {}
static void VoipCallback(const void *, const HrscCallbackData *) {}
static void ProcCallback(const void *, const HrscCallbackData *) {}
static void AuthCallback(const void *, const int code) { std::cout << "\n[AUTH] " << code << std::endl; }

static std::string ReadFile(const char *p) {
  std::ifstream s(p, std::ios::in | std::ios::binary);
  if (!s.is_open()) return "";
  std::string d((std::istreambuf_iterator<char>(s)), std::istreambuf_iterator<char>());
  return d;
}

int main(int argc, char **argv) {
  if (argc < 3) { printf("usage: %s in16k_mono.wav out.txt [channels] [ref_ch] [asr_mode]\n", argv[0]); return 2; }
  const char *wav_path = argv[1];
  const char *out_path = argv[2];
  int chn = argc > 3 ? atoi(argv[3]) : 6;
  int ref_ch = argc > 4 ? atoi(argv[4]) : 6;
  int asr_mode = argc > 5 ? atoi(argv[5]) : 2;
  double pace = argc > 6 ? atof(argv[6]) : 0.0;  // 1.0 = realtime, 0 = as fast as possible
  int fill = argc > 7 ? atoi(argv[7]) : 0;      // 0=all ch audio, 1=only ch0, 2=all but ref
  printf("fill=%d\n", fill);
  int wait_s = argc > 8 ? atoi(argv[8]) : 3;

  FILE *f = fopen(wav_path, "rb");
  if (!f) { printf("cannot open %s\n", wav_path); return 2; }
  fseek(f, 0, SEEK_END); long sz = ftell(f); fseek(f, 44, SEEK_SET);
  if (sz <= 44) { printf("bad wav\n"); return 2; }
  std::vector<short> pcm((sz - 44) / 2);
  size_t got = fread(pcm.data(), 2, pcm.size(), f);
  pcm.resize(got);
  fclose(f);

  int sr = 16000;
  double dur = (double)pcm.size() / sr;
  printf("input=%s frames=%zu dur=%.1fs chn=%d ref_ch=%d asr_mode=%d pace=%.2f\n", wav_path, pcm.size(), dur, chn, ref_ch, asr_mode, pace);
  printf("sdk version: %s\n", HrscGetVersion());

  HrscEffectConfig cfg; memset(&cfg, 0, sizeof(cfg));
  static HrscAudioConfig in_cfg, out_cfg;
  in_cfg.sample_rate = sr; in_cfg.audio_channels = chn; in_cfg.audio_format = kHrscAudioFormatPcm16Bit;
  out_cfg.sample_rate = sr; out_cfg.audio_channels = 1; out_cfg.audio_format = kHrscAudioFormatPcm16Bit;
  cfg.input_cfg = in_cfg;
  cfg.output_cfg = out_cfg;
  cfg.ref_ch_index = (unsigned char)ref_ch;
  cfg.wakeup_prefix = 200; cfg.wakeup_suffix = 200;
  cfg.asr_timeout = 5000; cfg.vad_timeout = 5000;
  cfg.target_score = 0;
  cfg.cfg_file_path = "/opt/tros/humble/lib/hobot_audio/hrsc";
  cfg.support_command_word = 0;
  cfg.is_use_linear_mic_flag = 0;
  cfg.asr_output_mode = asr_mode;
  cfg.asr_output_channel = 0;
  std::string wake = ReadFile("/opt/tros/humble/lib/hobot_audio/hrsc/cmd_word.json");
  cfg.custom_wakeup_word = wake.empty() ? nullptr : wake.c_str();
  cfg.priv = &cfg;
  cfg.HrscAsrCallback = AsrCallback;
  cfg.HrscAsrDataCallback = AsrDataCallback;
  cfg.HrscEventCallback = EventCallback;
  cfg.HrscCmdCallback = CmdCallback;
  cfg.HrscDoaCallbadk = DoaCallback;
  cfg.HrscWakeupDataCallback = WkpCallback;
  cfg.HrscVoipDataCallback = VoipCallback;
  cfg.HrscProcessedDataCallback = ProcCallback;
  cfg.HrscAuthCallback = AuthCallback;

  void *handle = HrscInit(&cfg);
  if (!handle) { printf("HrscInit FAILED\n"); return 3; }
  if (HRSC_CODE_SUCCESS != HrscStart(handle)) { printf("HrscStart FAILED\n"); return 3; }
  printf("hrsc started ok\n"); fflush(stdout);

  clock_gettime(CLOCK_MONOTONIC, &g_t0);
  struct timespec t_start = g_t0;
  const int FRAME = 512;
  double feed_secs = 0;
  std::vector<short> frame(FRAME * chn);
  size_t pos = 0; long long t_ms = 0;
  while (pos < pcm.size()) {
    size_t n = pcm.size() - pos; if (n > (size_t)FRAME) n = FRAME;
    for (size_t i = 0; i < n; i++) {
      for (int c = 0; c < chn; c++) {
        bool use = (fill == 0) ? true : (fill == 1 ? (c == 0) : (c != ref_ch));
        frame[i * chn + c] = use ? pcm[pos + i] : 0;
      }
    }
    if (n < (size_t)FRAME) memset(&frame[n * chn], 0, (FRAME - n) * chn * sizeof(short));
    HrscAudioBuffer buf; buf.audio_data = frame.data(); buf.size = FRAME * chn * sizeof(short);
    buf.start = t_ms; buf.end = t_ms + 32;
    { struct timespec a,b; clock_gettime(CLOCK_MONOTONIC,&a); HrscProcess(handle, &buf); clock_gettime(CLOCK_MONOTONIC,&b); feed_secs += (b.tv_sec-a.tv_sec)+(b.tv_nsec-a.tv_nsec)/1e9; }
    pos += n; t_ms += (FRAME * 1000) / sr;
    if (pace > 0) {
      long want_us = (long)((double)t_ms * 1000.0 / pace);
      struct timespec now; clock_gettime(CLOCK_MONOTONIC, &now);
      long now_us = (now.tv_sec - t_start.tv_sec) * 1000000L + (now.tv_nsec - t_start.tv_nsec) / 1000L;
      if (want_us > now_us) usleep(want_us - now_us);
    }
  }
  printf("\nfeed done, %.1fs audio, time_in_HrscProcess=%.2fs (=> %.2fx realtime), tail silence...\n", dur, feed_secs, dur/feed_secs); fflush(stdout);
  for (int k = 0; k < 100; k++) {
    memset(frame.data(), 0, frame.size() * sizeof(short));
    HrscAudioBuffer buf; buf.audio_data = frame.data(); buf.size = frame.size() * sizeof(short);
    buf.start = t_ms; buf.end = t_ms + 32;
    HrscProcess(handle, &buf); t_ms += (FRAME * 1000) / sr;
    usleep(1000);
  }
  printf("feed loop finished at +%.0fms, now draining async pipeline...\n", now_ms());
  double drain_start = now_ms(), last_change = now_ms();
  int last_n = g_n;
  while (now_ms() - drain_start < 300000) {
    usleep(200000);
    if (g_n != last_n) { last_n = g_n; last_change = now_ms(); }
    if (g_n > 0 && now_ms() - last_change > 5000) break;
  }
  { struct rusage ru; getrusage(RUSAGE_SELF,&ru); double cpu=ru.ru_utime.tv_sec+ru.ru_utime.tv_usec/1e6+ru.ru_stime.tv_sec+ru.ru_stime.tv_usec/1e6; printf("\n[CPU] user+sys=%.2fs / wall=%.2fs => 平均 %.2f 核在忙\n", cpu, now_ms()/1000.0, cpu/(now_ms()/1000.0)); }
  printf("\n=== 全部 %d 段结果到达，最后一段在 +%.0fms，端到端 %.2fs (音频 %.1fs => %.2fx 实时) ===\n", g_n, g_last_ms, now_ms()/1000.0, dur, dur/(now_ms()/1000.0));

  std::ofstream o(out_path);
  for (auto &s : g_asr) o << s << "\n";
  o.close();
  printf("\nsegments=%zu written=%s\n", g_asr.size(), out_path);
  HrscStop(handle);
  HrscRelease(&handle);
  return 0;
}