#define SC_CORE_EXPORT

#define SC_DAI_EXPORT

#include <algorithm>

#include <set>

#include <string>

#include <assert.h>

#include "Registry.h"

#include "sdaiApplication_instance.h"

#include "read_func.h"

#include "SdaiSchemaInit.h"

#include "STEPcomplex.h"

#include "sectionReader.h"

#include "lazyFileReader.h"

#include "lazyInstMgr.h"

#include "lazyTypes.h"

#include "instMgrHelper.h"

#include "current_function.hpp"

sectionReader::sectionReader( lazyFileReader * parent, std::ifstream & file, std::streampos start, sectionID sid ):

_lazyFile( parent ), _file( file ), _sectionStart( start ), _sectionID( sid ) {

_fileID = _lazyFile->ID();

}

std::streampos sectionReader::findNormalString( const std::string & str, bool semicolon ) {

}

const char * sectionReader::getDelimitedKeyword( const char * delimiters ) {

static std::string str;

char c;

str.clear();

str.reserve( 100 );

skipWS();

while( c = _file.get(), _file.good() ) {

if( c == '-' || c == '_' || isupper( c ) || isdigit( c ) ||

( c == '!' && str.length() == 0 ) ) {

str.append( 1, c );

} else if( ( c == '/' ) && ( _file.peek() == '*' ) && ( str.length() == 0 ) ) {

//push past comment

findNormalString( "*/" );

skipWS();

continue;

} else {

_file.putback( c );

break;

}

}

c = _file.peek();

if( !strchr( delimiters, c ) ) {

std::cerr << SC_CURRENT_FUNCTION << ": missing delimiter. Found " << c << ", expected one of " << delimiters << " at end of keyword " << str << ". File offset: " << _file.tellg() << std::endl;

abort();

}

return str.c_str();

}

std::streampos sectionReader::seekInstanceEnd( instanceRefs ** refs ) {

}

void sectionReader::locateAllInstances() {

}

instanceID sectionReader::readInstanceNumber() {

}

SDAI_Application_instance * sectionReader::getRealInstance( const Registry * reg, long int begin, instanceID instance,

const std::string & typeName, const std::string & schName, bool header ) {

char c;

const char * tName = 0, * sName = 0; //these are necessary since typeName and schName are const

std::string comment;

Severity sev;

SDAI_Application_instance * inst = 0;

tName = typeName.c_str();

if( schName.size() > 0 ) {

sName = schName.c_str();

} else if( !header ) {

SdaiFile_schema * fs = dynamic_cast< SdaiFile_schema * >( _lazyFile->getHeaderInstances()->find( 3 ) );

if( fs ) {

StringNode * sn = ( StringNode * ) fs->schema_identifiers_()->GetHead();

if( sn ) {

sName = sn->value.c_str();

if( sn->NextNode() ) {

std::cerr << "Warning - multiple schema names found. Only searching with first one." << std::endl;

}

}

} else {

std::cerr << "Warning - no schema names found; the file is probably invalid. Looking for typeName in any loaded schema." << std::endl;

}

}

_file.seekg( begin );

skipWS();

ReadTokenSeparator( _file, &comment );

if( !header ) {

findNormalString( "=" );

}

skipWS();

ReadTokenSeparator( _file, &comment );

c = _file.peek();

switch( c ) {

case '&':

std::cerr << "Can't handle scope instances. Skipping #" << instance << ", offset " << _file.tellg() << std::endl;

// sev = CreateScopeInstances( in, &scopelist );

break;

case '(':

inst = CreateSubSuperInstance( reg, instance, sev );

break;

case '!':

std::cerr << "Can't handle user-defined instances. Skipping #" << instance << ", offset " << _file.tellg() << std::endl;

break;

default:

if( ( !header ) && ( typeName.size() == 0 ) ) {

tName = getDelimitedKeyword( ";( /\\" );

}

inst = reg->ObjCreate( tName, sName );

break;

}

if( inst != & NilSTEPentity ) {

if( !comment.empty() ) {

inst->AddP21Comment( comment );

}

assert( inst->eDesc );

_file.seekg( begin );

findNormalString( "(" );

_file.unget();

//TODO do something with 'sev'

sev = inst->STEPread( instance, 0, _lazyFile->getInstMgr()->getAdapter(), _file, sName, true, false );

}

return inst;

}

STEPcomplex * sectionReader::CreateSubSuperInstance( const Registry * reg, instanceID fileid, Severity & sev ) {

std::string buf;

ErrorDescriptor err;

std::vector<std::string *> typeNames;

_file.get(); //move past the first '('

while( _file.good() && ( _file.peek() != ')' ) ) {

typeNames.push_back( new std::string( getDelimitedKeyword( ";( /\\" ) ) );

if( typeNames.back()->empty() ) {

delete typeNames.back();

typeNames.pop_back();

} else {

SkipSimpleRecord( _file, buf, &err ); //exactly what does this do? if it doesn't count parenthesis, it probably should

buf.clear();

}

skipWS();

if( _file.peek() != ')' ) {

// do something

}

}

// STEPComplex needs an array of strings or of char*. construct the latter using c_str() on all strings in the vector

//FIXME: STEPComplex ctor should accept std::vector<std::string *> ?

const int s = typeNames.size();

const char ** names = new const char * [ s + 1 ];

names[ s ] = 0;

for( int i = 0; i < s; i++ ) {

names[ i ] = typeNames[i]->c_str();

}

//TODO still need the schema name

return new STEPcomplex( ( const_cast<Registry *>( reg ) ), ( const char ** ) names, ( int ) fileid /*, schnm*/ );

}