MeshBuilder = class("MeshBuilder")

function MeshBuilder:initialize(modelPlaceholder, bundleSize, sendDelay)
    self.modelPlaceholder = modelPlaceholder or "models/holograms/cube.mdl"
    self.bundleSize = bundleSize or 10
    self.sendDelay = sendDelay or 0.5
    
    self._objects = {}
    self._setups = {}
   
    if CLIENT then
        self._setups = {}
        self._meshData = {}

        net.receive("holograms", function(len)
            local hasNext = net.readBit()
            
            while hasNext == 1 do
                local key = net.readString()
                
                net.readEntity(function(ent)
                    if not self._objects[key] then
                        local holo = ent:toHologram()
                        
                        if self._meshData[key] then
                            holo:setMesh(self._meshData[key])
                            holo:setRenderBounds(Vector(-200), Vector(200))
                        end
                        
                        self._objects[key] = holo
                    end
                end)
                
                hasNext = net.readBit()
            end
        end)
    else
        net.receive("setups", function(len, ply)
            local hasNext = net.readBit()
            
            while hasNext == 1 do
                local key = net.readString()
                local pos = net.readVector()
                local ang = net.readAngle()
                local scale = net.readVector()
                local color = net.readColor()
                local mat = net.readString()
                local parent = net.readEntity()
                local relativeTo = net.readEntity()
                
                if not self._objects[key] then
                    if isValid(relativeTo) then
                        pos = relativeTo:localToWorld(pos)
                        ang = relativeTo:localToWorldAngles(ang)
                    end
                    
                    local holo = holograms.create(pos, ang, self.modelPlaceholder, scale)
                    holo:setColor(color)
                    holo:setMaterial(mat)
                    holo:setParent(parent)
                    
                    self._objects[key] = holo
                end
                
                if not self._setups[key] then
                    self._setups[key] = self._objects[key]
                end
                
                hasNext = net.readBit()
            end
            
            net.start("holograms")
                for k, v in pairs(self._setups) do
                    net.writeBit(1)
                    net.writeString(k)
                    net.writeEntity(v)
                end
                net.writeBit(0)
            net.send(ply)
            
            table.empty(self._setups)
        end)
    end
end

if CLIENT then
    function MeshBuilder:setMeshData(meshData)
        self._meshData = meshData
    end
    
    function MeshBuilder:setup(key, pos, ang, scale, color, mat, parent, relativeTo)
        if not self._objects[key] and not self._setups[key] and self._meshData[key] then
            self._setups[key] = {
                pos = pos,
                ang = ang,
                scale = scale,
                color = color,
                mat = mat,
                parent = isValid(parent) and parent or chip(),
                relativeTo = isValid(relativeTo) and relativeTo or chip()
            }
        end
    end
    
    function MeshBuilder:setupAll(pos, ang, scale, color, mat, parent, relativeTo)
        for _, v in pairs(table.getKeys(self._meshData)) do
            self:setup(v, pos, ang, scale, color, mat, parent)     
        end
    end
    
    function MeshBuilder:build()
        local function sendSetups(setups)
            net.start("setups")
                for k, v in pairs(setups) do
                    net.writeBit(1)
                    net.writeString(k)
                    net.writeVector(v.pos)
                    net.writeAngle(v.ang)
                    net.writeVector(v.scale)
                    net.writeColor(v.color)
                    net.writeString(v.mat)
                    net.writeEntity(v.parent)
                    net.writeEntity(v.relativeTo)
                end
                net.writeBit(0)
            net.send()
        end        

        local bundleKeys = table.getKeys(self._setups)
        if #bundleKeys > self.bundleSize then
            local i  = 1
            
            timer.create("sendSetups", self.sendDelay, math.ceil(#bundleKeys / self.bundleSize), function()
                local from = (i - 1) * self.bundleSize + 1
                local setups = {}
                
                for _, v in pairs({ unpack(bundleKeys, from, from + self.bundleSize - 1) }) do
                    setups[v] = self._setups[v]
                end
                
                sendSetups(setups)
                
                if i < math.ceil(#bundleKeys / self.bundleSize) then
                    i = i + 1
                else
                    table.empty(self._setups)
                end
            end)
        else
            send(self._setups) 
        end
    end
end