const builtin = @import("builtin");
const curl = @import("curl");
const std = @import("std");
const xdg = @import("xdg");

const Allocator = std.mem.Allocator;
const ChildProcess = std.ChildProcess;
const JsonValue = std.json.Value;
const SemanticVersion = std.SemanticVersion;
const StringHashMap = std.StringHashMap;

const Installation = @This();

pub const Installations = StringHashMap(Installation);

allocator: Allocator,
ver_str: []u8,
version: SemanticVersion,
url: ?[:0]u8,

pub fn deinit(self: *Installation) void {
    self.allocator.free(self.ver_str);
    if (self.url) |url| self.allocator.free(url);

    self.* = undefined;
}

pub fn deinitMap(allocator: Allocator, installations: *Installations) void {
    var it = installations.iterator();
    while (it.next()) |kv| {
        allocator.free(kv.key_ptr.*);
        kv.value_ptr.deinit();
    }

    installations.deinit();

    installations.* = undefined;
}

pub fn getActiveName(allocator: Allocator) !?[]u8 {
    var bin_home = try xdg.openBinHome(allocator);
    defer bin_home.close();

    var buf: [std.fs.MAX_PATH_BYTES]u8 = undefined;
    const linkname = bin_home.readLink("zig", &buf) catch |err| {
        if (err == error.NotLink or err == error.FileNotFound) {
            return null;
        } else {
            return err;
        }
    };

    var linkpath = try bin_home.realpathAlloc(allocator, linkname);
    defer allocator.free(linkpath);

    var zup_dir = try xdg.getDataHome(allocator, "zup");
    defer allocator.free(zup_dir);

    const rel_path = try std.fs.path.relative(allocator, zup_dir, linkpath);
    defer allocator.free(rel_path);

    return try allocator.dupe(u8, std.fs.path.dirname(rel_path).?);
}

pub fn isActive(allocator: Allocator, name: []const u8) !bool {
    const active_name_opt = try getActiveName(allocator);
    if (active_name_opt) |active_name| {
        defer allocator.free(active_name);
        return std.mem.eql(u8, active_name, name);
    }
    return false;
}

pub fn getInstalledList(allocator: Allocator) !Installations {
    var zup_data = try xdg.openDataHome(allocator, "zup");
    defer zup_data.close();

    var installations = Installations.init(allocator);
    errdefer Installation.deinitMap(allocator, &installations);

    var it = zup_data.iterate();
    while (try it.next()) |item| {
        if (item.kind != .Directory) {
            continue;
        }

        var inst_dir = try zup_data.openDir(item.name, .{});
        defer inst_dir.close();

        var zig_exe = inst_dir.realpathAlloc(allocator, "zig") catch |err| {
            if (err == error.FileNotFound) {
                continue;
            }
            return err;
        };
        defer allocator.free(zig_exe);

        const res = try ChildProcess.exec(.{ .allocator = allocator, .argv = &.{ zig_exe, "version" } });
        errdefer allocator.free(res.stdout);
        allocator.free(res.stderr);

        if (res.term != .Exited or res.term.Exited != 0) {
            std.log.warn("Failed to execute '{s} version'", .{zig_exe});
            allocator.free(res.stdout);
            continue;
        }

        const trimmed_ver_str = std.mem.trim(u8, res.stdout, &std.ascii.spaces);
        const version = try SemanticVersion.parse(trimmed_ver_str);
        const name = try allocator.dupe(u8, item.name);

        try installations.putNoClobber(name, Installation{
            .allocator = allocator,
            .ver_str = res.stdout,
            .version = version,
            .url = null,
        });
    }

    return installations;
}

pub fn isInstalled(allocator: Allocator, name: []const u8) !bool {
    var zup_data = try xdg.openDataHome(allocator, "zup");
    defer zup_data.close();

    zup_data.access(name, .{}) catch return false;
    return true;
}

pub fn getAvailableList(allocator: Allocator) !Installations {
    var json_str = try curl.easyDownload(allocator, "https://ziglang.org/download/index.json");
    defer allocator.free(json_str);

    var parser = std.json.Parser.init(allocator, false);
    defer parser.deinit();

    var vt = try parser.parse(json_str);
    defer vt.deinit();

    if (vt.root != .Object) {
        return error.JsonSchema;
    }

    var installations = Installations.init(allocator);
    errdefer Installation.deinitMap(allocator, &installations);

    var it = vt.root.Object.iterator();
    while (it.next()) |kv| {
        if (try parseInstallation(allocator, kv.key_ptr.*, kv.value_ptr.*)) |*installation| {
            errdefer installation.deinit();

            var name = try allocator.dupe(u8, kv.key_ptr.*);
            errdefer allocator.free(name);

            try installations.putNoClobber(name, installation.*);
        }
    }

    return installations;
}

fn parseInstallation(allocator: Allocator, name: []const u8, value: JsonValue) !?Installation {
    if (value != .Object) {
        return error.JsonSchema;
    }
    const map = value.Object;

    const triple = @tagName(builtin.target.cpu.arch) ++ "-" ++ @tagName(builtin.target.os.tag);

    const url_root = map.get(triple) orelse {
        return null;
    };
    if (url_root != .Object) {
        return error.JsonSchema;
    }
    const url_src = url_root.Object.get("tarball") orelse {
        return error.JsonSchema;
    };
    if (url_src != .String) {
        return error.JsonSchema;
    }
    var url = try allocator.dupeZ(u8, url_src.String);
    errdefer allocator.free(url);

    const version_src = if (map.get("version")) |ver| blk: {
        if (ver != .String) {
            return error.JsonSchema;
        } else {
            break :blk ver.String;
        }
    } else blk: {
        break :blk name;
    };
    var ver_str = try allocator.dupe(u8, version_src);
    errdefer allocator.free(ver_str);
    const version = try SemanticVersion.parse(ver_str);

    return Installation{
        .allocator = allocator,
        .ver_str = ver_str,
        .version = version,
        .url = url,
    };
}