import fs from "fs";

import type { ExecOptions } from "@actions/exec/lib/interfaces";
import * as toolrunner from "@actions/exec/lib/toolrunner";
import * as io from "@actions/io";
import test from "ava";
import * as sinon from "sinon";

import {
  BundlePlatform,
  getBundlePlatform,
  darwinVersion,
  XCODE_SELECT_LINK_PATH,
  xcodeVersionFromLink,
  xcodeSdkVersion,
  xcodeVersionFromXcodeBuild,
} from "./platform";
import {
  checkExpectedLogMessages,
  initAllState,
  RecordingLogger,
  setupTests,
} from "./testing-utils";

setupTests(test);

for (const [platform, arch, expected] of [
  ["linux", "x64", BundlePlatform.Linux64],
  ["linux", "arm64", BundlePlatform.LinuxArm64],
  ["linux", "ia32", BundlePlatform.Linux64],
  ["darwin", "x64", BundlePlatform.Osx64],
  ["darwin", "arm64", BundlePlatform.Osx64],
  ["win32", "x64", BundlePlatform.Win64],
  ["win32", "arm64", BundlePlatform.Win64],
  ["freebsd", "x64", undefined],
] as const) {
  test(`getBundlePlatform maps ${platform}/${arch} to ${expected ?? "an all-platform bundle"}`, (t) => {
    t.is(getBundlePlatform(platform, arch), expected);
  });
}

const platforms: NodeJS.Platform[] = ["linux", "win32", "freebsd"];
for (const platform of platforms) {
  test(`darwinVersion returns undefined on ${platform}`, (t) => {
    t.is(darwinVersion(initAllState({ platform })), undefined);
  });
}

test("darwinVersion returns raw string if semver parsing fails", (t) => {
  const invalidSemVer = "sealOS-2026";
  t.is(
    darwinVersion(
      initAllState({ platform: "darwin", osRelease: invalidSemVer }),
    ),
    invalidSemVer,
  );
});

test("darwinVersion returns semver if parsing succeeds", (t) => {
  const validSemVer = "27.0.1";

  const version = darwinVersion(
    initAllState({ platform: "darwin", osRelease: validSemVer }),
  );

  // Check that `version` is not undefined and narrow the type; throws if undefined.
  if (t.truthy(version)) {
    // Check that it's also not just a string.
    t.not(typeof version, "string");

    // Should be an object with the expected properties.
    t.is(typeof version, "object");
    t.is(version["major"], 27);
    t.is(version["minor"], 0);
    t.is(version["patch"], 1);
  }
});

test.serial(
  "xcodeVersionFromLink returns undefined if symlink doesn't exist",
  (t) => {
    const logger = new RecordingLogger();

    const readlinkSync = sinon
      .stub(fs, "readlinkSync")
      .throws(new Error("ENOENT: no such file or directory"));

    t.is(xcodeVersionFromLink(logger), undefined);
    t.is(readlinkSync.callCount, 1);
    t.deepEqual(readlinkSync.args[0], [XCODE_SELECT_LINK_PATH]);

    checkExpectedLogMessages(t, logger.messages, [
      "Unable to determine Xcode version: ENOENT: no such file or directory",
    ]);
  },
);

test.serial(
  "xcodeVersionFromLink returns undefined if file is not a symlink",
  (t) => {
    const logger = new RecordingLogger();

    const readlinkSync = sinon
      .stub(fs, "readlinkSync")
      .throws(new Error("EINVAL: invalid argument"));

    t.is(xcodeVersionFromLink(logger), undefined);
    t.is(readlinkSync.callCount, 1);
    t.deepEqual(readlinkSync.args[0], [XCODE_SELECT_LINK_PATH]);

    checkExpectedLogMessages(t, logger.messages, [
      "Unable to determine Xcode version: EINVAL: invalid argument",
    ]);
  },
);

test.serial(
  "xcodeVersionFromLink returns undefined if resolving the symlink returns nothing",
  (t) => {
    const logger = new RecordingLogger();

    const readlinkSync = sinon.stub(fs, "readlinkSync").returns("");

    t.is(xcodeVersionFromLink(logger), undefined);
    t.is(readlinkSync.callCount, 1);
    t.deepEqual(readlinkSync.args[0], [XCODE_SELECT_LINK_PATH]);

    checkExpectedLogMessages(t, logger.messages, [
      "unexpectedly returned nothing",
    ]);
  },
);

test.serial(
  "xcodeVersionFromLink returns undefined if resolved path doesn't include pattern",
  (t) => {
    const logger = new RecordingLogger();

    const readlinkSync = sinon
      .stub(fs, "readlinkSync")
      .returns("/Applications/Xcode.app/Contents/Developer");

    t.is(xcodeVersionFromLink(logger), undefined);
    t.is(readlinkSync.callCount, 1);
    t.deepEqual(readlinkSync.args[0], [XCODE_SELECT_LINK_PATH]);

    checkExpectedLogMessages(t, logger.messages, [
      "does not contain expected pattern",
    ]);
  },
);

test.serial(
  "xcodeVersionFromLink returns undefined if match can't be parsed",
  (t) => {
    const logger = new RecordingLogger();

    const readlinkSync = sinon
      .stub(fs, "readlinkSync")
      .returns("/Applications/Xcode_00.0.app/Contents/Developer");

    t.is(xcodeVersionFromLink(logger), undefined);
    t.is(readlinkSync.callCount, 1);
    t.deepEqual(readlinkSync.args[0], [XCODE_SELECT_LINK_PATH]);

    checkExpectedLogMessages(t, logger.messages, [
      "Couldn't parse '00.0' as a semantic version.",
    ]);
  },
);

test.serial("xcodeVersionFromLink returns version from resolved path", (t) => {
  const logger = new RecordingLogger();

  const readlinkSync = sinon
    .stub(fs, "readlinkSync")
    .returns("/Applications/Xcode_16.4.app/Contents/Developer");

  const result = xcodeVersionFromLink(logger);

  if (t.truthy(result)) {
    t.is(result.major, 16);
    t.is(result.minor, 4);
  }

  t.is(readlinkSync.callCount, 1);
  t.deepEqual(readlinkSync.args[0], [XCODE_SELECT_LINK_PATH]);
});

test.serial(
  "xcodeVersionFromLink returns major version from resolved path",
  (t) => {
    const logger = new RecordingLogger();

    const readlinkSync = sinon
      .stub(fs, "readlinkSync")
      .returns("/Applications/Xcode_16.app/Contents/Developer");

    const result = xcodeVersionFromLink(logger);

    if (t.truthy(result)) {
      t.is(result.major, 16);
      t.is(result.minor, 0);
    }

    t.is(readlinkSync.callCount, 1);
    t.deepEqual(readlinkSync.args[0], [XCODE_SELECT_LINK_PATH]);
  },
);

test.serial(
  "xcodeVersionFromLink allows more version components in resolved path",
  (t) => {
    const logger = new RecordingLogger();

    const readlinkSync = sinon
      .stub(fs, "readlinkSync")
      .returns("/Applications/Xcode_16.5.9.app/Contents/Developer");

    const result = xcodeVersionFromLink(logger);

    if (t.truthy(result)) {
      t.is(result.major, 16);
      t.is(result.minor, 5);
    }

    t.is(readlinkSync.callCount, 1);
    t.deepEqual(readlinkSync.args[0], [XCODE_SELECT_LINK_PATH]);
  },
);

test.serial(
  "xcodeVersionFromXcodeBuild returns undefined for non-zero exit code",
  async (t) => {
    const logger = new RecordingLogger();

    const which = sinon.stub(io, "which").resolves("/path/to/xcrun");
    const exec = sinon.stub<[], Promise<number>>().resolves(1);
    const runner = sinon.createStubInstance(toolrunner.ToolRunner, { exec });
    const toolrunnerStub = sinon.stub(toolrunner, "ToolRunner").returns(runner);

    await t.notThrowsAsync(async () => {
      const result = await xcodeVersionFromXcodeBuild(logger);

      t.is(result, undefined);

      t.is(which.callCount, 1);
      t.deepEqual(which.args[0], ["xcrun", true]);

      t.is(toolrunnerStub.callCount, 1);
      t.is(exec.callCount, 1);

      checkExpectedLogMessages(t, logger.messages, [
        "xcodebuild returned exit code 1",
      ]);
    });
  },
);

test.serial(
  "xcodeVersionFromXcodeBuild extracts version from xcrun stdout",
  async (t) => {
    const logger = new RecordingLogger();

    const which = sinon.stub(io, "which").resolves("/path/to/xcrun");

    let stdoutListener: ((data: Buffer) => void) | undefined = undefined;
    const exec = sinon.stub<[], Promise<number>>().callsFake(async () => {
      if (stdoutListener !== undefined) {
        stdoutListener(Buffer.from("Xcode 26.5"));
        stdoutListener(Buffer.from("Build version 26F9"));
      }
      return 0;
    });
    const runner = sinon.createStubInstance(toolrunner.ToolRunner, { exec });

    const toolrunnerStub = sinon
      .stub(toolrunner, "ToolRunner")
      .callsFake((_cmd, _args, opts: ExecOptions) => {
        stdoutListener = opts.listeners?.stdout;
        return runner;
      });

    await t.notThrowsAsync(async () => {
      const result = await xcodeVersionFromXcodeBuild(logger);

      t.not(result, undefined);
      t.is(result?.major, 26);
      t.is(result?.minor, 5);

      t.is(which.callCount, 1);
      t.deepEqual(which.args[0], ["xcrun", true]);

      t.is(toolrunnerStub.callCount, 1);
      t.is(exec.callCount, 1);
    });
  },
);

test.serial(
  "xcodeSdkVersion returns undefined for non-zero exit code",
  async (t) => {
    const logger = new RecordingLogger();

    const which = sinon.stub(io, "which").resolves("/path/to/xcrun");
    const exec = sinon.stub<[], Promise<number>>().resolves(1);
    const runner = sinon.createStubInstance(toolrunner.ToolRunner, { exec });
    const toolrunnerStub = sinon.stub(toolrunner, "ToolRunner").returns(runner);

    await t.notThrowsAsync(async () => {
      const result = await xcodeSdkVersion(logger);

      t.is(result, undefined);

      t.is(which.callCount, 1);
      t.deepEqual(which.args[0], ["xcrun", true]);

      t.is(toolrunnerStub.callCount, 1);
      t.is(exec.callCount, 1);

      checkExpectedLogMessages(t, logger.messages, [
        "xcrun returned exit code 1",
      ]);
    });
  },
);

test.serial("xcodeSdkVersion extracts version from xcrun stdout", async (t) => {
  const logger = new RecordingLogger();

  const which = sinon.stub(io, "which").resolves("/path/to/xcrun");

  let stdoutListener: ((data: Buffer) => void) | undefined = undefined;
  const exec = sinon.stub<[], Promise<number>>().callsFake(async () => {
    if (stdoutListener !== undefined) {
      stdoutListener(Buffer.from("26.5"));
    }
    return 0;
  });
  const runner = sinon.createStubInstance(toolrunner.ToolRunner, { exec });

  const toolrunnerStub = sinon
    .stub(toolrunner, "ToolRunner")
    .callsFake((_cmd, _args, opts: ExecOptions) => {
      stdoutListener = opts.listeners?.stdout;
      return runner;
    });

  await t.notThrowsAsync(async () => {
    const result = await xcodeSdkVersion(logger);

    t.not(result, undefined);
    t.is(result?.major, 26);
    t.is(result?.minor, 5);

    t.is(which.callCount, 1);
    t.deepEqual(which.args[0], ["xcrun", true]);

    t.is(toolrunnerStub.callCount, 1);
    t.is(exec.callCount, 1);
  });
});