gitwit.pluto

local crypto = require "pluto:crypto"
local http = require "pluto:http"
local socket = require "pluto:socket"
local url = require "pluto:url"

local gitwit = {}

-- returns a table like: { ["HEAD"] = "<sha1 hash>", ["refs/heads/senpai"] = "<sha1 hash>", ["refs/tags/0.1.0"] = "<sha1 hash>" }
function gitwit.fetchrefs(url_base)
    return gitwit.parserefs(gitwit.downloadrefs(url_base))
end

function gitwit.downloadrefs(url_base)
    return http.request(url_base.."/info/refs?service=git-upload-pack")
end

function gitwit.parserefs(data)
    local i = 1
    local unpacked = ""
    while i < #data do
        local chunk_size = tonumber(data:sub(i, i + 3), 16)
        if chunk_size < 4 then
            chunk_size = 4
        end
        unpacked ..= data:sub(i + 4, i + chunk_size - 1)
        i += chunk_size
    end
    local refs = {}
    for unpacked:split("\n") as line do
        if #line ~= 0 and line[1] ~= "#" then
            local [hash, ref] = line:split("\0")[1]:split(" ")
            refs[ref] = hash
        end
    end
    return refs
end

function gitwit.fetchpackfile(url_base, commit_hash, base_objects: ?table)
    return gitwit.parsepackfile(gitwit.downloadpackfile(url_base, commit_hash, base_objects), base_objects)
end

local function downloadpackfileaux(url_base, body)
    local { host, path } = url.parse(url_base.."/git-upload-pack")
    local s = socket.connect(host, 443)
    assert(s, "failed to connect to "..host)
    assert(s:starttls(host), "failed to establish a secure tunnel to "..host)
    s:send("POST "..path.." HTTP/1.0\r\n"
        .. "Host: "..host.."\r\n"
        .. "User-Agent: PlutoLang/gitwit\r\n"
        .. "Git-Protocol: version=2\r\n"
        .. "Content-Type: application/x-git-upload-pack-request\r\n"
        .. "Content-Length: "..#body.."\r\n"
        .. "\r\n"
        .. body
        )
    -- Now we gotta parse this shit: https://git-scm.com/docs/gitprotocol-v2
    -- I don't wanna handle a pkt-line possibly being sent over multiple TLS records, so we're buffering it first.
    local data = ""
    while chunk := s:recv() do
        data ..= chunk
    end
    data = data:sub(data:find("\r\n\r\n") + 4)
    local i = 1
    local packfile = ""
    while true do
        local chunk_size = tonumber(data:sub(i, i + 3), 16)
        --print(chunk_size)
        --if data:sub(i + 4, i + 4) == "\2" then
            --print(data:sub(i + 5, i + chunk_size - 1))
        --end
        if data:sub(i + 4, i + 4) == "\1" then
            packfile ..= data:sub(i + 5, i + chunk_size - 1)
        end
        if chunk_size == 0 then
            break
        end
        i += chunk_size
    end
    return packfile
end

function gitwit.downloadpackfile(url_base, commit_hash, base_objects: ?table)
    if commit_hash == nil then
        commit_hash = gitwit.fetchrefs(url_base).HEAD
    end
    assert(#commit_hash == 40)
    -- This is based on what my client sent with 'git clone --no-checkout --depth=1'. I think the duplicated request is a quirk of protocol version 2.
    local request = "0032want "..commit_hash.."\n"
    if base_objects then
        local have = {}
        for base_objects as object do
            if object.type == "commit" then
                have:insert(object.hash)
            end
        end
        for have as hash do
            request ..= "0032have "..hash.."\n"
        end
        for have as hash do
            request ..= "0035shallow "..hash.."\n"
        end
    end
    local body = "0011command=fetch001eagent=git/2.40.0.windows.10016object-format=sha10001000dthin-pack000finclude-tag000dofs-delta000cdeepen 1"..request..request
            .. "0009done\n"
            .. "0000"
    return downloadpackfileaux(url_base, body)
end

function gitwit.downloadfullpackfile(url_base, commit_hash)
    if commit_hash == nil then
        commit_hash = gitwit.fetchrefs(url_base).HEAD
    end
    assert(#commit_hash == 40)
    local body = "0011command=fetch001eagent=git/2.40.0.windows.10016object-format=sha10001000dthin-pack000finclude-tag000dofs-delta0032want "..commit_hash.."\n"
            .. "0032want "..commit_hash.."\n"
            .. "0009done\n"
            .. "0000"
    return downloadpackfileaux(url_base, body)
end

-- https://git-scm.com/docs/gitformat-pack
-- https://github.com/robisonsantos/packfile_reader
local typenames <const> = { "commit", "tree", "blob", "tag" }
function gitwit.parsepackfile(packfile, base_objects)
    local objects = {}
    local i = packfile:find("PACK") -- Try to locate "PACK", which may be slightly offset in the case of a bundle file: https://git-scm.com/docs/gitformat-bundle
    assert(i, "Invalid packfile")
    i += 4
    local format, num_objects
    format, i = string.unpack(">I4", packfile, i)
    assert(format == 2, "Invalid packfile")
    num_objects, i = string.unpack(">I4", packfile, i)
    for _obj = 1, num_objects do
        local obj_offset = i
        local byte = packfile:byte(i)
        i += 1
        local type = (byte >> 4) & 0b111
        assert(type ~= 0)

        local length = byte & 0b1111
        local has_more = (byte >> 7) ~= 0
        local shift = 4
        while has_more do
            byte = packfile:byte(i)
            i += 1
            length |= (byte & 0b1111111) << shift
            shift += 7
            has_more = (byte >> 7) ~= 0
        end

        local base
        if type == 6 then
            -- OBJ_OFS_DELTA, has an offset before the compressed data
            -- https://github.com/git/git/blob/26e47e261e969491ad4e3b6c298450c061749c9e/builtin/pack-objects.c#L1443-L1473
            byte = packfile:byte(i)
            i += 1
            local offset = (byte & 0b1111111)
            has_more = (byte >> 7) ~= 0
            while has_more do
                byte = packfile:byte(i)
                i += 1
                offset += 1
                offset = (offset << 7) + (byte & 0b1111111)
                has_more = (byte >> 7) ~= 0
            end
            offset = (obj_offset - offset)
            base = objects:find(|x| -> x.offset == offset)
        elseif type == 7 then
            -- OBJ_REF_DELTA, has an object hash before the compressed data
            if base_objects then
                local base_hash = packfile:sub(i, i + 19):split(""):map(|x| -> string.format("%02x", x:byte())):concat("")
                base = base_objects:find(|x| -> x.hash == base_hash)
            end
            i += 20
        end

        local decompressed, info = crypto.decompress(packfile:sub(i), length)

        if type == 6 or type == 7 then
            type = base.typeid
            local data = {}
            local j = 1

            -- skip size of base object
            while (decompressed:byte(j) >> 7) ~= 0 do
                j += 1
            end
            j += 1

            -- skip size of undeltified object
            while (decompressed:byte(j) >> 7) ~= 0 do
                j += 1
            end
            j += 1

            while j < #decompressed do
                local insn = decompressed:byte(j)
                j += 1
                if (insn >> 7) == 0 then
                    -- Add new data
                    data:insert(decompressed:sub(j, j + insn - 1))
                    j += insn
                else
                    -- Copy from base object
                    local cp_offset = 0
                    local cp_size = 0
                    if (insn & 1) ~= 0 then
                        cp_offset |= decompressed:byte(j)
                        j += 1
                    end
                    if ((insn >> 1) & 1) ~= 0 then
                        cp_offset |= decompressed:byte(j) << 8
                        j += 1
                    end
                    if ((insn >> 2) & 1) ~= 0 then
                        cp_offset |= decompressed:byte(j) << 16
                        j += 1
                    end
                    if ((insn >> 3) & 1) ~= 0 then
                        cp_offset |= decompressed:byte(j) << 24
                        j += 1
                    end
                    if ((insn >> 4) & 1) ~= 0 then
                        cp_size |= decompressed:byte(j)
                        j += 1
                    end
                    if ((insn >> 5) & 1) ~= 0 then
                        cp_size |= decompressed:byte(j) << 8
                        j += 1
                    end
                    if ((insn >> 6) & 1) ~= 0 then
                        cp_size |= decompressed:byte(j) << 16
                        j += 1
                    end
                    if cp_size == 0 then
                        cp_size = 0x10000
                    end
                    cp_offset += 1
                    data:insert(base.raw_data:sub(cp_offset, cp_offset + cp_size - 1))
                end
            end
            decompressed = data:concat("")
        end

        if type <= #typenames then
            local data = decompressed
            if type == 1 then
                data = gitwit.parsecommit(data)
            elseif type == 2 then
                data = gitwit.parsetree(data)
            end
            objects:insert({
                typeid = type,
                type = typenames[type],
                data = data,
                raw_data = decompressed,
                hash = crypto.sha1(typenames[type].." "..#decompressed.."\0"..decompressed),
                compressed_data = packfile:sub(i, i + info.compressed_size - 1),
                compressed_base = base?.hash,
                compressed_length = length,
                offset = obj_offset,
            })
        end

        i += info.compressed_size
    end
    --print(crypto.sha1(packfile:sub(1, i - 1)))
    --print(packfile:sub(i):split(""):map(|x| -> string.format("%02x", x:byte())):concat(""))
    return objects
end

function gitwit.blobhash(data)
    return crypto.sha1("blob "..#data.."\0"..data)
end

function gitwit.parsecommit(data)
    local sep = data:find("\n\n")
    local commit = {
        message = data:sub(sep + 2):rstrip("\n")
    }
    for data:sub(1, sep - 1):split("\n") as line do
        sep = line:find(" ")
        commit[line:sub(1, sep - 1)] = line:sub(sep + 1)
    end
    return commit
end

function gitwit.parsetree(data)
    local files = {}
    local i = 1
    while i < #data do
        local mode = {}
        local name = {}
        while i < #data and data[i] ~= " " do
            mode:insert(data[i])
            i += 1
        end
        i += 1
        while i < #data and data[i] ~= "\0" do
            name:insert(data[i])
            i += 1
        end
        i += 1
        local hash = data:sub(i, i + 19):split(""):map(|x| -> string.format("%02x", x:byte())):concat("")
        i += 20
        files:insert({
            mode = mode:concat(""),
            name = name:concat(""),
            hash = hash,
        })
    end
    return files
end

function gitwit.listallfiles(objects, root_tree)
    local files = {}
    gitwit.listallfilesaux(objects, files, "", root_tree)
    return files
end

function gitwit.listallfilesaux(objects, files, prefix, tree)
    for tree.data as file do
        if file.mode == "40000" then
            local data = objects:find(|x| -> x.hash == file.hash)
            assert(data)
            gitwit.listallfilesaux(objects, files, prefix .. file.name .. "/", data)
        else
            files:insert({
                mode = file.mode,
                name = file.name,
                path = prefix .. file.name,
                hash = file.hash,
            })
        end
    end
end

function gitwit.createpackfile(objects)
    local data = { "PACK", string.pack(">I4I4", 2, #objects) }
    local offset = 12
    local offsets = {}
    for objects as object do
        local typeid = object.typeid
        local base_in_packfile = false
        if object.compressed_base then
            base_in_packfile = offsets[object.compressed_base]
            if base_in_packfile then
                typeid = 6
            else
                typeid = 7
            end
        end
        offsets[object.hash] = offset

        local length = object.compressed_length or #object.raw_data
        local byte = length & 0b1111
        length >>= 4
        byte |= (typeid << 4)
        if length ~= 0 then
            byte |= 0x80
        end
        data:insert(string.char(byte)) offset += 1
        while length ~= 0 do
            byte = length & 0x7f
            length >>= 7
            if length ~= 0 then
                byte |= 0x80
            end
            data:insert(string.char(byte)) offset += 1
        end

        if object.compressed_data then
            if object.compressed_base then
                if base_in_packfile then
                    -- https://github.com/git/git/blob/26e47e261e969491ad4e3b6c298450c061749c9e/builtin/pack-objects.c#L409-L419
                    local delta = offsets[object.hash] - offsets[object.compressed_base]
                    local bytes = { delta & 0x7f }
                    delta >>= 7
                    while delta ~= 0 do
                        delta -= 1
                        bytes:insert(0x80 | (delta & 0x7f))
                        delta >>= 7
                    end
                    for i = #bytes, 1, -1 do
                        data:insert(string.char(bytes[i])) offset += 1
                    end
                else
                    data:insert((object.compressed_base:gsub("..", |x| -> string.char(tonumber(x, 16))))) offset += 20
                end
            end
            data:insert(object.compressed_data) offset += #object.compressed_data
        else
            length = #object.raw_data
            local i = 1
            while length >= 0xffff do
                data:insert(string.pack("<I1I2I2", 0, 0xffff, 0)) offset += 5
                data:insert(object.raw_data:sub(i, i + 0xfffe)) offset += 0xffff
                i += 0xffff
                length -= 0xffff
            end
            data:insert(string.pack("<I1I2I2", 1, length, length ~ 0xffff)) offset += 5
            data:insert(object.raw_data:sub(i)) offset += length
        end
    end
    data = data:concat("")
    data ..= crypto.sha1(data, true)
    return data
end

if debug.getinfo(3) then
    -- Loaded as library
    return gitwit
end

-- Used as CLI tool
if arg[1] and arg[2] then
    if arg[1] == "refs" and arg[2] then
        for name, hash in gitwit.fetchrefs(arg[2]) do
            print(hash, name)
        end
        return
    end
    if arg[1] == "clone" then
        local url_base = arg[2]
        local packfile = url_base:split("/"):back()..".pack"
        local ref = arg[3]
        if not ref then
            ref = gitwit.fetchrefs(url_base).HEAD
        end
        print($"Saving {url_base} (at {ref}) to {packfile}...")
        io.contents(packfile, gitwit.downloadpackfile(url_base, ref))
        return
    end
    if arg[1] == "clone-full" or arg[1] == "full-clone" then
        local url_base = arg[2]
        local packfile = url_base:split("/"):back()..".full.pack"
        local ref = arg[3]
        if not ref then
            ref = gitwit.fetchrefs(url_base).HEAD
        end
        print($"Saving {url_base} (from {ref} to genesis) to {packfile}...")
        io.contents(packfile, gitwit.downloadfullpackfile(url_base, ref))
        return
    end
    local function print_obj(obj)
        if obj.type == "commit" then
            print(obj.type, obj.hash, obj.data.message:split("\n")[1])
        else
            print(obj.type, obj.hash)
        end
    end
    local objects = gitwit.parsepackfile(io.contents(arg[1]))
    if (arg[2] == "update" or arg[2] == "patch") and arg[3] then
        local new_objs = gitwit.fetchpackfile(arg[3], arg[4], objects)
        if #new_objs == 0 then
            print("# Already up-to-date")
        else
            print("# "..#new_objs.." new objects:")
            for new_objs as new_obj do
                print_obj(new_obj)
                objects:insert(new_obj)
            end
            io.contents(arg[1], gitwit.createpackfile(objects))
        end
        return
    end
    if arg[2] == "objects" then
        for objects as object do
            print_obj(object)
        end
        return
    end
    if arg[2] == "commits" then
        for objects as object do
            if object.type == "commit" then
                print(object.type, object.hash, object.data.message:split("\n")[1])
            end
        end
        return
    end
    if #arg[2] == 40 then
        local obj = objects:find(|x| -> x.hash == arg[2])
        if obj then
            if obj.type == "tree" then
                for obj.data as file do
                    print(file.mode, file.hash, file.name)
                end
            else
                io.write(obj.raw_data)
            end
        else
            print("Found no object with hash "..arg[2])
        end
        return
    end
end
print(""
    .."\nSupported operations:"
    .."\n"
    .."\n  pluto gitwit.pluto refs <url>                       List remote refs"
    .."\n  pluto gitwit.pluto clone <url> [ref]                Perform shallow clone"
    .."\n  pluto gitwit.pluto clone-full <url> [ref]           Perform full clone"
    .."\n  pluto gitwit.pluto <packfile> update <url> [ref]    Update clone"
    .."\n  pluto gitwit.pluto <packfile> objects               List objects"
    .."\n  pluto gitwit.pluto <packfile> commits               List commits"
    .."\n  pluto gitwit.pluto <packfile> <hash>                View object"
)