class ogMapFile;

class ogMapEntity {
    friend class ogMapFile;
public:
    og::Dict epairs;

public:
    ogMapEntity() { }

    static ogMapEntity *Parse( og::Lexer &source );

//  bool Write( og::File *file ) const;
};

ogMapEntity *ogMapEntity::Parse( og::Lexer &source ) {
    ogMapEntity *ent;

    try {
        const og::Token *tok;
        const char *p;

        if( !( tok = source.ReadToken() ) ) {
            return NULL;
        }

        p = tok->GetString();

        if( strcmp( p, "{" ) ) {
            source.Error( og::Format( "MapEntity::Parse: '{' not found, found '$*'" ) << p );
            return NULL;
        }

        ent = new ogMapEntity();

        do {
            if( !( tok = source.ReadToken() ) ) {
                source.Error( "MapEntity::Parse: unexpected EOF" );
                return NULL;
            }

            p = tok->GetString();

            if ( !strcmp( p, "}" ) ) {
                break;
            }

            if ( !strcmp( p, "{" ) ) {
                // skip brush ent data
                source.FindToken("}");
            }
            else {
                // parse key/value pairs
                og::String key, value;

                key = p;
                if( !( tok = source.ReadToken() ) ) {
                    source.Error( "MapEntity::Parse: unexpected EOL or EOF before value" );
                    return NULL;
                }
                p = tok->GetString();
                value = p;

                key.StripTrailingWhitespaces();
                value.StripTrailingWhitespaces();

                ent->epairs.Set( key.c_str(), value );
            }
        } while ( 1 );
    }
    catch( og::LexerError &err ) {
        og::String errStr;
        err.ToString( errStr );
        og::User::Error( og::ERR_LEXER_FAILURE, errStr.c_str(), "MapEntity" );
        return NULL;
    }

    return ent;
}

class ogMapFile {
public:
    ogMapFile( void );
    ~ogMapFile( ) { Clear(); }

public:
    bool Parse( const char *filename, bool fromBSP = false );
    bool Write( const char *filename );
    void Clear( void );

protected:
    og::List<ogMapEntity *> entities;
    og::String name;
};

ogMapFile::ogMapFile( ) {
    entities.SetGranularity( 256 );
}
void ogMapFile::Clear( ) {
    entities.Clear();
}
bool ogMapFile::Parse( const char *filename, bool fromBSP ) {
    og::Lexer source;
    ogMapEntity *ent;
    int i;

    name = filename;
    name.StripFileExtension();

    if( fromBSP ) {
        byte *buffer, *base;
        dheader_t header;
        name.SetFileExtension( ".bsp" );

        int length = og::FS->LoadFile( name.c_str(), &buffer );

        if( length < 0 ) {
            return false;
        }

        og::AutoFreeFile aff( buffer );

        header = *(dheader_t *)buffer;
        for( i = 0; i < sizeof( dheader_t ) / 4; i++ ) {
            ( (int *)&header )[i] = LittleLong( ( (int *)&header )[i] );
        }

        base = (byte *)buffer;

        char * entstr;
        // We drop 1 char because of the added NUL from some other lump it seems?
        int filelen = header.lumps[LUMP_ENTITIES].filelen - 1;
        entstr = new char [ filelen ];
        Com_Memset( entstr, 0, filelen );
        Com_Memcpy( entstr, base + header.lumps[LUMP_ENTITIES].fileofs, filelen );

        if( !entstr ) {
            return false;
        }

        if( !source.LoadData( name.c_str(), (byte *)entstr, filelen ) ) {
            G_Printf("Failed load entstring for parsing\n");
            return false;
        }

        delete[] entstr;

        while ( 1 ) {
            ent = ogMapEntity::Parse( source );
            if( !ent ) {
                break;
            }

            og::String classname = ent->epairs.Get( "classname", "noclass" );
            if( !classname.IcmpPrefix("item_" ) || !classname.IcmpPrefix("weapon_" ) || !classname.IcmpPrefix("ammo_" ) || !classname.IcmpPrefix("team_" ) || !classname.IcmpPrefix("holdable_" ) )
            {
                entities.Append( ent );
            }
            //delete ent;
        }

        name.SetFileExtension( ".items" );
        Write( name.c_str() );
        return true;
    }

    return true;
}
bool ogMapFile::Write( const char *filename ) {
    og::File *file;
    og::String name;
    int i, j;

    name = filename;
    name.SetFileExtension(".items");

    file = og::FS->OpenWrite( name.c_str() );
    if( !file ) {
        return false;
    }

    og::Format out( "\"$*\" \"$*\"\r\n" );
    for( i = 0; i < entities.Num(); i++ ) {
        file->WriteCStr("{\r\n");
        og::Dict &dict = entities[i]->epairs;
        for( j = 0; j < dict.Num(); j++ ) {
            const og::KeyValue *kv = dict.GetKeyValue(j);
            out << kv->GetKey().c_str() << kv->GetStringValue();
            file->Write( out, out.ByteLength() );
            out.Reset();
        }
        file->WriteCStr("}\r\n");
    }

    file->Close();

    return true;
}