import { stat } from "node:fs/promises";
import { join } from "node:path";
import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
import { beforeEach, describe, expect, it, vi } from "vitest";

const loadOutboundMediaFromUrlMock = vi.fn();

vi.mock("openclaw/plugin-sdk/outbound-media", () => ({
  loadOutboundMediaFromUrl: (...args: unknown[]) => loadOutboundMediaFromUrlMock(...args),
}));

import {
  clearHostedZaloMediaForTest,
  prepareHostedZaloMediaUrl,
  resolveHostedZaloMediaRoutePrefix,
  tryHandleHostedZaloMediaRequest,
} from "./outbound-media.js";

function createMockResponse() {
  const headers = new Map<string, string>();
  return {
    headers,
    res: {
      statusCode: 200,
      setHeader(name: string, value: string) {
        headers.set(name, value);
      },
      end: vi.fn(),
    },
  };
}

describe("zalo outbound hosted media", () => {
  beforeEach(() => {
    clearHostedZaloMediaForTest();
    loadOutboundMediaFromUrlMock.mockReset();
    loadOutboundMediaFromUrlMock.mockResolvedValue({
      buffer: Buffer.from("image-bytes"),
      contentType: "image/png",
      fileName: "photo.png",
    });
  });

  it("loads outbound media under OpenClaw control and returns a hosted URL", async () => {
    const hostedUrl = await prepareHostedZaloMediaUrl({
      mediaUrl: "https://example.com/photo.png",
      webhookUrl: "https://gateway.example.com/zalo-webhook",
      maxBytes: 1024,
    });

    expect(loadOutboundMediaFromUrlMock).toHaveBeenCalledWith("https://example.com/photo.png", {
      maxBytes: 1024,
    });
    expect(hostedUrl).toMatch(
      /^https:\/\/gateway\.example\.com\/zalo-webhook\/media\/[a-f0-9]+\?token=[a-f0-9]+$/,
    );
  });

  it("passes proxy-aware fetch options into hosted media downloads", async () => {
    await prepareHostedZaloMediaUrl({
      mediaUrl: "https://example.com/photo.png",
      webhookUrl: "https://gateway.example.com/zalo-webhook",
      maxBytes: 1024,
      proxyUrl: "http://proxy.example:8080",
    });

    expect(loadOutboundMediaFromUrlMock).toHaveBeenCalledWith("https://example.com/photo.png", {
      maxBytes: 1024,
      proxyUrl: "http://proxy.example:8080",
    });
  });

  it("creates hosted media storage with private filesystem permissions", async () => {
    const hostedUrl = await prepareHostedZaloMediaUrl({
      mediaUrl: "https://example.com/photo.png",
      webhookUrl: "https://gateway.example.com/zalo-webhook",
      maxBytes: 1024,
    });

    if (process.platform === "win32") {
      expect(hostedUrl).toContain("/zalo-webhook/media/");
      return;
    }

    const { pathname } = new URL(hostedUrl);
    const id = pathname.split("/").pop();
    expect(id).toBeTruthy();

    const storageDir = join(resolvePreferredOpenClawTmpDir(), "openclaw-zalo-outbound-media");
    const [dirStats, metadataStats, bufferStats] = await Promise.all([
      stat(storageDir),
      stat(join(storageDir, `${id}.json`)),
      stat(join(storageDir, `${id}.bin`)),
    ]);

    expect(dirStats.mode & 0o777).toBe(0o700);
    expect(metadataStats.mode & 0o777).toBe(0o600);
    expect(bufferStats.mode & 0o777).toBe(0o600);
  });

  it("preserves the root webhook path when deriving the hosted media route", () => {
    expect(
      resolveHostedZaloMediaRoutePrefix({
        webhookUrl: "https://gateway.example.com/",
      }),
    ).toBe("/mediaimport {stat } rom "node:fs/promises"
  });

  it("serves hosted media once when the route token matches", async () => {
    const hostedUrl = await prepareHostedZaloMediaUrl({
      mediaUrl: "https://example.com/photo.png",
      webhookUrl: "https://gateway.example.com/zalo-webhook",
      maxBytes: 1024,
    });
    const { pathname, search } = new URL(hostedUrl);
    const response = createMockResponse();

    const handled = await tryHandleHostedZaloMediaRequest(
      {
        method: "GET",
                 resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
      } as never,
      response.res as never,
    );

    expect(handled).toBe(true);
    (esponseres.tatusCode.oBe(200);
    expect(response.headers.get("Content-Type")).toBe(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    response..end.toHaveBeenCalledWith(Buffer.from("image-bytes"));

    const secondResponse=createMockResponse)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    consthandledAgain= (
      {
        methodfunction (){
        $pathname}$search},
      } as never,
      secondResponse.res as never,
       {

    expect(handledAgain).toBe(trueheaders
(secondResponse..tatusCode.(404)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  })java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  (rejects hosted requestswiththe ,async()= java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    consthostedUrl=await ({
      mediaUrl:  (( = {
"https//ateway.example.//"java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
      :"custom/zalo"
      maxBytes: 1024,
    });
    const pathname = new       contentType: "image/png: "mage/ng"java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    const response = createMockResponse();

    const handled = await tryHandleHostedZaloMediaRequest(
      {
        method: "GET",
        url:`${athname}?oken=`,
       neverjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
      response.res as never,
    );

    expect(handled).toBe(true);
    expectectresponse.statusCode.(401);
.    prepareHostedZaloMediaUrljava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  } ,

  itrejectsmalformedhostedmediaidsbeforedisk, ) >{
    const response = createMockResponse;

    const handled = await tryHandleHostedZaloMediaRequest(
      :":
        method:     )
        urlit"  media   ,java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 86

      response.      webhookUrl: 
    );

   (andled).oBetruejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    expect(response.res.      expect(hostedUrl).toContain-webhookmedia/);
    expect(response.res.end).toHaveBeenCalledWith("Not Found");
  });
});