#pragma once

#include "daScript/ast/ast_expressions.h"

#include "daScript/ast/ast_handle.h"

#include "daScript/ast/ast.h"

#include "daScript/misc/hash.h"

#include <optional>

#include <utility>

#ifndef DAS_SERIALIZE_DTAG

#define DAS_SERIALIZE_DTAG 0

#endif

namespace das {

struct SerializationStorage {

};

struct SerializationStorageVector : SerializationStorage {

};

// Composite key for serializer maps. Pairs a raw pointer with a per-

// AstSerializer epoch so reused addresses don't collide with prior entries.

// Hoisted to namespace das so daslang_hash can be specialized before the

// map instantiations inside AstSerializer.

struct SerializeNodeId {

};

template <>

struct daslang_hash<SerializeNodeId, void> {

size_t operator () ( const SerializeNodeId & s ) const noexcept {

const size_t pmix = (reinterpret_cast<size_t>(s.ptr) >> 4)

* size_t(0x9E3779B97F4A7C15ull);

return pmix ^ (s.epoch * size_t(0xBF58476D1CE4E5B9ull));

}

};

struct DAS_API AstSerializer {

~AstSerializer ();

AstSerializer ( SerializationStorage * storage, bool isWriting );

AstSerializer ( const AstSerializer & from ) = delete;

AstSerializer ( AstSerializer && from ) = default;

AstSerializer & operator = ( const AstSerializer & from ) = delete;

AstSerializer & operator = ( AstSerializer && from ) = default;

ModuleLibrary * moduleLibrary = nullptr;

// some passes require module group (it's passed from top-level)

ModuleGroup * thisModuleGroup = nullptr;

Module * thisModule = nullptr;

Module * astModule = nullptr;

bool writing = false;

bool failed = false;

size_t readOffset = 0;

SerializationStorage * buffer = nullptr;

bool seenNewModule = false;

// expression lookup

das_hash_map<uint32_t, Annotation *> rttiHash2Annotation;

// file info clean up

vector<FileInfo*> deleteUponFinish; // these pointers are for builtins (which we don't serialize) and need to be cleaned manually

das_hash_set<FileInfo*> doNotDelete;

// profile data

uint64_t totMacroTime = 0;

// Per-program epoch for SerializeNodeId. Bumped at the start of each

// serialize/deserialize call so reused pointer addresses across program

// boundaries don't collide with prior map entries on this persistent

// serializer. Must be initialized — uninitialized epoch produces garbage

// keys and silent map collisions.

size_t epoch = 0;

// pointers

das_hash_map<SerializeNodeId, ExprBlock*> exprBlockMap;

using DataOffset = uint64_t;

das_hash_map<FileInfo*, DataOffset> writingFileInfoMap;

das_hash_map<DataOffset, FileInfo*> readingFileInfoMap;

das_hash_map<SerializeNodeId, FileAccess*> fileAccessMap;

// smart pointers

das_hash_map<SerializeNodeId, MakeFieldDeclPtr> smartMakeFieldDeclMap;

das_hash_map<SerializeNodeId, EnumerationPtr> smartEnumerationMap;

das_hash_map<SerializeNodeId, StructurePtr> smartStructureMap;

das_hash_map<SerializeNodeId, VariablePtr> smartVariableMap;

das_hash_map<SerializeNodeId, FunctionPtr> smartFunctionMap;

das_hash_map<SerializeNodeId, MakeStructPtr> smartMakeStructMap;

das_hash_map<SerializeNodeId, TypeDeclPtr> smartTypeDeclMap;

// refs

vector<pair<ExprBlock**,SerializeNodeId>> blockRefs;

vector<pair<Function **,SerializeNodeId>> functionRefs;

vector<pair<Variable **,SerializeNodeId>> variableRefs;

vector<pair<Structure **,SerializeNodeId>> structureRefs;

vector<pair<Enumeration **,SerializeNodeId>> enumerationRefs;

// fieldRefs tuple contains: fieldptr, module, structname, fieldname

vector<tuple<Structure::FieldDeclarationRef*, Module *, string, string>> fieldRefs;

// parseModule tuple contains: moduleName, mtime, thisModule, thisModule

vector<tuple<string, uint64_t, ProgramPtr, Module*>> parsedModules;

// tracking for shared modules

das_hash_set<Module *> writingReadyModules;

bool ignoreEmptyExternal = false;

void tag ( const char * name, uint32_t hash );

#if DAS_SERIALIZE_DTAG

__forceinline void dtag ( const char * name, uint32_t hash ) { tag(name,hash); }

#else

__forceinline void dtag ( const char *, uint32_t ) {}

#endif

template<typename T>

void read ( T & data ) { buffer->read(data); }

void read ( void * data, size_t size );

void write ( const void * data, size_t size );

template<typename T>

void serialize ( T & data ) {

}

void serialize ( void * data, size_t size );

void serializeAdaptiveSize64 ( uint64_t & size );

void serializeAdaptiveSize32 ( uint32_t & size );

void collectFileInfo ( vector<FileInfoPtr> & orphanedFileInfos );

void getCompiledModules ( );

void patch ();

AstSerializer & operator << ( string & str );

AstSerializer & operator << ( const char * & value );

AstSerializer & operator << ( bool & value ) { serialize(value); return *this; }

AstSerializer & operator << ( vec4f & value ) { serialize(value); return *this; }

AstSerializer & operator << ( float & value ) { serialize(value); return *this; }

AstSerializer & operator << ( void * & value ) { serialize(value); return *this; }

AstSerializer & operator << ( uint8_t & value ) { serialize(value); return *this; }

AstSerializer & operator << ( int32_t & value ) { serialize(value); return *this; }

AstSerializer & operator << ( int64_t & value ) { serialize(value); return *this; }

AstSerializer & operator << ( uint16_t & value ) { serialize(value); return *this; }

AstSerializer & operator << ( uint32_t & value ) { serialize(value); return *this; }

AstSerializer & operator << ( uint64_t & value ) { serialize(value); return *this; }

AstSerializer & operator << ( pair<uint32_t,uint32_t> & value ) { serialize(value); return *this; }

AstSerializer & operator << ( pair<uint64_t,uint64_t> & value ) { serialize(value); return *this; }

AstSerializer & operator << ( pair<string,bool> & value ) { *this << value.first << value.second; return *this; }

AstSerializer & operator << ( tuple<Module *, string, string, bool, LineInfo> & value );

AstSerializer & operator << ( CodeOfPolicies & ser );

AstSerializer & operator << ( TypeDeclPtr & type );

AstSerializer & operator << ( AnnotationArgument & arg );

AstSerializer & operator << ( AnnotationDeclarationPtr & annotation_decl );

AstSerializer & operator << ( AnnotationPtr & anno );

AstSerializer & operator << ( Structure::FieldDeclaration & field_declaration );

AstSerializer & operator << ( ExpressionPtr & expr );

AstSerializer & operator << ( FunctionPtr & func );

AstSerializer & operator << ( Type & baseType );

AstSerializer & operator << ( LineInfo & at );

AstSerializer & operator << ( Module * & module );

AstSerializer & operator << ( FileInfo * & info );

AstSerializer & operator << ( FileInfoPtr & ptr );

AstSerializer & operator << ( FileAccessPtr & ptr );

AstSerializer & operator << ( StructurePtr & struct_ );

AstSerializer & operator << ( EnumerationPtr & enum_type );

AstSerializer & operator << ( Enumeration::EnumEntry & entry );

AstSerializer & operator << ( TypeAnnotationPtr & type_anno );

AstSerializer & operator << ( VariablePtr & var );

AstSerializer & operator << ( Function::AliasInfo & alias_info );

AstSerializer & operator << ( InferHistory & history );

AstSerializer & operator << ( ReaderMacroPtr & ptr );

AstSerializer & operator << ( TypeInfoMacro * & ptr );

AstSerializer & operator << ( ExprBlock * & block );

AstSerializer & operator << ( CallMacro * & ptr );

AstSerializer & operator << ( CaptureEntry & entry );

AstSerializer & operator << ( MakeFieldDeclPtr & ptr );

AstSerializer & operator << ( MakeStructPtr & ptr );

AstSerializer & operator << ( SerializeNodeId & value );

// Top-level

AstSerializer & operator << ( Module & module );

AstSerializer & serializeModule ( Module & module, bool already_exists );

uint32_t getVersion ();

void serializeProgram ( ProgramPtr program, ModuleGroup & libGroup ) noexcept;

bool serializeScript ( ProgramPtr program ) noexcept;

template <uint64_t n>

AstSerializer& operator << ( int (&value)[n] ) {

serialize(value, n * sizeof(int)); return *this;

}

___noinline bool trySerialize ( const callable<void(AstSerializer&)> &cb ) noexcept;

template <typename TT>

AstSerializer & operator << ( vector<TT> & value ) {

dtag("Vector",hash_tag("Vector"));

if ( writing ) {

uint64_t size = value.size();

serializeAdaptiveSize64(size);

} else {

uint64_t size = 0;

serializeAdaptiveSize64(size);

value.resize(size);

}

for ( TT & v : value ) {

*this << v;

}

return *this;

}

template <typename K, typename V, typename H, typename E>

void serialize_hash_map ( das_hash_map<K, V, H, E> & value );

template <typename K, typename V, typename H, typename E>

AstSerializer & operator << ( das_hash_map<K, V, H, E> & value );

template <typename V>

AstSerializer & operator << ( safebox_map<V> & box );

template <typename V, typename VT>

AstSerializer & operator << ( safebox<V,VT> & box );

template<typename TT>

AstSerializer & serializePointer ( TT * & ptr );

bool isInThisModule ( Function * & ptr );

bool isInThisModule ( Enumeration * & ptr );

bool isInThisModule ( Structure * & ptr );

bool isInThisModule ( Variable * & ptr );

bool isInThisModule ( TypeInfoMacro * & ptr );

void writeIdentifications ( Function * & func );

void writeIdentifications ( Enumeration * & ptr );

void writeIdentifications ( Structure * & ptr );

void writeIdentifications ( Variable * & ptr );

void writeIdentifications ( TypeInfoMacro * & ptr );

void fillOrPatchLater ( Function * & func, SerializeNodeId id );

void fillOrPatchLater ( Enumeration * & ptr, SerializeNodeId id );

void fillOrPatchLater ( Structure * & ptr, SerializeNodeId id );

void fillOrPatchLater ( Variable * & ptr, SerializeNodeId id );

auto readModuleAndName () -> pair<Module *, string>;

auto readModuleAndNameHash () -> pair<Module *, uint64_t>;

void findExternal ( Function * & func );

void findExternal ( Enumeration * & ptr );

void findExternal ( Structure * & ptr );

void findExternal ( Variable * & ptr );

void findExternal ( TypeInfoMacro * & ptr );

SerializeNodeId getSerializeId(void *ptr) { return {ptr, epoch}; }

template <typename EnumType>

void serialize_small_enum ( EnumType & baseType ) {

}

template <typename EnumType>

void serialize_enum ( EnumType & baseType ) {

}

};

// Opaque handle to expose serializer to daslang.

struct AstSerializerState {

unique_ptr<SerializationStorageVector> storage;

unique_ptr<AstSerializer> serializer;

};

// Create a writing serializer.

AstSerializerState * rtti_create_ast_serializer ();

// Create a reading serializer from a blob.

AstSerializerState * rtti_create_ast_deserializer ( const TArray<uint8_t> & data );

// Delete a serializer state.

void rtti_delete_ast_serializer ( AstSerializerState * state );

// Serialize one program (writing mode). Returns false on failure.

bool rtti_ast_serializer_serialize_program (

AstSerializerState * state,

const smart_ptr<Program> & program );

// Deserialize one program (reading mode).

void rtti_ast_serializer_deserialize_program (

AstSerializerState * state,

const TBlock<void,bool,smart_ptr<Program>,const string> & block,

Context * context, LineInfoArg * at );

// Get serialized data from a writing serializer.

void rtti_ast_serializer_get_data (

AstSerializerState * state,

const TBlock<void,TTemporary<TArray<uint8_t> const>> & block,

Context * context, LineInfoArg * at );

}