const std = @import("std");
const root = @import("../build.zig");

const debug = std.debug;
const fmt = std.fmt;
const fs = std.fs;
const mem = std.mem;

const Allocator = std.mem.Allocator;
const Child = std.process.Child;
const Build = std.build;
const FileSource = std.Build.FileSource;
const Reader = fs.File.Reader;
const RunStep = std.Build.RunStep;
const Step = Build.Step;

const Exercise = root.Exercise;

pub fn addCliTests(b: *std.Build, exercises: []const Exercise) *Step {
    const step = b.step("test-cli", "Test the command line interface");

    {
        // Test that `zig build -Dhealed -Dn=n test` selects the nth exercise.
        const case_step = createCase(b, "case-1");

        const tmp_path = makeTempPath(b) catch |err| {
            return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)});
        };

        const heal_step = HealStep.create(b, exercises, tmp_path);

        for (exercises[0 .. exercises.len - 1]) |ex| {
            const n = ex.number();
            if (ex.skip) continue;

            const cmd = b.addSystemCommand(&.{
                b.zig_exe,
                "build",
                "-Dhealed",
                b.fmt("-Dhealed-path={s}", .{tmp_path}),
                b.fmt("-Dn={}", .{n}),
                "test",
            });
            cmd.setName(b.fmt("zig build -Dhealed -Dn={} test", .{n}));
            cmd.expectExitCode(0);
            cmd.step.dependOn(&heal_step.step);

            const output = if (ex.check_stdout)
                cmd.captureStdOut()
            else
                cmd.captureStdErr();

            const verify = CheckNamedStep.create(b, ex, output);
            verify.step.dependOn(&cmd.step);

            case_step.dependOn(&verify.step);
        }

        const cleanup = b.addRemoveDirTree(tmp_path);
        cleanup.step.dependOn(case_step);

        step.dependOn(&cleanup.step);
    }

    {
        // Test that `zig build -Dhealed -Dn=n test` skips disabled esercises.
        const case_step = createCase(b, "case-2");

        const tmp_path = makeTempPath(b) catch |err| {
            return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)});
        };

        const heal_step = HealStep.create(b, exercises, tmp_path);

        for (exercises[0 .. exercises.len - 1]) |ex| {
            const n = ex.number();
            if (!ex.skip) continue;

            const cmd = b.addSystemCommand(&.{
                b.zig_exe,
                "build",
                "-Dhealed",
                b.fmt("-Dhealed-path={s}", .{tmp_path}),
                b.fmt("-Dn={}", .{n}),
                "test",
            });
            cmd.setName(b.fmt("zig build -Dhealed -Dn={} test", .{n}));
            cmd.expectExitCode(0);
            cmd.expectStdOutEqual("");
            expectStdErrMatch(cmd, b.fmt("{s} skipped", .{ex.main_file}));

            cmd.step.dependOn(&heal_step.step);

            case_step.dependOn(&cmd.step);
        }

        const cleanup = b.addRemoveDirTree(tmp_path);
        cleanup.step.dependOn(case_step);

        step.dependOn(&cleanup.step);
    }

    {
        // Test that `zig build -Dhealed` process all the exercises in order.
        const case_step = createCase(b, "case-3");

        const tmp_path = makeTempPath(b) catch |err| {
            return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)});
        };

        const heal_step = HealStep.create(b, exercises, tmp_path);
        heal_step.step.dependOn(case_step);

        // TODO: when an exercise is modified, the cache is not invalidated.
        const cmd = b.addSystemCommand(&.{
            b.zig_exe,
            "build",
            "-Dhealed",
            b.fmt("-Dhealed-path={s}", .{tmp_path}),
        });
        cmd.setName("zig build -Dhealed");
        cmd.expectExitCode(0);
        cmd.step.dependOn(&heal_step.step);

        const stderr = cmd.captureStdErr();
        const verify = CheckStep.create(b, exercises, stderr, true);
        verify.step.dependOn(&cmd.step);

        const cleanup = b.addRemoveDirTree(tmp_path);
        cleanup.step.dependOn(&verify.step);

        step.dependOn(&cleanup.step);
    }

    {
        // Test that `zig build -Dhealed -Dn=1 start` process all the exercises
        // in order.
        const case_step = createCase(b, "case-4");

        const tmp_path = makeTempPath(b) catch |err| {
            return fail(step, "unable to make tmp path: {s}\n", .{@errorName(err)});
        };

        const heal_step = HealStep.create(b, exercises, tmp_path);
        heal_step.step.dependOn(case_step);

        // TODO: when an exercise is modified, the cache is not invalidated.
        const cmd = b.addSystemCommand(&.{
            b.zig_exe,
            "build",
            "-Dhealed",
            b.fmt("-Dhealed-path={s}", .{tmp_path}),
            "-Dn=1",
            "start",
        });
        cmd.setName("zig build -Dhealed -Dn=1 start");
        cmd.expectExitCode(0);
        cmd.step.dependOn(&heal_step.step);

        const stderr = cmd.captureStdErr();
        const verify = CheckStep.create(b, exercises, stderr, false);
        verify.step.dependOn(&cmd.step);

        const cleanup = b.addRemoveDirTree(tmp_path);
        cleanup.step.dependOn(&verify.step);

        step.dependOn(&cleanup.step);
    }

    {
        // Test that `zig build -Dn=1` prints the hint.
        const case_step = createCase(b, "case-5");

        const cmd = b.addSystemCommand(&.{ b.zig_exe, "build", "-Dn=1" });
        cmd.setName("zig build -Dn=1");
        cmd.expectExitCode(1);
        expectStdErrMatch(cmd, exercises[0].hint orelse "");

        cmd.step.dependOn(case_step);

        step.dependOn(&cmd.step);
    }

    return step;
}

fn createCase(b: *Build, name: []const u8) *Step {
    const case_step = b.allocator.create(Step) catch @panic("OOM");
    case_step.* = Step.init(.{
        .id = .custom,
        .name = name,
        .owner = b,
    });

    return case_step;
}

/// Checks the output of `zig build -Dn=n test`.
const CheckNamedStep = struct {
    step: Step,
    exercise: Exercise,
    output: FileSource,

    pub fn create(owner: *Build, exercise: Exercise, output: FileSource) *CheckNamedStep {
        const self = owner.allocator.create(CheckNamedStep) catch @panic("OOM");
        self.* = .{
            .step = Step.init(.{
                .id = .custom,
                .name = "check-named",
                .owner = owner,
                .makeFn = make,
            }),
            .exercise = exercise,
            .output = output,
        };

        return self;
    }

    fn make(step: *Step, _: *std.Progress.Node) !void {
        const b = step.owner;
        const self = @fieldParentPtr(CheckNamedStep, "step", step);

        // Allow up to 1 MB of output capture.
        const max_bytes = 1 * 1024 * 1024;
        const path = self.output.getPath(b);
        const raw_output = try fs.cwd().readFileAlloc(b.allocator, path, max_bytes);

        const actual = try root.trimLines(b.allocator, raw_output);
        const expect = self.exercise.output;
        if (!mem.eql(u8, expect, actual)) {
            return step.fail("{s}: expected to see \"{s}\", found \"{s}\"", .{
                self.exercise.main_file, expect, actual,
            });
        }
    }
};

/// Checks the output of `zig build` or `zig build -Dn=1 start`.
const CheckStep = struct {
    step: Step,
    exercises: []const Exercise,
    stderr: FileSource,
    has_logo: bool,

    pub fn create(
        owner: *Build,
        exercises: []const Exercise,
        stderr: FileSource,
        has_logo: bool,
    ) *CheckStep {
        const self = owner.allocator.create(CheckStep) catch @panic("OOM");
        self.* = .{
            .step = Step.init(.{
                .id = .custom,
                .name = "check",
                .owner = owner,
                .makeFn = make,
            }),
            .exercises = exercises,
            .stderr = stderr,
            .has_logo = has_logo,
        };

        return self;
    }

    fn make(step: *Step, _: *std.Progress.Node) !void {
        const b = step.owner;
        const self = @fieldParentPtr(CheckStep, "step", step);
        const exercises = self.exercises;

        const stderr_file = try fs.cwd().openFile(
            self.stderr.getPath(b),
            .{ .mode = .read_only },
        );
        defer stderr_file.close();

        const stderr = stderr_file.reader();
        for (exercises) |ex| {
            if (ex.number() == 1 and self.has_logo) {
                // Skip the logo.
                var buf: [80]u8 = undefined;

                var lineno: usize = 0;
                while (lineno < 8) : (lineno += 1) {
                    _ = try readLine(stderr, &buf);
                }
            }
            try check_output(step, ex, stderr);
        }
    }

    fn check_output(step: *Step, exercise: Exercise, reader: Reader) !void {
        const b = step.owner;

        var buf: [1024]u8 = undefined;
        if (exercise.skip) {
            {
                const actual = try readLine(reader, &buf) orelse "EOF";
                const expect = b.fmt("Skipping {s}", .{exercise.main_file});
                try check(step, exercise, expect, actual);
            }

            {
                const actual = try readLine(reader, &buf) orelse "EOF";
                try check(step, exercise, "", actual);
            }

            return;
        }

        {
            const actual = try readLine(reader, &buf) orelse "EOF";
            const expect = b.fmt("Compiling {s}...", .{exercise.main_file});
            try check(step, exercise, expect, actual);
        }

        {
            const actual = try readLine(reader, &buf) orelse "EOF";
            const expect = b.fmt("Checking {s}...", .{exercise.main_file});
            try check(step, exercise, expect, actual);
        }

        {
            const actual = try readLine(reader, &buf) orelse "EOF";
            const expect = "PASSED:";
            try check(step, exercise, expect, actual);
        }

        // Skip the exercise output.
        const nlines = 1 + mem.count(u8, exercise.output, "\n") + 1;
        var lineno: usize = 0;
        while (lineno < nlines) : (lineno += 1) {
            _ = try readLine(reader, &buf) orelse @panic("EOF");
        }
    }

    fn check(
        step: *Step,
        exercise: Exercise,
        expect: []const u8,
        actual: []const u8,
    ) !void {
        if (!mem.eql(u8, expect, actual)) {
            return step.fail("{s}: expected to see \"{s}\", found \"{s}\"", .{
                exercise.main_file,
                expect,
                actual,
            });
        }
    }

    fn readLine(reader: fs.File.Reader, buf: []u8) !?[]const u8 {
        if (try reader.readUntilDelimiterOrEof(buf, '\n')) |line| {
            return mem.trimRight(u8, line, " \r\n");
        }

        return null;
    }
};

/// Fails with a custom error message.
const FailStep = struct {
    step: Step,
    error_msg: []const u8,

    pub fn create(owner: *Build, error_msg: []const u8) *FailStep {
        const self = owner.allocator.create(FailStep) catch @panic("OOM");
        self.* = .{
            .step = Step.init(.{
                .id = .custom,
                .name = "fail",
                .owner = owner,
                .makeFn = make,
            }),
            .error_msg = error_msg,
        };

        return self;
    }

    fn make(step: *Step, _: *std.Progress.Node) !void {
        const b = step.owner;
        const self = @fieldParentPtr(FailStep, "step", step);

        try step.result_error_msgs.append(b.allocator, self.error_msg);
        return error.MakeFailed;
    }
};

/// A variant of `std.Build.Step.fail` that does not return an error so that it
/// can be used in the configuration phase.  It returns a FailStep, so that the
/// error will be cleanly handled by the build runner.
fn fail(step: *Step, comptime format: []const u8, args: anytype) *Step {
    const b = step.owner;

    const fail_step = FailStep.create(b, b.fmt(format, args));
    step.dependOn(&fail_step.step);

    return step;
}

/// Heals the exercises.
const HealStep = struct {
    step: Step,
    exercises: []const Exercise,
    work_path: []const u8,

    pub fn create(owner: *Build, exercises: []const Exercise, work_path: []const u8) *HealStep {
        const self = owner.allocator.create(HealStep) catch @panic("OOM");
        self.* = .{
            .step = Step.init(.{
                .id = .custom,
                .name = "heal",
                .owner = owner,
                .makeFn = make,
            }),
            .exercises = exercises,
            .work_path = work_path,
        };

        return self;
    }

    fn make(step: *Step, _: *std.Progress.Node) !void {
        const b = step.owner;
        const self = @fieldParentPtr(HealStep, "step", step);

        return heal(b.allocator, self.exercises, self.work_path);
    }
};

/// Heals all the exercises.
fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8) !void {
    const join = fs.path.join;

    const exercises_path = "exercises";
    const patches_path = "patches/patches";

    for (exercises) |ex| {
        const name = ex.name();

        const file = try join(allocator, &.{ exercises_path, ex.main_file });
        const patch = b: {
            const patch_name = try fmt.allocPrint(allocator, "{s}.patch", .{name});
            break :b try join(allocator, &.{ patches_path, patch_name });
        };
        const output = try join(allocator, &.{ work_path, ex.main_file });

        const argv = &.{ "patch", "-i", patch, "-o", output, "-s", file };

        var child = Child.init(argv, allocator);
        _ = try child.spawnAndWait();
    }
}

/// This function is the same as the one in std.Build.makeTempPath, with the
/// difference that returns an error when the temp path cannot be created.
pub fn makeTempPath(b: *Build) ![]const u8 {
    const rand_int = std.crypto.random.int(u64);
    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ Build.hex64(rand_int);
    const path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch
        @panic("OOM");
    try b.cache_root.handle.makePath(tmp_dir_sub_path);

    return path;
}

//
// Missing functions from std.Build.RunStep
//

/// Adds a check for stderr match. Does not add any other checks.
pub fn expectStdErrMatch(self: *RunStep, bytes: []const u8) void {
    const new_check: RunStep.StdIo.Check = .{
        .expect_stderr_match = self.step.owner.dupe(bytes),
    };
    self.addCheck(new_check);
}

/// Adds a check for stdout match as well as a check for exit code 0, if
/// there is not already an expected termination check.
pub fn expectStdOutMatch(self: *RunStep, bytes: []const u8) void {
    const new_check: RunStep.StdIo.Check = .{
        .expect_stdout_match = self.step.owner.dupe(bytes),
    };
    self.addCheck(new_check);
    if (!self.hasTermCheck()) {
        self.expectExitCode(0);
    }
}