Engine.setDirectiveFactory(
    (cls) -> {
      Directive directive = Objects.requireNonNull(Solon.context()).getBean(cls);
      if (directive != null) {
        return directive;
      }

      // 兜底
      return ClassUtil.newInstance(cls);
    });

package top.godenyear.ray.framework.aifei.db;

import cn.aifei.log.Log;
import cn.aifei.log.LogFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Aifei LogFactory 的 Slf4j 桥接实现。 解决 aifei-core 不含 Slf4jLogFactory 的问题。
 *
 * @author airhead
 */
public class Slf4jLogFactory implements LogFactory {

  @Override
  public Log getLog() {
    return getLog(LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME));
  }

  @Override
  public Log getLog(Class<?> clz) {
    return getLog(LoggerFactory.getLogger(clz));
  }

  @Override
  public Log getLog(String name) {
    return getLog(LoggerFactory.getLogger(name));
  }

  private Log getLog(Logger slf4jLogger) {
    return new Log() {
      @Override
      public String getName() {
        return slf4jLogger.getName();
      }

      @Override
      public boolean isTraceEnabled() {
        return slf4jLogger.isTraceEnabled();
      }

      @Override
      public void trace(String msg, Throwable t) {
        slf4jLogger.trace(msg, t);
      }

      @Override
      public void trace(String msg) {
        slf4jLogger.trace(msg);
      }

      @Override
      public void trace(String format, Object arg) {
        slf4jLogger.trace(format, arg);
      }

      @Override
      public void trace(String format, Object arg1, Object arg2) {
        slf4jLogger.trace(format, arg1, arg2);
      }

      @Override
      public void trace(String format, Object... args) {
        slf4jLogger.trace(format, args);
      }

      @Override
      public void trace(java.util.function.Supplier<String> supplier) {
        if (isTraceEnabled()) {
          slf4jLogger.trace(supplier.get());
        }
      }

      @Override
      public boolean isDebugEnabled() {
        return slf4jLogger.isDebugEnabled();
      }

      @Override
      public void debug(String msg, Throwable t) {
        slf4jLogger.debug(msg, t);
      }

      @Override
      public void debug(String msg) {
        slf4jLogger.debug(msg);
      }

      @Override
      public void debug(String format, Object arg) {
        slf4jLogger.debug(format, arg);
      }

      @Override
      public void debug(String format, Object arg1, Object arg2) {
        slf4jLogger.debug(format, arg1, arg2);
      }

      @Override
      public void debug(String format, Object... args) {
        slf4jLogger.debug(format, args);
      }

      @Override
      public void debug(java.util.function.Supplier<String> supplier) {
        if (isDebugEnabled()) slf4jLogger.debug(supplier.get());
      }

      @Override
      public boolean isInfoEnabled() {
        return slf4jLogger.isInfoEnabled();
      }

      @Override
      public void info(String msg, Throwable t) {
        slf4jLogger.info(msg, t);
      }

      @Override
      public void info(String msg) {
        slf4jLogger.info(msg);
      }

      @Override
      public void info(String format, Object arg) {
        slf4jLogger.info(format, arg);
      }

      @Override
      public void info(String format, Object arg1, Object arg2) {
        slf4jLogger.info(format, arg1, arg2);
      }

      @Override
      public void info(String format, Object... args) {
        slf4jLogger.info(format, args);
      }

      @Override
      public void info(java.util.function.Supplier<String> supplier) {
        if (isInfoEnabled()) slf4jLogger.info(supplier.get());
      }

      @Override
      public boolean isWarnEnabled() {
        return slf4jLogger.isWarnEnabled();
      }

      @Override
      public void warn(String msg, Throwable t) {
        slf4jLogger.warn(msg, t);
      }

      @Override
      public void warn(String msg) {
        slf4jLogger.warn(msg);
      }

      @Override
      public void warn(String format, Object arg) {
        slf4jLogger.warn(format, arg);
      }

      @Override
      public void warn(String format, Object arg1, Object arg2) {
        slf4jLogger.warn(format, arg1, arg2);
      }

      @Override
      public void warn(String format, Object... args) {
        slf4jLogger.warn(format, args);
      }

      @Override
      public void warn(java.util.function.Supplier<String> supplier) {
        if (isWarnEnabled()) {
          slf4jLogger.warn(supplier.get());
        }
      }

      @Override
      public boolean isErrorEnabled() {
        return slf4jLogger.isErrorEnabled();
      }

      @Override
      public void error(String msg, Throwable t) {
        slf4jLogger.error(msg, t);
      }

      @Override
      public void error(String msg) {
        slf4jLogger.error(msg);
      }

      @Override
      public void error(String format, Object arg) {
        slf4jLogger.error(format, arg);
      }

      @Override
      public void error(String format, Object arg1, Object arg2) {
        slf4jLogger.error(format, arg1, arg2);
      }

      @Override
      public void error(String format, Object... args) {
        slf4jLogger.error(format, args);
      }

      @Override
      public void error(java.util.function.Supplier<String> supplier) {
        if (isErrorEnabled()) {
          slf4jLogger.error(supplier.get());
        }
      }
    };
  }
}

//应用加载完成事件
@Componentpublic 
class AppPluginLoadEndEventListener implements EventListener<AppPluginLoadEndEvent> {
    @Overridepublic void onEvent(AppPluginLoadEndEvent e) throws Throwable {
        //定制 json 序列化输出（使用新的处理接管 "@json" 指令）
        e.app().renders().register("@json", (data, ctx) -> {
            String json = JFinalJson.getJson().toJson(data);
            ctx.outputAsJson(json);
        });
    }
}

/**
 * 是否匹配
 *
 * @param ctx 请求上下文
 * @param mime 内容类型
 */
@Override
public boolean matched(Context ctx, String mime) {
  if (mime == null || mime.isEmpty()) {
    return true;
  } else {
    return mime.contains(label) || mime.startsWith(MimeType.APPLICATION_X_NDJSON_VALUE);
  }
}

/**
 * Snack 实体转换器
 *
 * @author noear
 * @since 3.6
 */
public class Snack4EntityConverter extends AbstractStringEntityConverter<Snack4StringSerializer> {
  @Override
  protected Object changeEntityDo(Context ctx, ParamWrap p, String name, Class<?> type)
      throws Exception {
    Props props = new Props().addAll(ctx.paramMap());
    Options options = serializer.getDeserializeConfig().getOptions();
    return ONode.ofBean(props, options).toBean(type);
  }
}

context.getBeanAsync(
    Snack4StringSerializer.class,
    serializer -> {
      serializer.getDeserializeConfig().addFeatures(Feature.Decode_AllowUseSetter);
      serializer.getSerializeConfig().addFeatures(Feature.Write_UseSmlCamelStyle);
      
      serializer.addEncoder(AifeiRow.class, new ModelEncoder<>());
    });

package com.goldsyear.solon.asr.config;

import lombok.Data;
import org.noear.solon.annotation.Configuration;

/**
 * FunASR 配置类
 *
 * @author airhead
 */
@Configuration
@Data
public class FunAsrConfig {

  /**
   * WebSocket 服务地址，例如：ws://localhost:10095/funasr/ws/offline
   */
  private String serverUrl;

  /**
   * 模式：offline（离线模式）
   */
  private String mode = "offline";

  /**
   * 音频文件格式：pcm/mp3/mp4 等
   */
  private String wavFormat = "pcm";

  /**
   * 是否启用文本规范化
   */
  private Boolean itn = true;

  /**
   * 热词配置（JSON 字符串格式），例如：{"关键词":20}
   */
  private String hotwords;

  /**
   * 超时时间（秒）
   */
  private Integer timeout = 300;

  /**
   * PCM 采样率
   */
  private Integer sampleRate = 16000;
}

package com.goldsyear.solon.asr.client;

import com.goldsyear.solon.asr.config.FunAsrConfig;
import com.goldsyear.solon.asr.exception.FunAsrException;
import com.goldsyear.solon.asr.model.FunAsrResult;
import com.goldsyear.solon.common.core.model.KeyValue;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import okio.ByteString;
import org.jspecify.annotations.NonNull;
import org.noear.snack4.ONode;

/**
 * FunASR WebSocket 客户端
 *
 * @author airhead
 */
@Slf4j
public class FunAsrWebSocketClient {

  /**
   * -- GETTER --
   *  获取配置
   *
   * @return FunASR 配置
   */
  @Getter
  private final FunAsrConfig config;
  private final OkHttpClient httpClient;

  /**
   * 创建 FunASR WebSocket 客户端
   *
   * @param config FunASR 配置
   * @throws IllegalArgumentException 如果配置参数无效
   */
  public FunAsrWebSocketClient(FunAsrConfig config) {
    validateConfig(config);
    this.config = config;
    this.httpClient =
        new OkHttpClient.Builder()
            .readTimeout(config.getTimeout(), TimeUnit.SECONDS)
            .writeTimeout(config.getTimeout(), TimeUnit.SECONDS)
            .connectTimeout(config.getTimeout(), TimeUnit.SECONDS)
            .build();
  }

  /**
   * 识别音频文件
   *
   * @param audioFile 音频文件
   * @param wavName 音频文件名（可选）
   * @return 识别结果
   */
  public FunAsrResult recognize(File audioFile, String wavName) {
    return recognize(audioFile, wavName, null);
  }

  /**
   * 识别音频文件
   *
   * @param audioFile 音频文件
   * @param wavName 音频文件名（可选）
   * @param hotWords 热词配置（可选，会覆盖配置中的热词）
   * @return 识别结果
   */
  public FunAsrResult recognize(File audioFile, String wavName, String hotWords) {
    if (audioFile == null || !audioFile.exists()) {
      throw new IllegalArgumentException("Audio file not found: " + audioFile);
    }

    // 读取音频文件
    byte[] audioData;
    try {
      audioData = Files.readAllBytes(audioFile.toPath());
    } catch (IOException e) {
      throw new FunAsrException("Failed to read audio file: " + audioFile, e);
    }

    return recognize(audioData, wavName != null ? wavName : audioFile.getName(), hotWords);
  }

  /**
   * 识别音频数据
   *
   * @param audioData 音频数据（字节数组）
   * @param wavName 音频文件名
   * @return 识别结果
   */
  public FunAsrResult recognize(byte[] audioData, String wavName) {
    return recognize(audioData, wavName, null);
  }

  /**
   * 识别音频数据
   *
   * @param audioData 音频数据（字节数组）
   * @param wavName 音频文件名
   * @param hotwords 热词配置（可选，会覆盖配置中的热词）
   * @return 识别结果
   */
  public FunAsrResult recognize(byte[] audioData, String wavName, String hotwords) {
    if (audioData == null || audioData.length == 0) {
      throw new IllegalArgumentException("Audio data is empty");
    }

    // 构建 WebSocket 请求
    Request request = new Request.Builder().url(config.getServerUrl()).build();

    // 创建用于存储结果的容器
    AtomicReference<FunAsrResult> resultRef = new AtomicReference<>();
    AtomicReference<Throwable> errorRef = new AtomicReference<>();
    CountDownLatch latch = new CountDownLatch(1);

    // 创建 WebSocket 监听器
    WebSocketListener listener =
        new WebSocketListener() {
          @Override
          public void onClosing(WebSocket webSocket, int code, String reason) {
            log.info("WebSocket closing: {} - {}", code, reason);
            webSocket.close(code, reason);
            // 如果已经有结果，立即释放 latch
            // 对于离线模式，结果可能已经在 onMessage 中处理了
            if (resultRef.get() != null) {
              latch.countDown();
            }
          }

          @Override
          public void onFailure(
              @NonNull WebSocket webSocket, @NonNull Throwable t, Response response) {
            // 如果已经有结果且是因为关闭连接导致的错误，忽略这个异常
            if (resultRef.get() != null && t instanceof java.net.SocketException) {
              log.debug("WebSocket closed after result received: {}", t.getMessage());
              return;
            }
            log.error("WebSocket error", t);
            errorRef.set(t);
            latch.countDown();
          }

          @Override
          public void onMessage(@NonNull WebSocket webSocket, @NonNull String text) {
            log.info("Received message: {}", text);

            try {
              // 尝试解析消息
              FunAsrResult result = parseResult(text);
              // 立即缓存结果
              resultRef.set(result);

              // 离线模式：收到任何有效结果就立即返回
              // 在线模式：等待 isFinal=true
              if ("offline".equals(config.getMode())) {
                log.info("Offline mode: received result, closing connection");
                latch.countDown();
                // 主动关闭连接
                webSocket.close(1000, "Result received");
              } else if (Boolean.TRUE.equals(result.getIsFinal())) {
                log.info("Online mode: received final result");
                latch.countDown();
              }
            } catch (Exception e) {
              log.error("Failed to parse result: {}", text, e);
              errorRef.set(e);
              latch.countDown();
            }
          }

          @Override
          public void onOpen(@NonNull WebSocket webSocket, @NonNull Response response) {
            log.debug("WebSocket connected");

            // 发送初始化配置
            try {
              String initJson = buildInitConfig(wavName, hotwords);
              log.debug("Sending init config: {}", initJson);
              webSocket.send(initJson);

              // 分块发送音频数据，每块 16KB
              int chunkSize = 16 * 1024; // 16KB
              int offset = 0;
              while (offset < audioData.length) {
                int length = Math.min(chunkSize, audioData.length - offset);
                byte[] chunk = new byte[length];
                System.arraycopy(audioData, offset, chunk, 0, length);
                webSocket.send(ByteString.of(chunk));
                log.debug(
                    "Sent audio chunk: {} bytes (offset: {}/{})", length, offset, audioData.length);
                offset += length;
                // 添加小延迟，避免发送过快
                try {
                  Thread.sleep(10);
                } catch (InterruptedException e) {
                  Thread.currentThread().interrupt();
                  break;
                }
              }
              log.debug("Sent all audio data: {} bytes total", audioData.length);

              // 发送结束标志
              String endJson = buildEndFlag();
              log.debug("Sending end flag: {}", endJson);
              webSocket.send(endJson);

            } catch (Exception e) {
              log.error("Error during send", e);
              errorRef.set(e);
              latch.countDown();
              webSocket.close(1000, "Error during send");
            }
          }
        };

    // 建立 WebSocket 连接
    WebSocket webSocket = httpClient.newWebSocket(request, listener);

    try {
      // 等待结果或超时
      boolean completed = latch.await(config.getTimeout(), TimeUnit.SECONDS);

      if (!completed) {
        throw new FunAsrException(
            "FunASR recognition timeout after " + config.getTimeout() + " seconds");
      }

      // 检查是否有错误
      Throwable error = errorRef.get();
      if (error != null) {
        throw new FunAsrException("FunASR recognition failed", error);
      }

      // 获取结果
      FunAsrResult result = resultRef.get();
      if (result == null) {
        throw new FunAsrException("No result received from FunASR");
      }

      return result;

    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      throw new FunAsrException("FunASR recognition interrupted", e);
    } finally {
      webSocket.cancel();
    }
  }

  /**
   * 异步识别音频文件
   *
   * @param audioFile 音频文件
   * @param wavName 音频文件名（可选）
   * @return Future 识别结果
   */
  public CompletableFuture<FunAsrResult> recognizeAsync(File audioFile, String wavName) {
    return recognizeAsync(audioFile, wavName, null);
  }

  /**
   * 异步识别音频文件
   *
   * @param audioFile 音频文件
   * @param wavName 音频文件名（可选）
   * @param hotWords 热词配置（可选）
   * @return Future 识别结果
   */
  public CompletableFuture<FunAsrResult> recognizeAsync(
      File audioFile, String wavName, String hotWords) {
    return CompletableFuture.supplyAsync(() -> recognize(audioFile, wavName, hotWords));
  }

  /**
   * 异步识别音频数据
   *
   * @param audioData 音频数据（字节数组）
   * @param wavName 音频文件名
   * @return Future 识别结果
   */
  public CompletableFuture<FunAsrResult> recognizeAsync(byte[] audioData, String wavName) {
    return recognizeAsync(audioData, wavName, null);
  }

  /**
   * 异步识别音频数据
   *
   * @param audioData 音频数据（字节数组）
   * @param wavName 音频文件名
   * @param hotWords 热词配置（可选）
   * @return Future 识别结果
   */
  public CompletableFuture<FunAsrResult> recognizeAsync(
      byte[] audioData, String wavName, String hotWords) {
    return CompletableFuture.supplyAsync(() -> recognize(audioData, wavName, hotWords));
  }

  /** 关闭客户端 */
  public void shutdown() {
    httpClient.dispatcher().executorService().shutdown();
    httpClient.connectionPool().evictAll();
  }

  /**
   * 健康检查 尝试连接到 FunASR 服务器，检查服务是否可用
   *
   * @return true 如果服务可用，false 否则
   */
  public boolean healthCheck() {
    try {
      Request request = new Request.Builder().url(config.getServerUrl()).build();

      // 使用短超时进行连接测试
      OkHttpClient testClient =
          httpClient
              .newBuilder()
              .connectTimeout(5, TimeUnit.SECONDS)
              .readTimeout(5, TimeUnit.SECONDS)
              .build();

      AtomicReference<Boolean> connected = new AtomicReference<>(false);
      CountDownLatch latch = new CountDownLatch(1);

      WebSocketListener listener =
          new WebSocketListener() {
            @Override
            public void onFailure(@NonNull WebSocket webSocket, @NonNull Throwable t, Response response) {
              connected.set(false);
              latch.countDown();
            }

            @Override
            public void onOpen(WebSocket webSocket, @NonNull Response response) {
              connected.set(true);
              latch.countDown();
              webSocket.close(1000, "Health check");
            }
          };

      WebSocket webSocket = testClient.newWebSocket(request, listener);
      boolean completed = latch.await(10, TimeUnit.SECONDS);
      webSocket.cancel();

      return completed && connected.get();

    } catch (Exception e) {
      log.error("FunASR health check failed: {}", e.getMessage());
      return false;
    }
  }

  /**
   * 验证配置参数
   *
   * @param config FunASR 配置
   * @throws IllegalArgumentException 如果配置参数无效
   */
  private void validateConfig(FunAsrConfig config) {
    if (config == null) {
      throw new IllegalArgumentException("FunAsrConfig cannot be null");
    }
    if (config.getServerUrl() == null || config.getServerUrl().trim().isEmpty()) {
      throw new IllegalArgumentException("Server URL cannot be empty");
    }
    if (!config.getServerUrl().startsWith("ws://") && !config.getServerUrl().startsWith("wss://")) {
      throw new IllegalArgumentException("Server URL must start with ws:// or wss://");
    }
    if (config.getTimeout() != null && config.getTimeout() <= 0) {
      throw new IllegalArgumentException("Timeout must be positive");
    }
  }

  /** 构建初始化配置 JSON */
  private String buildInitConfig(String wavName, String hotWords) {
    KeyValue data = KeyValue.of();
    data.set("mode", config.getMode());
    data.set("wav_name", wavName);
    data.set("wav_format", config.getWavFormat());
    data.set("is_speaking", true);
    data.set("itn", config.getItn());

    String hw = hotWords != null ? hotWords : config.getHotwords();
    if (hw != null && !hw.isEmpty()) {
      data.set("hotwords", hw);
    }

    return ONode.serialize(data);
  }

  /** 构建结束标志 JSON */
  private String buildEndFlag() {
    return ONode.serialize(KeyValue.of("is_speaking", false));
  }

  /** 解析识别结果 */
  private FunAsrResult parseResult(String jsonText) {
    KeyValue root = ONode.deserialize(jsonText, KeyValue.class);

    FunAsrResult result = new FunAsrResult();

    // 检查错误响应
    if (root.notNull("error_code")) {
      result.setErrorCode(root.getStr("error_code"));
      result.setErrorMsg(root.getStr("error_msg"));
      return result;
    }

    // 解析成功响应
    result.setMode(root.getStr("mode"));
    result.setWavName(root.getStr("wav_name"));
    result.setText(root.getStr("text"));
    result.setIsFinal(root.getBoolean("is_final"));
    result.setTimestamp(root.getStr("timestamp"));

    // 解析时间戳句子列表
    if (root.notNull("stamp_sents")) {
      result.setStampSents(parseStampSents((List<?>) root.get("stamp_sents")));
    }

    return result;
  }

  /** 解析时间戳句子列表 */
  private List<FunAsrResult.StampSent> parseStampSents(List<?> stampSentsList) {
    if (stampSentsList == null) {
      return null;
    }
    List<FunAsrResult.StampSent> stampSents = new ArrayList<>();
    for (Object item : stampSentsList) {
      if (item instanceof KeyValue) {
        KeyValue sentNode = (KeyValue) item;
        FunAsrResult.StampSent stampSent = new FunAsrResult.StampSent();
        stampSent.setTextSeg(sentNode.getStr("text_seg"));
        stampSent.setPunc(sentNode.getStr("punc"));
        stampSent.setStart(sentNode.getLong("start"));
        stampSent.setEnd(sentNode.getLong("end"));
        stampSent.setTsList(parseTsList(sentNode.getAs("ts_list")));
        stampSents.add(stampSent);
      } else if (item instanceof java.util.Map) {
        // 处理普通 Map
        @SuppressWarnings("unchecked")
        java.util.Map<String, Object> sentNode = (java.util.Map<String, Object>) item;
        FunAsrResult.StampSent stampSent = new FunAsrResult.StampSent();
        stampSent.setTextSeg((String) sentNode.get("text_seg"));
        stampSent.setPunc((String) sentNode.get("punc"));
        stampSent.setStart(toLong(sentNode.get("start")));
        stampSent.setEnd(toLong(sentNode.get("end")));
        stampSent.setTsList(parseTsList((List<?>) sentNode.get("ts_list")));
        stampSents.add(stampSent);
      }
    }
    return stampSents;
  }

  /** 解析时间戳列表 */
  private List<List<Integer>> parseTsList(List<?> tsListRaw) {
    if (tsListRaw == null) {
      return null;
    }
    List<List<Integer>> tsList = new ArrayList<>();
    for (Object item : tsListRaw) {
      if (item instanceof List<?> tsRaw) {
        List<Integer> ts = new ArrayList<>();
        for (Object num : tsRaw) {
          ts.add(toInteger(num));
        }
        tsList.add(ts);
      }
    }
    return tsList;
  }

  /** 安全转换为 Long */
  private Long toLong(Object value) {
    switch (value) {
      case null -> {
        return null;
      }
      case Long l -> {
        return l;
      }
      case Integer i -> {
        return i.longValue();
      }
      case Number number -> {
        return number.longValue();
      }
      case String command -> {
        try {
          return Long.parseLong(command);
        } catch (NumberFormatException e) {
          return null;
        }
      }
      default -> {}
    }
    return null;
  }

  /** 安全转换为 Integer */
  private Integer toInteger(Object value) {
    switch (value) {
      case null -> {
        return null;
      }
      case Integer i -> {
        return i;
      }
      case Long l -> {
        return l.intValue();
      }
      case Number number -> {
        return number.intValue();
      }
      case String command -> {
        try {
          return Integer.parseInt(command);
        } catch (NumberFormatException e) {
          return null;
        }
      }
      default -> {}
    }

    return null;
  }

}

@Test
public void testRecognizeFile() {
  // 创建配置
  FunAsrConfig config = new FunAsrConfig();
  config.setServerUrl("ws://localhost:10095/funasr/ws/offline");
  config.setWavFormat("mp3");
  config.setMode("offline");
  config.setItn(true);
  config.setHotwords("{}");
  config.setTimeout(300);

  // 创建客户端
  FunAsrWebSocketClient client = FunAsrClientFactory.create(config);

  try {
    // 识别音频文件（请替换为实际的音频文件路径）
    File audioFile = new File("1d829d6c-558b-4865-98cc-a3bcecffc485.mp3");
    if (!audioFile.exists()) {
      log.warn("Audio file not found: {}", audioFile.getAbsolutePath());
      return;
    }

    FunAsrResult result = client.recognize(audioFile, "test_audio");

    if (result.isSuccess()) {
      log.info("识别成功:");
      log.info("文本: {}", result.getText());
      log.info("模式: {}", result.getMode());
      log.info("时间戳: {}", result.getTimestamp());
    } else {
      log.error("离线识别失败: {} - {}", result.getErrorCode(), result.getErrorMsg());
    }

  } catch (Exception e) {
    log.error("识别过程出错", e);
  } finally {
    client.shutdown();
  }
}