-- bit.tobit  bit.tohex  bit.bnot    bit.band bit.bor  bit.bxor
-- bit.lshift bit.rshift bit.arshift bit.rol  bit.ror  bit.bswap

dalosp.binaryops = {
    operations = {
        XOR = 1,
        AND = 2,
        OR = 3,
        ADD = 4,
        SUB = 5,
    },
    
    opnames = {
        "xor",
        "and",
        "or",
        "add",
        "sub",
    },
    
    configure = function (self)
--        local accept = iup.GetParam
    end,
    
    input_change = function (self, ind)
        local h1 = self:get_linked_input(1)
        local h2 = self:get_linked_input(1)
        local op = self.extra.op or dalosp.binaryops.XOR
        if h1 and h2 then
            local obj = {
                h1 = h1,
                h2 = h2,
                op = op,
                maximize = self.extra.maximize,
                offset = 0,
                size = self.extra.maximize and math.max(h1:getsize(), h2:getsize()) or math.min(h1:getsize(), h2:getsize()),
                canread = function (self) return true end,
                canwrite = function (self) return false end,
                canseek = function (self) return true end,
                canwatch = function (self) return false end,
                getname = function (self) return  end,
                tell = function (self) return self.offset end,
                getsize = function (self) return self.size end,
                getmodif = function (self) return 0 end,
                flush = function (self) return true end,
                seek = function (self, offset, wheel) 
                    if wheel == SEEK_SET then
                        self.offset = offset
                    elseif wheel == SEEK_CUR then
                        self.offset = self.offset + offset
                    elseif wheel == SEEK_END then
                        self.offset = self.size + offset
                    else
                        error "Unknown wheel"
                    end
                    if self.offset < 0 then self.offset = 0 end
                    if self.offset >= self.size then self.offset = self.size end
                    return self.offset
                end,
                read = function (self, dummy, count)
                    count = math.min(count, self.size - self.offset)
                    
                    if count == 0 then
                        if self.got_eof then self.lh:close() end
                        self.got_eof = true
                        return 0
                    end
                    
                    self.got_eof = false
                    
                    self.h1:seek(self.offset)
                    self.h2:seek(self.offset)

---- maximizing work to do here...                    
                    local r1, t1 = self.h1:read(count)
                    local r2, t2 = self.h2:read(count)
                    local r = math.min(r1, r2)
                    self.offset = self.offset + r
                    if r == 0 then self.got_eof = true return 0 end
                    local t = {}
                    local op
                    if self.op == dalosp.binaryops.operations.XOR then
                        op = bit.bxor
                    elseif self.op == dalosp.binaryops.operations.AND then
                        op = bit.band
                    elseif self.op == dalosp.binaryops.operations.OR then
                        op = bit.bor
                    elseif self.op == dalosp.binaryops.operations.ADD then
                        op = function(a, b) return a + b end
                    elseif self.op == dalosp.binaryops.operations.SUB then
                        op = function(a, b) return a - b end
                    end
                    for i = 0, r - 1 do
                        t[i] = bit.band(op(t1[i], t2[i]), 255)
                    end
                    return r, t
                end,
            }
            local newh = HandleLua(obj)
            obj.lh = newh
            self:set_houtput(newh)
        else
            self:set_houtput(nil)
        end
    end,
    
    draw = function (self, cv, x, y, w, h)
        dalosp.object.default_draw(self, cv, x, y, w, h)
        -- add status display
    end,
    
    create = function (d, tab)
        tab.ninputs = 2
        tab.noutputs = 1
        tab.otype = dalos.objtype.LUA_FILTER
        tab.configure = dalosp.binaryops.configure
        tab.input_change = dalosp.binaryops.input_change
        tab.default_name = "Binary Ops"
        tab.draw = dalosp.binaryops.draw
        local extra = { }
        
        local obj = dalos.object(d, tab, extra)
    end,
}

dalos.binaryops = dalosp.binaryops.create
dalos:register_obj("Binary Ops", dalos.binaryops)