//
// g++ -Wall -O2 -o fnt fnt.cpp -lboost_regex-mt

#include <string>
#include <iostream>
#include <iterator>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <ctime>
#include "boost/bind.hpp"
#include "boost/shared_ptr.hpp"
#include "boost/operators.hpp"
#include "boost/regex.hpp"
#include "boost/lexical_cast.hpp"

using namespace std;

/// Konstante für die maximale Leselänge von einem Stream
namespace buffer { enum bufsiz { size = 512  }; }

/// Die Klasse "file_tokenizer" liefert einen Iterator auf einen Input Stream.
/// Der Input Stream wird dabei in Stücke zerteilt, die auf ein bestimmtes
/// Zeichen enden oder die maximale Leselänge der Konstanten buffer::size erreichen.
///
/// Ich mache mir dabei die boost Bibliothek "boost::operator" zu Nutze, um nur
/// die minimale Schnittstelle implementieren zu müssen.
class file_tokenizer : private boost::input_iterator_helper<file_tokenizer, string> {
    /// Zugrundeliegender "input"
    istream * file;
    /// Interne Variable zum Zwischenspeichern des Stream Zustands 
    bool ok;
    /// Das Trennzeichen der "tokens"
    unsigned char delim;
    /// Interner Buffer fürs Lesen vom "input"
    char buf[buffer::size];
    /// Zur einfachen Weiterverarbeitung wird der gelesene Buffer
    /// als dieser string gespeichert und vom Iterator zurückgegeben
    string worker;
public:
    /// Standard Konstruktor
    /// @param i Der zugrendliegende input stream
    /// @param d Das Trennzeichen der Iterator Stücke
    explicit file_tokenizer(istream * i = 0, unsigned char d = '\n');
    /// copy constructor, dessen Implementierung boost::operator erzwingt
    file_tokenizer(const file_tokenizer& x);
    /// Vergleichsoperator. Wird hier vorallem für die das Iterator Ende
    /// benötigt. Implementierung boost::operator
    bool operator==(const file_tokenizer & x) const;
    /// Increase Operator, erzwungen von boost::operator
    file_tokenizer & operator++( void );
    /// Derefernzierung zum Zugriff auf das Zugrundeliegende Element
    const string & operator*( void ) const;
};

/// Die struktur "footnote" dient zur Speicherung aller
/// Fußnoten mit der Häufigkeit der Verwendung, der Position in
/// der Textdatei und der Rangfolge ihrer ersten Verwendung.
struct footnote {
    /// Standard Konstruktor
    explicit footnote( unsigned int c = 0,
                       unsigned int o = 0,
                       unsigned int r = 0) :
        counter( c ), offset( o ), order( r) { }
    /// Häufigkeit der Verwendung
    unsigned int counter;
    /// Position in der textdatei
    unsigned int offset;
    /// Rangfolge der ersten Verwendung
    unsigned int order;
};
/// Jede Fußnote wird in dieser Map abgelegt, indiziert durch
/// ihre orginal Nummer.
typedef map<unsigned int, footnote> footnote_map;

/// Der Textdatei wird beim ersten Scannen die Orginal 
/// Fußnotennummer und die Anzahl der Zeichen, die zwischen
/// der letzten Fußnote lagen, entrissen. Diese beiden
/// Zahlen werden in einer Struktur names "footnote_offset"
/// gespeichert und beim zweiten Lesen der Datei verwendet.
struct footnote_offset {
    /// Standard Konstruktor
    explicit footnote_offset(
        unsigned int id, unsigned int offset ) :
        id( id), offset( offset ) {
    }
    /// Orginal Nummer der Fußnote. Die Fußnote 0 hat eine
    /// Sonderbedeutung. Sie ist für den Anfangstext bis zur
    /// ersten Fußnote reserviert und soll nicht weiter-
    /// verarbeitet werden.
    unsigned int id;
    /// Anzahl der gelesen Zeichen seit der letzten Fußnote
    unsigned int offset;
};
/// Das Ergebnis des ersten Textdatei Scans werden innerhalb
/// einer Liste von "footnote_offset"s gespeichert. Ich
/// nenne ihn "text_chunks".
typedef list< footnote_offset > text_chunks;

/// Nachdem wir alle Daten gesammelt haben, wird die Textdatei
/// ein zweites Mal durchlaufen. Dabei werden je nach Modus die
/// Fußnoten nach der Reihenfolge ihres Auftretens oder ihrer
/// Häufigkeit numeriert und im Text angegeben. Um die Ausgabe
/// zu erleichtern, schaffe ich mir dieses erweiterte
/// Funktionsobject "print_footnote"
class print_footnote {
    /// Die Sammelung aller gescannten Fußnoten
    footnote_map & fidx;
    /// Zugrundeliegender "input"
    istream * file;
    /// Interner Buffer fürs Lesen vom "input"
    char buf[buffer::size];
public:
    /// Standard Konstruktor
    /// @param fidx Die gesammelten Fußnoten
    /// @param file Der zugrundeliegnede "input stream"
    explicit print_footnote( footnote_map & fidx,
                             istream * file );
    /// Hilfsfunktion die den geöffneten stream zum Anfang zurücksetzt 
    void rewind( void );
    /// Dadurch wird dies ein Funktionsobject, das den Text ausdrucken
    /// kann. Intern wird der mitgegebene Textabschnitt mit der
    /// neuen Fußnote versehen und an "stdout" geschickt. Bei Fußnote
    /// "0" wird der der Verweis übersprungen.
    void operator()( const footnote_offset & ft );
};

/// In diesem Funktionsobjekt wird jeder String nach dem
/// Fußnotenmuster gescanned und den beiden Containern "text_chunks"
/// und "footnote_map" die entsprechenden Einträge hinzugefügt.
class build_index {
    boost::regex pattern; 
    string buffer;
    const string switcher;
    bool switched;
    text_chunks * text;
    footnote_map * footnotes;
public:
    /// Konstruktor
    explicit build_index( const string & sw ,
                          text_chunks * text,
                          footnote_map * footnotes );
    /// Durchkämmt den den mitgegebenen string und erweitert
    /// damit die interenen Container um ...
    void operator()( const string & ft );
};

/// Nun ist alles vorbereitet...
int main( int argc, char *argv[] )
{
    // Die zu bearbeitende Datei wird als erster Parameter erwartet
    ifstream source( argv[1] );
    text_chunks text;
    footnote_map footnotes;
    build_index bldidx( "@footnotes:", &text, &footnotes );
    print_footnote printit( footnotes, &source );

    // Auf der Datei wird nun einen Iterator definiert,
    // der diese in ']' terminierte Stückchen zerteilt.
    file_tokenizer bos( &source,'['), eos;
    // Gehe mittels dieses Iteratotrs durch die Datei und baue
    // dabei den Index auf.
    for_each( bos, eos, bldidx );
    // Textdatei zurücksetzten und damit bereit für den
    // zweiten Durchlauf sein
    printit.rewind();
    // Jetzt kann der Textteil der Datei ausgedruckt werden
    for_each( text.begin(), text.end(), printit );
    // Aufräumen
    source.close();
}

//////////////////////////////////////////////////////////////////////
// Implementierungsteil //////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

file_tokenizer::file_tokenizer(istream * i, unsigned char d )
    : file(i), ok(false), delim(d) { }
file_tokenizer::file_tokenizer(const file_tokenizer& x)
    : file(x.file), ok(x.ok), delim( x.delim) {
    ++(*this);
}
bool file_tokenizer::operator==(const file_tokenizer & x) const {
    return ( ok == x.ok ) && ( ! ok || file == x.file );
}
file_tokenizer & file_tokenizer::operator++( void ){
    ok = ( file && *file && ! file->eof() ) ? true : false;
    if ( ok ) {
        worker.clear();
        if ( file->peek() == delim ){
            file->get();
            worker.assign("[");
        }
        if ( file->peek() != delim ){
            memset( buf, 0, buffer::size );
            file->get( buf, buffer::size , delim );
            worker.append( buf );
        }
    }
    return *this;
}
const string & file_tokenizer::operator*( void ) const {
    return worker;
}
print_footnote::print_footnote( footnote_map & fidx,
                                istream * file ) :
    fidx( fidx ), file( file ) {
}
void print_footnote::rewind( void ){
    file->clear();
    file->seekg( 0, ios::beg );
}
void print_footnote::operator()( const footnote_offset & ft ){
    // Nur echte Fußnoten werden auch gedruckt
    if ( ft.id != 0 ){
        cout << '[' << fidx[ft.id].order << ']';
        file->get( buf, 32, ']' );
        file->get();
    }
    memset( buf, 0, buffer::size );
    file->read( buf, ft.offset );
    cout << buf;
}
build_index::build_index( const string & sw ,
                          text_chunks * text,
                          footnote_map * footnotes
    ) :
    pattern( "\\[([0-9]+)\\].*" ), buffer (""),
    switcher(sw) , switched(false),
    text(text), footnotes(footnotes) {
}
void build_index::operator()( const string & ft ){
    static unsigned int footnote_counter = 0;
    buffer.append( ft );
    size_t switch_pos = buffer.find( switcher, 0 );
    if ( switch_pos != string::npos ){
        switched = true;
    }
    
    boost::smatch footnote_id;
    unsigned int id = 0;
    unsigned int os = buffer.length();
    if( 0 != boost::regex_match(buffer, footnote_id, pattern ) ){
        id = boost::lexical_cast<unsigned int>(footnote_id[1].str());
        os = os - footnote_id[1].str().length() - 2;
    }
    
    buffer.clear();
    text->push_back( footnote_offset( id, os ) );
    if ( footnotes->find( id ) == footnotes->end() )
        (*footnotes)[ id ] = footnote();
    (*footnotes)[ id ].counter++;
    if ( switched )
        (*footnotes)[ id ].order = footnote_counter++;


}