#include "type_boolarray.h"

barray *create_barray(uint size) {
    barray *ptr = malloc(sizeof(barray));
    ptr->size = size;
    if (size % 8 == 0) {
        ptr->size_array = size / 8;
    } else {
        ptr->size_array = size / 8 + 1;
    }
    ptr->array = malloc(ptr->size_array * sizeof(uchar));
    for (uint i = 0; i < ptr->size_array; i++) {
        ptr->array[i] = false;
    }

    return ptr;
}

uint getsize_barray(barray *ptr) {
    if (ptr == NULL) {
        ERROR("getsize_barray: ptr is NULL");
    }
    return ptr->size;
}

void delete_barray(barray *ptr) {
    if (ptr == NULL) {
        return;
    }
    if (ptr->array != NULL) {
        free(ptr->array);
    }
    free(ptr);
    return;
}

void settrue_barray(barray *ptr, uint num_bool) {
    if (ptr == NULL) {
        ERROR("settrue_barray: ptr is NULL");
    }
    if (num_bool >= ptr->size) {
        ERROR("settrue_barray: cell is out of bounds");
    }
    uint cell = num_bool / 8;
    uint bit = num_bool % 8;
    ptr->array[cell] |= 1 << bit;
    return;
}

void setfalse_barray(barray *ptr, uint num_bool) {
    if (ptr == NULL) {
        ERROR("setfalse_barray: ptr is NULL");
    }
    if (num_bool >= ptr->size) {
        ERROR("setfalse_barray: cell is out of bounds");
    }
    uint cell = num_bool / 8;
    uint bit = num_bool % 8;
    ptr->array[cell] &= ~(1 << bit);
    return;
}

bool getval_barray(barray *ptr, uint num_bool) {
    if (ptr == NULL) {
        ERROR("getval_barray: ptr is NULL");
    }
    if (num_bool >= ptr->size) {
        ERROR("getval_barray: cell is out of bounds");
    }
    uint cell = num_bool / 8;
    uint bit = num_bool % 8;
    return (ptr->array[cell] & 1 << bit);
}

barray *or_barray(barray *ptr1, barray *ptr2) {
    if (ptr1 == NULL || ptr2 == NULL) {
        ERROR("or_barray: ptr is NULL");
    }
    if (ptr1->size != ptr2->size) {
        return NULL;
    }
    barray *ptr = create_barray(ptr1->size);
    for (uint i = 0; i < ptr->size; i++) {
        ptr->array[i] = ptr1->array[i] | ptr2->array[i];
    }
    return ptr;
}

barray *and_barray(barray *ptr1, barray *ptr2) {
    if (ptr1 == NULL || ptr2 == NULL) {
        ERROR("or_barray: ptr is NULL");
    }
    if (ptr1->size != ptr2->size) {
        return NULL;
    }
    barray *ptr = create_barray(ptr1->size);
    for (uint i = 0; i < ptr->size; i++) {
        ptr->array[i] = ptr1->array[i] & ptr2->array[i];
    }
    return ptr;
}

barray *copy_barray(barray *ptr) {
    if (ptr == NULL) {
        ERROR("copy_barray: ptr is NULL");
    }
    barray *copy = create_barray(ptr->size);
    for (uint i = 0; i < ptr->size_array; i++) {
        copy->array[i] = ptr->array[i];
    }
    return copy;
}