RULE_SER

#ifndef SAD_TEST_RULE_SERIALIZATION_H
#define SAD_TEST_RULE_SERIALIZATION_H

#include "../rule_representation/rule.h"
#include "../util/sad_stdlib.h"
#include "../util/sad_stdint.h"



//TODO document
typedef struct _sad_rule_serialization_result {
    char *data;
    unsigned int size;
} sad_rule_serialization_result;


//TODO fill
//TODO document
typedef struct _sad_rule_deserialization_result {

} sad_rule_deserialization_result;


//TODO document
typedef struct _sad_attribute_collection {
    unsigned int numAttributes;
    sad_rule_attribute_generic** attributes;
} sad_attribute_collection;


//TODO document
typedef struct _sad_condition_collection {
    unsigned int numConditions;
    sad_rule_condition_generic** conditions;
} sad_condition_collection;


//TODO document
//TODO move to .c file
unsigned int sad_count_attributes(sad_rule* rule) {
    int i;
    unsigned int numAttributes=0;
    sad_rule_condition_allowedmatches* cond;

    numAttributes += rule->numAttributes;

    //Count attributes in all sad_rule_condition_allowedmatches structs
    for(i=0; i<rule->numConditions; ++i) {
        if(rule->conditions[i]->type==ALLOWED_MATCHES) {
            cond = (sad_rule_condition_allowedmatches*) rule->conditions[i];
            if(cond==0) {
                continue;
            }
            numAttributes+=cond->numAttributes;
        }
    }

    return numAttributes;
}


//TODO document
//TODO move to .c file
int sad_copy_attribute_pointers(sad_rule* rule, _sad_attribute_collection* collection) {
    int i, j;
    unsigned int attrArrayPointer = 0; /* Indicates where to store next attribute in collection array */
    sad_rule_condition_allowedmatches* cond;

    for(i=0; i<rule->numAttributes; ++i) { /* Copy attribute pointers from rule struct to collection */
        if(attrArrayPointer>collection->numAttributes) {
            return -1;
        }
        collection->attributes[attrArrayPointer] = rule->attributes[i];
        attrArrayPointer++;
    }

    for(i=0; i<rule->numConditions; ++i) {
        if(rule->conditions[i]->type==ALLOWED_MATCHES) {
            cond = (sad_rule_condition_allowedmatches*) rule->conditions[i];
            if(cond==0) {
                continue;
            }
            for(j=0; j<cond->numAttributes; ++j) { /* Copy attribute pointers from condition to collection */
                if(attrArrayPointer>collection->numAttributes) {
                    return -1;
                }
                collection->attributes[attrArrayPointer] = cond->attributes[j];
                attrArrayPointer++;
            }
        }
    }

    return 0;
}


//TODO document
//TODO move to .c file
int sad_copy_condition_pointers(sad_rule* rule, sad_condition_collection* collection) {
    int i;
    for(i=0; i<rule->numConditions; ++i) {
        collection->conditions[i] = rule->conditions[i];
    }

    return 0;
}


//TODO document
//TODO move to .c file
int sad_collect_attributes(sad_rule* rule, sad_attribute_collection* collection) {
    collection->numAttributes = sad_count_attributes(rule);
    collection->attributes = SAD_MALLOC(sizeof(sad_rule_attribute_generic)*collection->numAttributes);
    return sad_copy_attribute_pointers(rule, collection);
}


//TODO document
//TODO move to .c file
int sad_collect_conditions(sad_rule* rule, sad_condition_collection* collection) {
    collection->numConditions = rule->numConditions;
    collection->conditions = SAD_MALLOC(sizeof(sad_rule_condition_generic)*collection->numConditions);
    return sad_copy_condition_pointers(rule, collection);
}


//TODO document
//TODO move to .c file
unsigned int sad_get_attribute_size(sad_rule_attribute_generic* attr) {
    if(attr==0) {
        return sizeof(sad_rule_attribute_generic);
    }
    switch (attr->type) {
        case HASH:
        case PARENT_HASH:
            return sizeof(sad_rule_attribute_hash);
        case NAME:
            return sizeof(sad_rule_attribute_name);
        case VENDOR:
            return sizeof(sad_rule_attribute_vendor);
        case SERIAL:
            return sizeof(sad_rule_attribute_serial);
        case VIAPORT:
            return sizeof(sad_rule_attribute_viaport);
        case WITHINTERFACE:
            return sizeof(sad_rule_attribute_withinterface);
        default:
            return sizeof(sad_rule_attribute_generic);
    }
}


//TODO implement
//TODO document
//TODO move to .c file
unsigned int sad_get_condition_size(sad_rule_condition_generic* cond) {
    if(cond==0) {
        return sizeof(sad_rule_condition_generic);
    }
    switch (cond->type) {
        case LOCALTIME:
            return sizeof(sad_rule_condition_localtime);
        case ALLOWED_MATCHES:
            return sizeof(sad_rule_condition_allowedmatches);
        case RULE_APPLIED:
        case RULE_APPLIED_TIME:
        case RULE_EVALUATED:
        case RULE_EVALUATED_TIME:
            return sizeof(sad_rule_condition_applied);
        case TRUE:
        case FALSE:
            return sizeof(sad_rule_condition_bool);
        default:
            return sizeof(sad_rule_condition_generic);
    }
}


//TODO document
//TODO move to .c file
unsigned int sad_get_size_of_attributes(unsigned int numAttributes, sad_rule_attribute_generic* attributes) {
    unsigned int totalSize=0;
    int i;
    for(i=0; i<numAttributes; ++i) {
        totalSize += sad_get_attribute_size(attributes[i]);
    }
    return totalSize;
}


//TODO document
//TODO move to .c file
unsigned int sad_get_size_of_conditions(unsigned int numConditions, sad_rule_condition_generic* conditions) {
    unsigned int totalSize=0;
    int i;
    for(i=0; i<numConditions; ++i) {
        totalSize += sad_get_condition_size(conditions[i]);
    }
    return totalSize;
}

//TODO document
//TODO move to .c file
unsigned int sad_get_amount_attr_collections(sad_rule* rule) {
    int i;
    unsigned int numAttrCollections=1; /* 1 for the sad_rule_struct attributes */

    for(i=0; i<rule->numConditions; ++i) {
        if(rule->conditions[i]->type==ALLOWED_MATCHES) {
            numAttrCollections++;
        }
    }

    return numAttrCollections;
}

//TODO document
//TODO move to .c file
unsigned int sad_get_amount_cond_collections(sad_rule* rule) {
    int i;
    unsigned int numCondCollections=0;

    for(i=0; i<rule->numConditions; ++i) {
        if(rule->conditions[i]->type==ALLOWED_MATCHES) {
            numCondCollections++;
        }
    }

    return numCondCollections;
}

//TODO document
//TODO move to .c file
int sad_lookup_attr_index(sad_attribute_collection* coll, sad_rule_attribute_generic* attr) {
    int i;
    sad_rule_attribute_generic* currAttr;
    for(i=0; i<coll->numAttributes; ++i) {
        currAttr = coll->attributes[i];
        if(currAttr == attr) {
            return i;
        }
    }

    return -1;
}

//TODO document
//TODO move to .c file
int sad_lookup_cond_index(sad_condition_collection* coll, sad_rule_condition_generic* cond) {
    int i;
    sad_rule_condition_generic* currCond;
    for(i=0; i<coll->numConditions; ++i) {
        currCond = coll->conditions[i];
        if(currCond == cond) {
            return i;
        }
    }

    return -1;
}

//TODO implement
//TODO document
//TODO move to .c file
void sad_make_attr_reference_collections(sad_rule* rule, sad_attribute_collection* srcCollection, sad_attribute_collection* destCollections) {
    int i;
    int j;
    int attrIndex;
    int collIndex=0;
    sad_rule_condition_allowedmatches* cond;
    sad_attribute_collection* coll = destCollections;

    coll[collIndex].numAttributes = (uint8_t)rule->numAttributes;
    coll[collIndex].attributes = SAD_MALLOC(sizeof(sad_rule_attribute_generic*)*coll[collIndex].numAttributes);
    for(i=0; i<rule->numAttributes; ++i) {
        attrIndex = sad_lookup_attr_index(srcCollection, rule->attributes[i]);
        coll[collIndex].attributes[i] = (sad_rule_attribute_generic*)((void*)index);
    }

    for(i=0; i<rule->numConditions; ++i) {
        if(rule->conditions[i]->type==ALLOWED_MATCHES) {
            collIndex++;
            cond = (sad_rule_condition_allowedmatches*)rule->conditions[i];
            coll[collIndex].numAttributes = cond->numAttributes;
            coll[collIndex].attributes = SAD_MALLOC(sizeof(sad_rule_attribute_generic*)*coll[collIndex].numAttributes);
            for(j=0; j<cond->numAttributes; ++j) {
                attrIndex = sad_lookup_attr_index(srcCollection, cond->attributes[j]);
                coll[collIndex].attributes[j] = (sad_rule_attribute_generic*)((void*)index);
            }
        }
    }
}

//TODO implement
//TODO document
//TODO move to .c file
void sad_make_cond_reference_collections(sad_rule* rule, sad_condition_collection* srcCollection, sad_attribute_collection* destCollections) {
    int i=0;
    sad_condition_collection* coll;

    coll[]
}

//TODO implement
//TODO document
//TODO move to .c file
sad_rule_serialization_result sad_serialize_rule(sad_rule* rule) {
    sad_rule_serialization_result serialized;
    sad_rule ruleCopy;
    sad_attribute_collection ruleAttrColl;
    sad_condition_collection ruleCondColl;

    /* temp variables */
    /* may resemble the serialized packet */
    unsigned int packetSize;
    unsigned int attrCollectionSize;
    unsigned int condCollectionSize;
    sad_attribute_collection attrColl;
    sad_condition_collection condColl;
    unsigned int numAttributeCollections;
    sad_attribute_collection* attributeCollections;
    unsigned int numConditionCollections;
    sad_condition_collection* conditionCollections;

    serialized.data = 0;
    serialized.size = 0;

    ruleCopy = *rule;

    /* Fill packet fields */
    sad_collect_attributes(&ruleCopy, &ruleAttrColl);
    sad_collect_conditions(&ruleCopy, &ruleCondColl);
    attrCollectionSize = sad_get_size_of_attributes(attrColl.numAttributes, attrColl.attributes);
    condCollectionSize = sad_get_size_of_conditions(condColl.numConditions, condColl.conditions);
    numAttributeCollections = sad_get_amount_attr_collections(&ruleCopy);
    numConditionCollections = sad_get_amount_cond_collections(&ruleCopy);
    attributeCollections = SAD_MALLOC(sizeof(sad_attribute_collection)*numAttributeCollections);
    conditionCollections = SAD_MALLOC(sizeof(sad_condition_collection)*numConditionCollections);
    sad_make_attr_reference_collections(&ruleCopy, attrColl, attributeCollections);
    sad_make_cond_reference_collections(&ruleCopy, condColl, conditionCollections);


    SAD_FREE(attributeCollections);
    SAD_FREE(conditionCollections);
}

//Should this just use sad_rule as a return type?
sad_rule_deserialization_result sad_deserialize_rule(sad_rule_serialization_result serialized) {
    //TODO implement
}

#endif //SAD_TEST_RULE_SERIALIZATION_H