local expect = require "cc.expect".expect
local compression_level = 8

if not fs.exists(".containerizer/libs/lua-minify.lua") then
    local lib = http.get("https://git.cadencoaster.com/Rivulet/CC-Tweaked-Stuff/raw/branch/main/lua-minify.lua").readAll()
    fs.makeDir(".containerizer/libs/")
    local file = fs.open(".containerizer/libs/lua-minify.lua","w")
    file.write(lib)
    file.close()
end
if not fs.exists(".containerizer/libs/deflate.lua") then
    local lib = http.get("https://github.com/SafeteeWoW/LibDeflate/raw/refs/heads/main/LibDeflate.lua").readAll()
    fs.makeDir(".containerizer/libs/")
    local file = fs.open(".containerizer/libs/deflate.lua","w")
    file.write(lib)
    file.close()
end

local parser = loadfile(".containerizer/libs/lua-minify.lua")()
local deflate = loadfile(".containerizer/libs/deflate.lua")()

local function setFileSystem(data,dir)
    data.rom = nil
    data = textutils.serialize(data)
    local file = fs.open(dir, "w")
    file.write(deflate:CompressDeflate(data,{level=compression_level}))
    file.close()
end

local function scan(dir)
    local out = {}
    for _,i in ipairs(fs.list(dir)) do
        local path = fs.combine(dir,i)
        if fs.isDir(path) then
            out[i] = scan(path)
        else
            local file = fs.open(path,"r")
            out[i] = file.readAll()
            file.close()
        end
    end
    return out
end

local funcs = {}

function funcs.create(projname, appid)
    expect(1, projname, "string")
    expect(2, appid, "string")
    print("creating project with name",projname.."...")
    fs.makeDir(fs.combine(shell.dir(),projname,"src"))
    fs.makeDir(fs.combine(shell.dir(),projname,"build"))
    local buildfile = fs.open(fs.combine(shell.dir(),projname,"build.lua"),"w")
    buildfile.write([[--Default build.lua Script

local appid = "]]..appid..[["

local project_name = "]]..projname..[["


local package_data = build.optimize(build.package("src"))

build.writePackage(package_data,"build/"..appid)

local meta = {
  perms = {
    repo = false,
    network = false,
    app = false,
    http = false,
  },
  author = "Unkown",
  name = project_name,
  appid = appid,
}

build.writeMeta(meta,"build/"..project_name..".meta")
build.merge("build/"..appid,"build/"..project_name..".meta","build/"..project_name..".app")
]])
    buildfile.close()
    local startupfile = fs.open(fs.combine(shell.dir(),projname,"src/startup.lua"),"w")
    startupfile.write('print("Hello, World!")')
    startupfile.close()
    print("done configuring project")
end

function funcs.build()
    if fs.exists(fs.combine(shell.dir(),"build.lua")) and not fs.isDir(fs.combine(shell.dir(),"build.lua")) then
        fs.delete(fs.combine(shell.dir(),"build"))
        fs.makeDir(fs.combine(shell.dir(),"build"))
        local builddir = "/.containerizer/build"
        fs.delete(builddir)
        fs.makeDir(builddir)
        builddir = fs.combine(builddir,fs.getName(shell.dir()))
        fs.copy(shell.dir(),builddir)
        local build = {}
        build.path = builddir
        function build.package(dir)
            print("packaging",dir)
            return scan(fs.combine(builddir,dir))
        end
        function build.writePackage(data,loc)
            print("writing package to",loc)
            setFileSystem(data,fs.combine(builddir,loc))
        end
        function build.writeMeta(data,loc)
            print("writing meta to",loc)
            local file = fs.open(fs.combine(builddir,loc),"w")
            if not file then printError("Build Error: Unable to open", loc) return end
            file.write(textutils.serialise(data))
            file.close()
        end
        function build.optimize(data)
            print("optimizing package")
            local function optimize(data)
                if type(data) == "table" then
                    local out = {}
                    for k,v in pairs(data) do
                        out[k] = optimize(v)
                    end
                    return out
                else
                    local st,ast = parser.parser.ParseLua(data)
                    if not st then
                        return data
                    end
                    return parser.Format_Mini(ast)
                end
            end
            return optimize(data)
        end
        function build.merge(packagePath,metaPath,outputPath)
            print("merging",packagePath,"and",metaPath,"to",outputPath)
            local pFile = fs.open(fs.combine(builddir,packagePath),"r")
            if not pFile then printError("Build Error: Unable to open", packagePath) return end
            local package = pFile.readAll()
            pFile.close()
            
            local mFile = fs.open(fs.combine(builddir,metaPath),"r")
            if not mFile then printError("Build Error: Unable to open", metaPath) return end
            local meta = textutils.unserialise(mFile.readAll())
            mFile.close()

            local oFile = fs.open(fs.combine(builddir,outputPath),"w")
            if not oFile then printError("Build Error: Unable to open", outputPath) return end
            oFile.write(textutils.serialise({meta=meta,package=package}))
            oFile.close()
        end
        local buildenv = {build = build}
        setmetatable(buildenv,{__index=_G})
        setfenv(loadfile(fs.combine(builddir,"build.lua")),buildenv)()
        fs.delete(fs.combine(shell.dir(),"build"))
        fs.copy(fs.combine(builddir,"build"),fs.combine(shell.dir(),"build"))
        print("done building",fs.getName(shell.dir()))
    else
        printError("Not in the root directory of a project.")
    end
end


local args = {...}
funcs[args[1]](table.unpack(args,2,#args))