#Nextjs SSG 模式实现本地全文搜索

export interface SearchIndexItem {
     id: string;
     title: string;
     content: string;
     routePath: string;
     ...<其他拓展字段>
 }

const cache = new OfflineSearchCache({ name: "search-cache" });

export async function getDateByWasm() {
  let jsonData = [];
  // @ts-ignore
  let wasmBuffer: ArrayBuffer | null = null;

  await cache.init();
  const wasmCache = await cache.get("wasm_v1");

  if (!wasmCache) {
    const response = await fetch(
      `${process.env.BASE_PATH_URL}/source_transfor.wasm`,
    );

    wasmBuffer = await response.arrayBuffer();
    await cache.transaction({ id: "wasm_v1", data: wasmBuffer });
  } else {
    wasmBuffer = wasmCache.data;
  }
  const { instance } = await WebAssembly.instantiate(wasmBuffer!);
  const wasmModule: any = instance.exports;

  function arrayToPtr(array: any[]) {
    const ptr = wasmModule.alloc_memory(array.length);

    if (ptr === 0) {
      throw new Error("Memory allocation failed");
    }
    new Uint8Array(wasmModule.memory.buffer).set(array, ptr);

    return { ptr, len: array.length };
  }

  try {
    let arrayBuffer = null;
    // @ts-ignore
    const indexCache = await cache.get(`ahri_${SEARCH_INDEX_HASH}`);

    if (!indexCache) {
      const response = await fetch(
        // @ts-ignore
        `${location.origin}${process.env.BASE_PATH_URL}/search/search.${SEARCH_INDEX_HASH}.ahri`,
      );

      arrayBuffer = await response.arrayBuffer();
      await cache.transaction({
        // @ts-ignore
        id: `ahri_${SEARCH_INDEX_HASH}`,
        data: arrayBuffer,
      });
    } else {
      arrayBuffer = indexCache.data;
    }

    const encrypted = new Uint8Array(arrayBuffer);

    // 分配内存并复制加密数据
    const encryptedData = arrayToPtr(encrypted as any);
    const outLenPtr = wasmModule.alloc_memory(4);

    const decryptedPtr = wasmModule.decrypt(
      encryptedData.ptr,
      encrypted.length,
      outLenPtr,
    );

    const decryptedLen = new Uint32Array(
      wasmModule.memory.buffer,
      outLenPtr,
      1,
    )[0];

    if (decryptedPtr === 0 || decryptedLen === 0) {
      throw new Error("Decryption failed");
    }

    // 从内存中获取解密后的数据
    const decryptedData = new Uint8Array(
      wasmModule.memory.buffer,
      decryptedPtr,
      decryptedLen,
    );

    // 转换为字符串
    const decoder = new TextDecoder();
    const decrypted = decoder.decode(decryptedData);

    // 尝试解析 JSON
    try {
      jsonData = JSON.parse(decrypted);
    } catch (e) {
      console.error(e);
    }

    // 清理内存
    wasmModule.free_memory(encryptedData.ptr, encryptedData.len);
    wasmModule.free_memory(decryptedPtr, decryptedLen);
    wasmModule.free_memory(outLenPtr, 4);
  } catch (error: any) {
    console.error("Decryption error:", error);
  }

  return jsonData;
}

const cache = await getDateByWasm()
 const { index } = await createFlexDocument(undfined, cache);

// search-worker.ts
import { PageSearcher } from "@/components/Search/logic/search";
let searcher: PageSearcher | null = null;

async function init() {
  searcher = new PageSearcher({} as any);
  console.time("searcherInit"); // 计算索引初始化时间
  await searcher.init();
  console.timeEnd("searcherInit");

  return {
    name: "init",
    data: true,
  };
}

async function match(query: string) {
  const matched = await searcher?.match(query);

  return {
    name: "match",
    query,
    matched,
  };
}

addEventListener("message", async (event: MessageEvent<any>) => {
  if (event.data.name === "init") {
    postMessage(await init());
  }
  if (event.data.name === "match") {
    postMessage(await match(event.data.query));
  }
});

// SearchComponment.tsx
// 示例代码，非真实业务逻辑
function SearchComponment() {
  const [query, setQuery] = useState(""); // 搜索参数
  const workerRef = useRef<Worker | null>(null); //worker实例
  const [searchResult, setSearchResult] = useState<MatchResult>([]); // 搜索结果列表
  const [initing, setIniting] = useState(true); // 是否初始化
  const [isSearching, setIsSearching] = useState(false);

  async function search(query: string) {
    let newQuery = value;
    setQuery(newQuery);
    if (newQuery) {
      workerRef.current?.postMessage({
        name: "match",
        query: newQuery,
      });
    }
  }
  async function initPageSearcher() {
    workerRef.current = new Worker(
      new URL("../../utils/search/search.worker.ts", import.meta.url)
    );
    workerRef.current.postMessage({
      name: "init",
    });

    workerRef.current.onmessage = (e) => {
      if (e.data.name === "init") {
        setIniting(false);
        const NQuery = searchInputRef.current?.value;

        if (NQuery) {
          workerRef.current?.postMessage({
            name: "match",
            query: NQuery,
          });
        }
      }
      if (e.data.name === "match") {
        const NQuery = searchInputRef.current?.value;

        if (e.data.query === NQuery) {
          setSearchResult(e.data.matched);
          setIsSearching(false);
        }
      }
    };
  }

  useEffect(() => {
    initPageSearcher();
    return () => {
      workerRef.current?.terminate();
    };
  }, []);

  return (
    <div>xxxxxx</div> 
  );
}