#ifndef SCHEMAINIT_H
#define SCHEMAINIT_H

#include <stddef.h>

#include "sc_export.h"
#include "clstepcore/attrDescriptor.h"
#include "clstepcore/aggrTypeDescriptor.h"
#include "clstepcore/dictSchema.h"
#include "clstepcore/entityDescriptor.h"
#include "clstepcore/enumTypeDescriptor.h"
#include "clstepcore/selectTypeDescriptor.h"
#include "clstepcore/schemaModule.h"

class Derived_attribute;
class Inverse_attribute;
class ComplexCollect;
class Registry;

/** Compact records used by API v2 generated schema initialization. */
struct SC_CORE_EXPORT SchemaInitRecord {
    Schema ** slot;
    const char * name;
    ModelContentsCreator modelContentsCreator;
};

struct SC_CORE_EXPORT EntityDescriptorInitRecord {
    EntityDescriptor ** slot;
    const char * name;
    Schema ** schemaSlot;
    Logical abstractEntity;
    Logical externalMapping;
    Creator creator;
};

struct SC_CORE_EXPORT EntitySupertypeInitRecord {
    EntityDescriptor * supertype;
};

enum TypeDescriptorInitKind {
    TypeDescriptorInit_Base,
    TypeDescriptorInit_Enum,
    TypeDescriptorInit_Select,
    TypeDescriptorInit_Aggregate,
    TypeDescriptorInit_Array,
    TypeDescriptorInit_List,
    TypeDescriptorInit_Set,
    TypeDescriptorInit_Bag
};

struct SC_CORE_EXPORT TypeDescriptorInitRecord {
    void * slot;
    TypeDescriptorInitKind kind;
    const char * name;
    PrimitiveType fundamentalType;
    Schema ** schemaSlot;
    const char * description;
    int uniqueElements;
    SelectCreator selectCreator;
    EnumCreator enumCreator;
    AggregateCreator aggregateCreator;

    TypeDescriptorInitRecord( TypeDescriptor ** descriptorSlot,
                              const char * typeName, PrimitiveType type,
                              Schema ** schema, const char * typeDescription );
    TypeDescriptorInitRecord( EnumTypeDescriptor ** descriptorSlot,
                              const char * typeName, PrimitiveType type,
                              Schema ** schema, const char * typeDescription,
                              EnumCreator creator );
    TypeDescriptorInitRecord( SelectTypeDescriptor ** descriptorSlot,
                              int unique, const char * typeName,
                              PrimitiveType type, Schema ** schema,
                              const char * typeDescription,
                              SelectCreator creator );
    TypeDescriptorInitRecord( AggrTypeDescriptor ** descriptorSlot,
                              const char * typeName, PrimitiveType type,
                              Schema ** schema, const char * typeDescription,
                              AggregateCreator creator );
    TypeDescriptorInitRecord( ArrayTypeDescriptor ** descriptorSlot,
                              const char * typeName, PrimitiveType type,
                              Schema ** schema, const char * typeDescription,
                              AggregateCreator creator );
    TypeDescriptorInitRecord( ListTypeDescriptor ** descriptorSlot,
                              const char * typeName, PrimitiveType type,
                              Schema ** schema, const char * typeDescription,
                              AggregateCreator creator );
    TypeDescriptorInitRecord( SetTypeDescriptor ** descriptorSlot,
                              const char * typeName, PrimitiveType type,
                              Schema ** schema, const char * typeDescription,
                              AggregateCreator creator );
    TypeDescriptorInitRecord( BagTypeDescriptor ** descriptorSlot,
                              const char * typeName, PrimitiveType type,
                              Schema ** schema, const char * typeDescription,
                              AggregateCreator creator );
};

/**
 * Attribute descriptor record.  The overloaded constructors preserve the
 * concrete type of generated descriptor slots without templates or casts in
 * generated translation units.
 */
struct SC_CORE_EXPORT AttributeInitRecord {
    AttrDescriptor ** attributeSlot;
    Derived_attribute ** derivedSlot;
    Inverse_attribute ** inverseSlot;
    const char * name;
    const TypeDescriptor * domain;
    Logical optional;
    Logical unique;
    AttrType_Enum attrType;
    const char * initializer;
    const char * invertedAttribute;
    const char * invertedEntity;

    AttributeInitRecord( AttrDescriptor ** slot, const char * attrName,
                         const TypeDescriptor * domainType, Logical isOptional,
                         Logical isUnique, AttrType_Enum type,
                         const char * init = 0 );
    AttributeInitRecord( Derived_attribute ** slot, const char * attrName,
                         const TypeDescriptor * domainType, Logical isOptional,
                         Logical isUnique, AttrType_Enum type,
                         const char * init = 0 );
    AttributeInitRecord( Inverse_attribute ** slot, const char * attrName,
                         const TypeDescriptor * domainType, Logical isOptional,
                         Logical isUnique, const char * invertedAttr,
                         const char * invertedEnt );
};

enum ComplexNodeInitKind {
    ComplexNodeInit_Simple,
    ComplexNodeInit_And,
    ComplexNodeInit_Or,
    ComplexNodeInit_AndOr
};

struct SC_CORE_EXPORT ComplexNodeInitRecord {
    ComplexNodeInitKind kind;
    const char * name;
    size_t firstChild;
    size_t nextSibling;
};

struct SC_CORE_EXPORT ComplexListInitRecord {
    size_t rootNode;
};

struct SC_CORE_EXPORT GlobalRuleInitRecord {
    const char * name;
    const char * text;
};

enum SchemaImageDescriptorRefKind {
    SchemaImageRef_None,
    SchemaImageRef_Entity,
    SchemaImageRef_Type,
    SchemaImageRef_Builtin,
    SchemaImageRef_Aggregate
};

struct SC_CORE_EXPORT SchemaImageDescriptorRef {
    uint32_t kind;
    uint32_t schema;
    uint32_t index;
};

struct SC_CORE_EXPORT SchemaImageSchemaRecord {
    uint32_t name;
    uint32_t firstEntity;
    uint32_t entityCount;
    uint32_t firstType;
    uint32_t typeCount;
};

struct SC_CORE_EXPORT SchemaImageEntityRecord {
    uint32_t schema;
    uint32_t name;
    uint32_t flags;
    uint32_t supertypeStatement;
    uint32_t firstSupertype;
    uint32_t supertypeCount;
    uint32_t firstAttribute;
    uint32_t attributeCount;
    uint32_t firstWhereRule;
    uint32_t whereRuleCount;
    uint32_t firstUniqueRule;
    uint32_t uniqueRuleCount;
};

enum SchemaImageEntityFlags {
    SchemaImageEntity_Abstract = 1u << 0,
    SchemaImageEntity_ExternalMapping = 1u << 1
};

struct SC_CORE_EXPORT SchemaImageTypeRecord {
    uint32_t schema;
    uint32_t name;
    uint32_t description;
    uint32_t fundamentalType;
    uint32_t descriptorKind;
    int32_t uniqueElements;
    SchemaImageDescriptorRef referent;
    uint32_t aggregate;
    uint32_t firstSelectElement;
    uint32_t selectElementCount;
    uint32_t firstWhereRule;
    uint32_t whereRuleCount;
    uint32_t firstEnumElement;
    uint32_t enumElementCount;
};

struct SC_CORE_EXPORT SchemaImageAttributeRecord {
    uint32_t name;
    SchemaImageDescriptorRef domain;
    uint32_t optional;
    uint32_t unique;
    uint32_t attrType;
    uint32_t initializer;
    uint32_t invertedAttribute;
    uint32_t invertedEntity;
};

struct SC_CORE_EXPORT SchemaImageAggregateRecord {
    uint32_t schema;
    uint32_t description;
    uint32_t fundamentalType;
    SchemaImageDescriptorRef referent;
    uint32_t bound1Type;
    int32_t bound1;
    uint32_t bound1Text;
    uint32_t bound2Type;
    int32_t bound2;
    uint32_t bound2Text;
    uint32_t optionalElements;
    uint32_t uniqueElements;
};

struct SC_CORE_EXPORT SchemaImageRuleRecord {
    uint32_t text;
};

enum SchemaImageSchemaTextKind {
    SchemaImageText_GlobalRule,
    SchemaImageText_Function,
    SchemaImageText_Procedure
};

struct SC_CORE_EXPORT SchemaImageSchemaTextRecord {
    uint32_t schema;
    uint32_t kind;
    uint32_t name;
    uint32_t text;
};

struct SC_CORE_EXPORT SchemaImageRenameRecord {
    SchemaImageDescriptorRef descriptor;
    uint32_t schema;
    uint32_t name;
};

struct SC_CORE_EXPORT SchemaImageSchemaBinding {
    Schema ** schemaSlot;
    ModelContentsCreator modelContentsCreator;
    SchemaModule * module;
};

struct SC_CORE_EXPORT SchemaImageTypeBinding {
    void * slot;
    SelectCreator selectCreator;
    EnumCreator enumCreator;
    AggregateCreator aggregateCreator;
};

enum SchemaLoadError {
    SchemaLoad_Ok,
    SchemaLoad_UnsupportedVersion,
    SchemaLoad_TruncatedImage,
    SchemaLoad_InvalidOffset,
    SchemaLoad_InvalidString,
    SchemaLoad_InvalidReference,
    SchemaLoad_CountMismatch,
    SchemaLoad_MissingBinding,
    SchemaLoad_ModuleFailure
};

struct SC_CORE_EXPORT SchemaLoadResult {
    SchemaLoadError error;
    uint32_t record;

    bool Succeeded() const {
        return error == SchemaLoad_Ok;
    }
    const char * Message() const;
};

SC_CORE_EXPORT SchemaLoadResult InitializeSchemaFromImage(
    Registry & registry, const SchemaModuleImage & image,
    const SchemaImageSchemaBinding * schemaBindings,
    size_t schemaBindingCount,
    const SchemaImageTypeBinding * typeBindings,
    size_t typeBindingCount, SchemaLoadContext & context );

enum PackedComplexImageVersion {
    PackedComplexImageVersion_1 = 1
};

struct SC_CORE_EXPORT PackedComplexImage {
    uint32_t version;
    uint32_t byteSize;
    uint32_t stringOffset;
    uint32_t stringBytes;
    uint32_t nodeOffset;
    uint32_t nodeCount;
    uint32_t listOffset;
    uint32_t listCount;
};

struct SC_CORE_EXPORT PackedComplexNode {
    uint32_t kind;
    uint32_t name;
    uint32_t firstChild;
    uint32_t nextSibling;
};

struct SC_CORE_EXPORT PackedComplexList {
    uint32_t rootNode;
};

SC_CORE_EXPORT ComplexCollect * InitializePackedComplexSupport(
    const PackedComplexImage & image, SchemaLoadResult * result = 0 );

SC_CORE_EXPORT void InitializeSchemas( Registry & reg,
                                       const SchemaInitRecord * records,
                                       size_t count );
SC_CORE_EXPORT void InitializeSchemaModuleImages(
    const SchemaInitRecord * records, size_t count );
SC_CORE_EXPORT void InitializeEntityDescriptors(
    const EntityDescriptorInitRecord * records, size_t count );
SC_CORE_EXPORT void InitializeTypeDescriptors(
    const TypeDescriptorInitRecord * records, size_t count );
SC_CORE_EXPORT void InitializeTypeMetadata(
    Registry & reg, Schema & schema, TypeDescriptor & type,
    const TypeDescriptor * referent,
    const TypeDescriptor * const * selectElements, size_t selectElementCount );
SC_CORE_EXPORT void InitializeEntityMetadata(
    Registry & reg, EntityDescriptor & entity, Schema & schema,
    const EntitySupertypeInitRecord * supertypes, size_t supertypeCount,
    const AttributeInitRecord * attributes, size_t attributeCount );
SC_CORE_EXPORT void InitializeWhereRules(
    TypeDescriptor & owner, const char * const * rules, size_t count );
SC_CORE_EXPORT void InitializeUniquenessRules(
    EntityDescriptor & owner, const char * const * rules, size_t count );
SC_CORE_EXPORT void InitializeGlobalRules(
    Schema & schema, const GlobalRuleInitRecord * rules, size_t count );
SC_CORE_EXPORT void InitializeFunctions(
    Schema & schema, const char * const * functions, size_t count );
SC_CORE_EXPORT void InitializeProcedures(
    Schema & schema, const char * const * procedures, size_t count );
SC_CORE_EXPORT ComplexCollect * InitializeComplexSupport(
    const ComplexNodeInitRecord * nodes, size_t nodeCount,
    const ComplexListInitRecord * lists, size_t listCount );

#endif