/******************************************************************************
bitDerle v0.2.02 ham (beta)
(c) 2012 - Salih Dinçer <salihdb@hotmail.com>

o Ali Çehreli <acehreli@yahoo.com>
o Zafer Çelenk <zafercelenk@gmail.com>

(o) Katkı sağladılar...
******************************************************************************/
//import std.c.stdio: printf;/*
import std.stdio;

class bitDerle {
        // BS (BiR SIFIR ~ One Zero)
    struct BS (data_t = ubyte) {  
        data_t[] xData;
        
        immutable bl = data_t.sizeof * 8;           // bit length (ubyte => 8)
        immutable lb = (data_t.max / 2) + 1;        // last bit (ubyte => 128)
    
        auto mask(data_t rol, data_t lOffset, data_t mLength) {
            auto maske = data_t.max;
            
            maske >>= bl - mLength;
            maske <<= lOffset;
            
            // partial masking (offset/rolling 2/3 => 0b11100111)
            // if (rol) maske = ~maske; // invert mask
            for (; rol>0; rol--) {
                maske <<= 1;
                maske |= 1;
            }
            
            return maske;
        }
        
        auto reverse(data_t n) {
            data_t x = 0;
            
            for(auto i = 0; i < bl; ++i) {
               x <<= 1;
               x += n % 2;
               n >>= 1;
            }
            
            return x;
        }
        
        auto invert(data_t xPattern, data_t pLength = 0) {
            // !!! BAKILACAK !!!
            
            return ~xPattern;
        }
        
        void init(data_t[] data) {
            xData ~= data;
        }
        
        bool read(size_t n) {
            return (xData[n / bl] & (lb >> n % bl)) != 0;/*
            
            if((xData[n / bl] & (lb >> n % bl)) != 0) return true;
            return false;//*/
        }
        
        data_t find(data_t xBit) {
            data_t xHead, xMask, x, xSay = xBit;
            
            for (x = 0; x <= bl; ++x, xSay >>= 1) if (xSay == 0) {
                xMask = mask(0, 0, x);
                for (auto bs = 0; bs < (xData.length * bl); ++bs, xHead <<= 1) {
                    if ((xData[bs / bl] & (lb >> bs % bl)) != 0) xHead |= 1;
                    xHead &= xMask;
                    if (xHead == xBit) return cast(data_t)(bs - x + 1);
                }
            }
            
            return 0;  // not found!
        }
    
        data_t write(data_t xOffset, data_t xPattern, data_t pLength) {
            auto pOffset = cast(data_t)(bl - (xOffset % bl));   // pattern offset
            auto sOffset = cast(data_t)(pLength - pOffset);     // secondary offset
            auto lOffset = cast(data_t)(bl - sOffset);          // left offset
            auto rOffset = cast(data_t)(pOffset - pLength);     // right offset
            auto xByte  = cast(size_t)(xOffset / bl);
        
            if (xOffset) {
                if (pOffset >= pLength) {
                    if (pOffset == pLength) {
                        xData[xByte] &= mask(0, pLength, bl);
                        xData[xByte] |= xPattern;
                        return 1;   // shift masking
                    } else {
                        xData[xByte] &= mask(rOffset, pLength, bl);
                        xData[xByte] |= xPattern << rOffset;
                        return 2;   // rotate masking
                    }
                } else {
                    xData[xByte] &= mask(0, pOffset, bl);
                    xData[xByte] |= xPattern >> sOffset;
                    
                    xByte++;   // next byte...
                    
                    xData[xByte] &= mask(lOffset, sOffset, bl);
                    xData[xByte] |= (xPattern & mask(0, 0, sOffset)) << lOffset;
                    return 3;  // partial masking
                }
            }
            
            return 0;  // no change...
        }
    
        void print(data_t sb, data_t sr = bl) {
            for (size_t i = 0; i < xData.length * bl; i++) {
                if ((i != 0) && (i % sr == 0)) writef("_");
                writef(read(i) ? "1" : "0");
            }
            writef("\n");
            
            for (size_t i = 0; i < sb + (sb / sr); i++) writef("-");
            if (sb) writef("^\n");
        }
    }
}

int main() {
    bitDerle.BS!(ulong) bit;
    typeof(bit.xData) searchData = [ 7, 1, 137];//, 137, 137, 137, 3, 143 ];
    immutable keyword1 = 0b1110;
    immutable keyword2 = 0b0001;   //bit.invert(keyword1);
    
    bit.init(searchData);
    auto offset = bit.find(keyword1);
    
    bit.print(offset);
    auto test = bit.write(offset, keyword2, 4);
    bit.print(offset);
    
    //writef("%b - ", test);/*
    
    if (test < 0) writef("!!! ERROR !!! ");
    else if (test == 0) writef("No Change: ");
    else if (test == 1) writef("Shift Masking: ");
    else if (test == 2) writef("Rotate Masking: ");
    else if (test == 3) writef("Partial Masking: ");
    
    //*/ 
    writef("[ %b ] Search term ", keyword1);
    if (offset) writef("found.\nFirst occurrence was at position %d.", offset);
    else writef("not found! Sorry...");
    writeln();
    
    return 0;
}