class BoolCalc

# File lib/bitwiseCalc, line 11
def initialize()
    @x = nil; @y = nil; @ans = nil; @operation = nil

    # Valid Operations
    @ops = { :NOT => "Bitwise Not", :SHR => "Shift Right",
             :SHL => "Shift Left", :AND => "Logical And",
             :OR => "Logical Or", :XOR => "Exclusive Or",
             :RAD => "Display Radixes", :ROL => "Circular Rotate Left",
             :ROR => "Circular Rotate Right", :MUL => "Multiply",
             :DIV => " Division", :ADD => "Addition",
             :SUB => "Subtraction", :MOD => "Modulus",
             :POW => "Exponentiation", :NOR => "Negated OR",
             :NAND => "Negated AND", :XNOR => "Complement XOR"}

    # Option Hash
    @options = { nocolor: false, grouped: false, bit4: true,
                 bit64: true, ipnum: false, nargs: false }
end

# File lib/bitwiseCalc, line 106
def check_for_errors()
    # no operation read
    abort("ERROR, Expected Operation".red) if @operation.nil?

    # make sure binary operations have binary input
    restriction = @operation != "NOT" && @operation != "RAD" && @y.nil?
    # also make sure we have read at least 1 number
    if restriction || @x.nil?
        abort("ERROR, Expected Number(s) for Operation:\t#{@operation}".red)
    end

    # div by zero
    if (@operation == "DIV" || @operation == "MOD") && @y == 0
        abort("ERROR, Divide by 0 for Operation:\t#{@operation}".red)
    end
end

# File lib/bitwiseCalc, line 42
def execute()
    case @operation
    when 'RAD'
        return
    when 'AND'
        @ans = @x & @y
    when 'NAND'
        @ans = ~(@x & @y)
    when 'OR'
        @ans = @x | @y
    when 'NOR'
        @ans = ~(@x | @y)
    when 'XOR'
        @ans = @x ^ @y
    when 'XNOR'
        @ans = ~(@x ^ @y)
    when 'NOT'
        @ans = ~@x
    when 'SHR'
        @ans = @x >> @y
    when 'SHL'
        @ans = @x << @y
    when 'ROL'
        binarr = int_to_binarr(@x)
        @ans = rol(binarr).join.to_i(2)
    when 'ROR'
        binarr = int_to_binarr(@x)
        @ans = ror(binarr).join.to_i(2)
    when 'MUL'
        @ans = @x * @y
    when 'ADD'
        @ans = @x + @y
    when 'DIV'
        @ans = @x / @y
    when 'SUB'
        @ans = @x - @y
    when 'MOD'
        @ans = @x % @y
    when 'POW'
        @ans = @x ** @y
    end
end

# File lib/bitwiseCalc, line 237
def int_to_binarr(arr)
    tmparr = []
    255.downto(0) do |n|
        tmparr << arr[n]
    end
    tmparr
end

# File lib/bitwiseCalc, line 124
def parse_args()
    #exit if no args passed; parse flags only if needed
    usage if ARGV.empty?
    parse_flags if ARGV[0][0] == "-"

    ARGV.each do |arg|

        case arg
        #check if valid operation choice
        when arg[/[a-zA-Z]+/]
            @operation = arg.upcase if @ops.has_key?(arg.upcase.to_sym)
        #hex number
        when arg[/0[xX][0-9a-fA-F]+/]
            @x == nil ? @x = arg.to_i(16) : @y = arg.to_i(16)
        #binary number
        when arg[/0[bB][0-1]+/]
            @x == nil ? @x = arg.to_i(2) : @y = arg.to_i(2)
        #octal number
        when arg[/0[0-7]+/]
            @x == nil ? @x = arg.to_i(8) : @y = arg.to_i(8)
        #decimal number
    when arg[/^-?[0-9]+/]
            @x == nil ? @x = arg.to_i : @y = arg.to_i
        end
    end
end

# File lib/bitwiseCalc, line 151
def parse_flags()
    flags = ARGV[0]
    flags.split("").each do |flag|
        case flag
        when "n"
            @options[:nocolor] = true
        when "h"
            usage
        when "f"
            @options[:bit4] = false
        when "s"
            @options[:bit64] = false
        when "g"
            @options[:grouped] = true
        end
    end
end

# File lib/bitwiseCalc, line 31
def print_all_radix(num)
    base10 = num.to_s(10)
    base10 = base10.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse! if @options[:grouped]
    print "Base 2:\n".yellow
    print_nice_binary(num)
    puts "Base 8: ".yellow; puts "\t#{num.to_s(8)}"
    puts "Base 10:".yellow; puts "\t#{base10}"
    puts "Base 16:".yellow; puts "\t#{num.to_s(16)}"
end

# File lib/bitwiseCalc, line 214
def print_nice_binary(num)
    if num <= 2 ** 31
        max = 31
    elsif num <= 2 ** 63
        max = 63
    elsif num <= 2 ** 127
        max = 127
    else
        max = 255
    end
    puts "\t#{max+1} Bit Format(MSB First)".yellow
    print "\t"
    max.downto(0) do |n|
        if (n+1)%64 == 0 && @options[:bit64]
                print "\n\t"
        elsif (n+1)%4 == 0 && @options[:bit4]
            print " "
        end
        print num[n]
    end
    puts
end

# File lib/bitwiseCalc, line 86
def print_results()
    String.disable_colorization = true if @options[:nocolor]
    separator = "\t---------------------------------------\n"
    print separator.green
    print_all_radix(@x)

    # print 2 passed num only if
    if @y != nil && @operation != "NOT"
        puts separator.green
        print_all_radix(@y)
    end

    # rad simply outputs num(s) in multiple radixes
    if @operation != "RAD"
        puts "\n\t-------------#{@operation} Result-----------------".green
        print_all_radix(@ans)
    end
end

# File lib/bitwiseCalc, line 266
def rol(tmparr)
    arr_tail = tmparr.length-2
    for i in 1..@y
        #save most significant bit(beginning of array)
        msb = tmparr[0]
        for j in 0..arr_tail
            #assign next element in array to current element in array
            tmparr[j] = tmparr[j+1]
        end
        #assign most significant bit to tail
        tmparr[-1] = msb
    end
    tmparr
end

# File lib/bitwiseCalc, line 245
def ror(tmparr)
    arr_tail = tmparr.length-2
    for i in 1..@y
        #save least significant bit(end of array)
        lsb = tmparr[-1]
        for j in 0..arr_tail
            if j == 0
                tmp1 = tmparr[j+1]
                tmparr[j+1] = tmparr[j]
            end
            #save next element, make next element previously saved elem
            tmp2 = tmparr[j+1]
            tmparr[j+1] = tmp1
            tmp1 = tmp2
        end
        #assign least significant bit(end of array) to head of array
        tmparr[0] = lsb
    end
    tmparr
end

# File lib/bitwiseCalc, line 169
def usage()
    puts """
    Description:
        A simple bitwise calculator that executes the operations noted below.
        It can accept Octal, Hexadecimal, Decimal, and Binary inputs.
        It will output in above mentioned radixes.
        Binary output will have 32, 64, 128, and up to 256 bit format.
        The results are printed to the console.
    Usage:
        Pass arguments to the program as shown below. Note that binary output
        is spaced every 4 bits. Every 64 bits, a newline is added for readability.
        For additional help/examples:
            https://github.com/vargash1/Bitwise-Calculator

        Unary Operations:
            bitwiseCalc [flag] <number> <operation>

        Binary Operations:
            bitwiseCalc [flag] <number> <operation> <number>

        Passing a number in a radix other than base10:
            <base_2_number>  = 0b[0-1]
            <base_8_number>  = 0[0-7]
            <base_16_number> = 0x[0-9a-f]
    Flags:
        -f
            disables spacing every 4 bits in binary output(enabled by default)
        -s
            disables newline every 64 bits in binary output(enabled by default)
        -n
            disables colorized output(enabled by default)
        -h
            displays this message and exits
        -g
            outputs base 10 numbers in grouped form(with commas)
    Operations:"""
    @ops.each_pair do |key,val|
        puts "\t #{key}\n\t\t#{val}"
    end
    exit
end