using System;

namespace ErrorsManager{

    class FullError{

        public int integer;
        public string _string;
        public byte[] array;
        
        public FullError(ErrorsManager errors, int integer){
            this.integer = integer;
            _string = errors.to_string(integer);
            array = errors.to_array(integer);
        }
        
        public FullError(ErrorsManager errors, string _string){
            integer = errors.to_integer(_string);
            this._string = _string;
            array = errors.to_array(_string);
        }
        
        public FullError(ErrorsManager errors, byte[] array){
            integer = errors.to_integer(array);
            _string = errors.to_string(array);
            this.array = array;
        }

        public static string print(byte[] array){
            return "[" + string.Join(", ", array) + "]";
        }

    }

    class Tests{

        public static void errors(){

            ErrorsManager errors = new ErrorsManager();
            FullError error = new FullError(errors, 217934237);
            FullError reset = new FullError(errors, 0);

            reset.integer = errors.reset(error.integer, -5, 12);
            reset._string = errors.reset(error._string, -5, 12);
            reset.array = errors.reset(error.array, -5, 12);

            Console.WriteLine($"RESET: from {-5} bits {12}");
            Console.WriteLine($"INTEGER: {errors.to_string_binary(error.integer)} - {errors.to_string_binary(reset.integer)}");
            Console.WriteLine($"STRING:  {errors.to_string_binary(error._string)} - {errors.to_string_binary(reset._string)}");
            Console.WriteLine($"ARRAY:   {errors.to_string_binary(error.array)} - {errors.to_string_binary(reset.array)}");
            Console.WriteLine();
            
        }

        public static ErrorsManager conversions(int tests = 10, object inputs = null){

            ErrorsManager errors = new ErrorsManager(inputs);
            Random seed = new Random();
            
            for(int i = 0; i < tests; i ++){
                
                FullError error = new FullError(errors, seed.Next(0, 1 << 16));

                Console.WriteLine($"INTEGER: {errors.to_integer(error.integer)}, {errors.to_integer(error._string)}, {errors.to_integer(error.array)}");
                Console.WriteLine($"STRING: {errors.to_string(error.integer)}, {errors.to_string(error._string)}, {errors.to_string(error.array)}");
                Console.WriteLine($"ARRAY: {FullError.print(errors.to_array(error.integer))}, {FullError.print(errors.to_array(error._string))}, {FullError.print(errors.to_array(error.array))}");
                Console.WriteLine();

            }
            
            return errors;
        }

        public static void alphabet(int tests = 10){

            Random seed = new Random();
            
            for(int i = 0; i < tests; i ++){

                ErrorsManager errors = conversions(1, new Dictionary<string, object>() {
                    {"base", seed.Next(2, 128)}
                });

                Console.WriteLine($"^^^ ALPHABET: {string.Join(", ", errors.get_alphabet())} ^^^");
                Console.WriteLine();

            }
        }

        public static void bitwise(int tests = 10){

            ErrorsManager errors = new ErrorsManager();
            Random seed = new Random();
            
            for(int i = 0; i < tests; i ++){
                
                FullError error = new FullError(errors, seed.Next(0, 1 << seed.Next(0, 16)));
                FullError shifted = new FullError(errors, 0);
                FullError unshifted = new FullError(errors, 0);
                int bitwise = 10 - seed.Next(0, 20);

                Console.WriteLine($"BITWISE: {bitwise}");

                shifted.integer = errors.bitwise(error.integer, bitwise);
                shifted._string = errors.bitwise(error._string, bitwise);
                shifted.array = errors.bitwise(error.array, bitwise);
                unshifted.integer = errors.bitwise(shifted.integer, -bitwise);
                unshifted._string = errors.bitwise(shifted._string, -bitwise);
                unshifted.array = errors.bitwise(shifted.array, -bitwise);

                Console.WriteLine($"INTEGER: {errors.to_string_binary(error.integer)} - {error.integer}");
                Console.WriteLine($"STRING:  {errors.to_string_binary(error._string)} - {error._string}");
                Console.WriteLine($"ARRAY:   {errors.to_string_binary(error.array)} - {FullError.print(error.array)}");
                Console.WriteLine($"INTEGER: {errors.to_string_binary(shifted.integer)} - {shifted.integer}");
                Console.WriteLine($"STRING:  {errors.to_string_binary(shifted._string)} - {shifted._string}");
                Console.WriteLine($"ARRAY:   {errors.to_string_binary(shifted.array)} - {FullError.print(shifted.array)}");
                Console.WriteLine($"INTEGER: {errors.to_string_binary(unshifted.integer)} - {unshifted.integer}");
                Console.WriteLine($"STRING:  {errors.to_string_binary(unshifted._string)} - {unshifted._string}");
                Console.WriteLine($"ARRAY:   {errors.to_string_binary(unshifted.array)} - {FullError.print(unshifted.array)}");
                Console.WriteLine();

            }
            
        }

        public static void bitwise_sucesive(int tests = 10){

            ErrorsManager errors = new ErrorsManager();
            FullError error = new FullError(errors, new Random().Next(0, 1 << 16));

            Console.WriteLine($"INTEGER: {errors.to_string_binary(error.integer)} - {error.integer}");
            Console.WriteLine($"STRING:  {errors.to_string_binary(error._string)} - {error._string}");
            Console.WriteLine($"ARRAY:   {errors.to_string_binary(error.array)} - {FullError.print(error.array)}");
            Console.WriteLine();
            
            for(int i = -tests; i < tests; i ++){

                FullError shifted = new FullError(errors, 0);

                Console.WriteLine($"BITWISE: {i}");

                shifted.integer = errors.bitwise(error.integer, i);
                shifted._string = errors.bitwise(error._string, i);
                shifted.array = errors.bitwise(error.array, i);


                Console.WriteLine($"INTEGER: {errors.to_string_binary(shifted.integer)} - {shifted.integer}");
                Console.WriteLine($"STRING:  {errors.to_string_binary(shifted._string)} - {shifted._string}");
                Console.WriteLine($"ARRAY:   {errors.to_string_binary(shifted.array)} - {FullError.print(shifted.array)}");
                Console.WriteLine();

            }
            
        }

        public static void bits(int tests = 10){
            
            ErrorsManager errors = new ErrorsManager();
            Random seed = new Random();
            
            for(int i = 0; i < tests; i++){
                
                FullError error = new FullError(errors, seed.Next(0, 1 << seed.Next(0, 28)));
                int from_value = seed.Next(-15, 15);
                int bits_value = seed.Next(-13, 13);
                int[] from = new int[]{from_value, from_value, from_value};
                int[] bits = new int[]{bits_value, bits_value, bits_value};

                errors.get_from_bits(error.integer, ref from[0], ref bits[0]);
                errors.get_from_bits(error._string, ref from[1], ref bits[1]);
                errors.get_from_bits(error.array, ref from[2], ref bits[2]);


                Console.WriteLine($"CODE: {error.integer} - {error._string} - {FullError.print(error.array)}");
                Console.WriteLine($"ERROR: {errors.to_string_binary(error.integer)} - {errors.get_bits(error.integer)} - {errors.get_bits(error._string)} - {errors.get_bits(error.array)}");
                Console.WriteLine($"FROM: {from_value} - {from[0]}, {from[1]}, {from[2]}");
                Console.WriteLine($"BITS: {bits_value} - {bits[0]}, {bits[1]}, {bits[2]}");
                Console.WriteLine();

            }
            
        }

        public static void reset(int tests = 10){
            
            ErrorsManager errors = new ErrorsManager();
            Random seed = new Random();
            
            for(int i = 0; i < tests; i ++){
                
                FullError error = new FullError(errors, seed.Next(0, 1 << 28));
                int from = seed.Next(-15, 15);
                int bits = seed.Next(-13, 13);
                FullError reset = new FullError(errors, 0);

                reset.integer = errors.reset(error.integer, from, bits);
                reset._string = errors.reset(error._string, from, bits);
                reset.array = errors.reset(error.array, from, bits);

                Console.WriteLine($"RESET: from {from} bits {bits}");
                Console.WriteLine($"INTEGER: {errors.to_string_binary(error.integer)} - {errors.to_string_binary(reset.integer)}");
                Console.WriteLine($"STRING:  {errors.to_string_binary(error._string)} - {errors.to_string_binary(reset._string)}");
                Console.WriteLine($"ARRAY:   {errors.to_string_binary(error.array)} - {errors.to_string_binary(reset.array)}");
                Console.WriteLine();

            }

        }

        public static void ranges(int tests = 10){
            
            ErrorsManager errors = new ErrorsManager();
            Random seed = new Random();
            
            for(int i = 0; i < tests; i ++){
                
                FullError error = new FullError(errors, seed.Next(0, 1 << 28));
                int from = seed.Next(-15, 15);
                int bits = seed.Next(-13, 13);
                FullError range = new FullError(errors, 0);

                Console.WriteLine($"RANGE: from {from} bits {bits}");
                errors.get_from_bits(error._string, ref from, ref bits);
                Console.WriteLine($"REAL:  from {from} bits {bits}");

                range.integer = errors.get_range(error.integer, from, bits);
                range._string = errors.get_range(error._string, from, bits);
                range.array = errors.get_range(error.array, from, bits);

                Console.WriteLine($"INTEGER: {errors.to_string_binary(error.integer)} - {errors.to_string_binary(range.integer)}");
                Console.WriteLine($"STRING:  {errors.to_string_binary(error._string)} - {errors.to_string_binary(range._string)}");
                Console.WriteLine($"ARRAY:   {errors.to_string_binary(error.array)} - {errors.to_string_binary(range.array)}");
                Console.WriteLine();

            }

        }

        public static void has(int tests = 10){
            
            ErrorsManager errors = new ErrorsManager();
            Random seed = new Random();
            
            for(int i = 0; i < tests; i ++){
                
                FullError error = new FullError(errors, seed.Next(0, 1 << 28));
                int from = seed.Next(-15, 15);
                int bits = seed.Next(-13, 13);

                Console.WriteLine($"HAS: from {from} bits {bits}");
                Console.WriteLine($"INTEGER: {errors.has(error.integer, from, bits)} - {errors.to_string_binary(error.integer)} - {errors.to_string_binary(errors.get_range(error.integer, from, bits))}");
                Console.WriteLine($"STRING:  {errors.has(error._string, from, bits)} - {errors.to_string_binary(error._string)} - {errors.to_string_binary(errors.get_range(error._string, from, bits))}");
                Console.WriteLine($"ARRAY:   {errors.has(error.array, from, bits)} - {errors.to_string_binary(error.array)} - {errors.to_string_binary(errors.get_range(error.array, from, bits))}");
                Console.WriteLine();

            }

        }

        public static void set(int tests = 10){
            
            ErrorsManager errors = new ErrorsManager();
            Random seed = new Random();
            
            for(int i = 0; i < tests; i ++){
                
                FullError error = new FullError(errors, seed.Next(0, 1 << 15));
                FullError value = new FullError(errors, seed.Next(0, 1 << 15));
                int from = seed.Next(-15, 15);
                int bits = seed.Next(-13, 13);
                FullError set_integer = new FullError(errors, 0);
                FullError set_string = new FullError(errors, 0);
                FullError set_array = new FullError(errors, 0);

                set_integer.integer = errors.set(error.integer, value.integer, from, bits);
                set_string.integer = errors.set(error.integer, value._string, from, bits);
                set_array.integer = errors.set(error.integer, value.array, from, bits);
                set_integer._string = errors.set(error._string, value.integer, from, bits);
                set_string._string = errors.set(error._string, value._string, from, bits);
                set_array._string = errors.set(error._string, value.array, from, bits);
                set_integer.array = errors.set(error.array, value.integer, from, bits);
                set_string.array = errors.set(error.array, value._string, from, bits);
                set_array.array = errors.set(error.array, value.array, from, bits);

                Console.WriteLine($"SET: from {from} bits {bits} to {value}");
                Console.WriteLine($"ERROR: {errors.to_string_binary(error.integer)} - VALUE: {errors.to_string_binary(value.integer)}");
                Console.WriteLine($"INTEGER: {errors.to_string_binary(set_integer.integer)} - {errors.to_string_binary(set_integer._string)} - {errors.to_string_binary(set_integer.array)}");
                Console.WriteLine($"STRING:  {errors.to_string_binary(set_string.integer)} - {errors.to_string_binary(set_string._string)} - {errors.to_string_binary(set_string.array)}");
                Console.WriteLine($"ARRAY:   {errors.to_string_binary(set_array.integer)} - {errors.to_string_binary(set_array._string)} - {errors.to_string_binary(set_array.array)}");
                Console.WriteLine();

            }

        }

    }

}