/** \file inverse_attr2.cc
** 1-Jul-2012
** Test inverse attributes; uses a tiny schema similar to a subset of IFC2x3
**
*/
#include "config.h"
#include "cleditor/STEPfile.h"
#include "clstepcore/sdai.h"
#include "clstepcore/STEPattribute.h"
#include "clstepcore/ExpDict.h"
#include "clstepcore/Registry.h"
#include "clutils/errordesc.h"
#include <algorithm>
#include <string>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include "schema.h"

char  * sc_optarg;        // global argument pointer
int sc_optind = 0;     // global argv index

int sc_getopt( int argc, char * argv[], char * optstring ) {
    static char * next = NULL;
    if( sc_optind == 0 ) {
        next = NULL;
    }

    sc_optarg = NULL;

    if( next == NULL || *next == '\0' ) {
        if( sc_optind == 0 ) {
            sc_optind++;
        }

        if( sc_optind >= argc || argv[sc_optind][0] != '-' || argv[sc_optind][1] == '\0' ) {
            sc_optarg = NULL;
            if( sc_optind < argc ) {
                sc_optarg = argv[sc_optind];
            }
            return EOF;
        }

        if( strcmp( argv[sc_optind], "--" ) == 0 ) {
            sc_optind++;
            sc_optarg = NULL;
            if( sc_optind < argc ) {
                sc_optarg = argv[sc_optind];
            }
            return EOF;
        }

        next = argv[sc_optind];
        next++;     // skip past -
        sc_optind++;
    }

    char c = *next++;
    char * cp = strchr( optstring, c );

    if( cp == NULL || c == ':' ) {
        return '?';
    }

    cp++;
    if( *cp == ':' ) {
        if( *next != '\0' ) {
            sc_optarg = next;
            next = NULL;
        } else if( sc_optind < argc ) {
            sc_optarg = argv[sc_optind];
            sc_optind++;
        } else {
            return '?';
        }
    }

    return c;
}
///second way of finding inverse attrs
bool findInverseAttrs2( InverseAItr iai, InstMgr & instList, Registry & reg ) {
    const Inverse_attribute * ia;
    int j = 0;
    while( 0 != ( ia = iai.NextInverse_attribute() ) ) {
        cout << "inverse attr #" << j << ", name: " << ia->Name() << ", inverted attr id: " << ia->inverted_attr_id_()
             << ", from entity: " << ia->inverted_entity_id_() << endl;

        //now find the entity containing the attribute in question
        const EntityDescriptor * inv_ed = reg.FindEntity( ia->inverted_entity_id_() );
        AttrDescItr attr_desc_itr( inv_ed->ExplicitAttr() );
        const AttrDescriptor * attrDesc;
        int k = 0;
        while( 0 != ( attrDesc = attr_desc_itr.NextAttrDesc() ) ) {
            if( !strcmp( ia->inverted_attr_id_(), attrDesc->Name() ) ) {
                cout << "attribute '" << attrDesc->Name() << "' is attribute #" << k
                     << " of '" << inv_ed->Name() << "'." << endl;

                // now go through the instList looking at each instance of
                // entity type 'inv_ed', looking for references to 'ed' in the
                // attribute described by 'attrDesc'
                int l = 0;
                SdaiReldefinesbytype * inst;
                while( 0 != ( inst = ( SdaiReldefinesbytype * ) instList.GetApplication_instance( inv_ed->Name(), l ) ) ) {
                    int i = inst->StepFileId();
                    if( i < l ) {
                        break;
                    }
                    STEPattributeList attrlist = inst->attributes;
                    if( attrlist.list_length() < k + 1 ) {
                        return false;
                    }
                    STEPattribute sa = attrlist[k];
                    if( sa.getADesc()->DomainType()->Type() == SET_TYPE ) {
                        STEPaggregate * aggr = sa.Aggregate();
                        if( !aggr || aggr->is_null() != 0 ) {
                            cout << "findInverseAttrs2 FAILED" << endl;
                            return false;
                        }
                    } else {
                        //something is wrong - it should be an aggregate (specifically, a SET)
                        return false;
                    }
                    l = i;
                }
            }
            k++;
        }
        j++;
    }
    return( j != 0 );
}


int main( int argc, char * argv[] ) {
    Registry  registry( SchemaInit );
    InstMgr   instance_list;
    STEPfile  sfile( registry, instance_list, "", false );
    bool inverseAttrsFound = false;
    if( argc != 2 ) {
        exit( EXIT_FAILURE );
    }
    sfile.ReadExchangeFile( argv[1] );

    if( sfile.Error().severity() <= SEVERITY_INCOMPLETE ) {
        sfile.Error().PrintContents( cout );
        exit( EXIT_FAILURE );
    }
    //find inverse attribute descriptors
    //first, find inverse attrs unique to this entity (i.e. not inherited)
    const EntityDescriptor * ed = registry.FindEntity( "window" );
    InverseAItr iaIter( &( ed->InverseAttr() ) ); //iterator for inverse attributes
    if( findInverseAttrs2( iaIter, instance_list, registry ) ) {
        inverseAttrsFound = true;
    }
    //now, find inherited inverse attrs
    EntityDescItr edi( ed->GetSupertypes() );
    const EntityDescriptor * super;
    while( 0 != ( super = edi.NextEntityDesc() ) ) {
        cout << "supertype " << super->Name() << endl;
        InverseAItr superIaIter( &( super->InverseAttr() ) );
        if( findInverseAttrs2( superIaIter, instance_list, registry ) ) {
            inverseAttrsFound = true;
        }
    }
    if( !inverseAttrsFound ) {
        cout << "no inverse attrs found" << endl;
        exit( EXIT_FAILURE );
    }
    exit( EXIT_SUCCESS );
}