jest.mock("../../request", () => ({
  main: jest.fn(),
}));
jest.mock("../utils/config", () => ({
  getConfig: jest.fn(),
}));
jest.mock("./TLSSigAPIv2", () => ({
  Api: jest.fn(),
}));

const request = require("../../request");
const { getConfig } = require("../utils/config");
const TLSSigAPIv2 = require("./TLSSigAPIv2");
const tencentIM = require("./index");

describe("tencent-im", () => {
  beforeEach(() => {
    jest.clearAllMocks();
    jest.spyOn(console, "log").mockImplementation(() => {});
    jest.spyOn(console, "error").mockImplementation(() => {});
    getConfig.mockResolvedValue({
      sdkAppId: 1600000000,
      identifier: "administrator",
      secretKey: "test-secret",
    });
    TLSSigAPIv2.Api.mockImplementation(() => ({
      genSig: jest.fn(() => "test-user-sig"),
    }));
  });

  afterEach(() => {
    jest.restoreAllMocks();
  });

  test("imports a new account", async () => {
    request.main.mockResolvedValue({
      ActionStatus: "OK",
      ErrorCode: 0,
      ErrorInfo: "",
    });

    const result = await tencentIM({
      type: "importAccount",
      account: "WZTEST001",
      corpId: "corp-1",
    });

    expect(result).toEqual({
      success: true,
      message: "腾讯 IM 账号导入成功",
    });
    expect(request.main).toHaveBeenCalledWith(
      expect.stringContaining("/v4/im_open_login_svc/account_import?"),
      { Identifier: "WZTEST001" },
      "POST"
    );
  });

  test("treats repeated successful imports as success", async () => {
    request.main.mockResolvedValue({
      ActionStatus: "OK",
      ErrorCode: 0,
      ErrorInfo: "",
    });

    const first = await tencentIM({
      type: "importAccount",
      account: "WZTEST001",
      corpId: "corp-1",
    });
    const second = await tencentIM({
      type: "importAccount",
      account: "WZTEST001",
      corpId: "corp-1",
    });

    expect(first.success).toBe(true);
    expect(second.success).toBe(true);
    expect(request.main).toHaveBeenCalledTimes(2);
  });

  test("preserves Tencent error details when an import returns HTTP 200 with FAIL", async () => {
    request.main.mockResolvedValue({
      ActionStatus: "FAIL",
      ErrorCode: 70001,
      ErrorInfo: "import failed",
    });

    const result = await tencentIM({
      type: "importAccount",
      account: "WZTEST002",
      corpId: "corp-1",
    });

    expect(result).toMatchObject({
      success: false,
      message: "腾讯 IM 账号导入失败",
      errorCode: 70001,
      errorInfo: "import failed",
    });
  });

  test("does not report sendmsg ErrorCode 20003 as success", async () => {
    request.main.mockResolvedValue({
      ActionStatus: "FAIL",
      ErrorCode: 20003,
      ErrorInfo: "Invalid sender or receiver identifier!",
    });

    const result = await tencentIM({
      type: "sendSystemNotification",
      formAccount: "WZTEST003",
      toAccount: "000001",
      SyncOtherMachine: 2,
      corpId: "corp-1",
      msgBody: [],
    });

    expect(result).toMatchObject({
      success: false,
      errorCode: 20003,
      errorInfo: "Invalid sender or receiver identifier!",
    });
  });

  test("returns a diagnostic error when IM configuration is incomplete", async () => {
    getConfig.mockResolvedValue({});

    const result = await tencentIM({
      type: "importAccount",
      account: "WZTEST004",
      corpId: "corp-1",
    });

    expect(result).toMatchObject({
      success: false,
      message: "未找到完整的企业 IM 配置",
    });
    expect(request.main).not.toHaveBeenCalled();
  });

  test("returns a diagnostic error when UserSig generation fails", async () => {
    TLSSigAPIv2.Api.mockImplementation(() => ({
      genSig: jest.fn(() => {
        throw new Error("signature failure");
      }),
    }));

    const result = await tencentIM({
      type: "importAccount",
      account: "WZTEST005",
      corpId: "corp-1",
    });

    expect(result).toMatchObject({
      success: false,
      message: "生成 UserSig 失败",
      error: "signature failure",
    });
    expect(request.main).not.toHaveBeenCalled();
  });

  test("returns a diagnostic error on network failure", async () => {
    request.main.mockRejectedValue(new Error("network unavailable"));

    const result = await tencentIM({
      type: "importAccount",
      account: "WZTEST006",
      corpId: "corp-1",
    });

    expect(result).toMatchObject({
      success: false,
      message: "腾讯 IM 账号导入失败",
      error: "network unavailable",
    });
  });
});