/*
 * $Id: VectorAnalyzer.java,v 1.4 2005/04/13 06:37:26 lawern Exp $
 *
 * Copyright (c) Siemens AG 2008 
 *           (c) Universität Paderborn 2008 
 * Licensed under EUPL 1.1. 
 *
 * $Log: VectorAnalyzer.java,v $
 * Revision 1.4  2005/04/13 06:37:26  lawern
 * Analyser mit Typografiegewichtung
 *
 * Revision 1.3  2004/06/27 17:08:23  marbobo
 * + Quellcode maintenance
 *
 * Revision 1.2  2003/12/24 10:12:04  bigmac
 * Projektweite Import-Optimierung
 *
 * Revision 1.1  2003/09/18 12:11:18  lawern
 * initiale Version
 *

 */
package vkc.analyse;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.StopAnalyzer;
import org.apache.lucene.analysis.Token;
import org.apache.lucene.analysis.TokenStream;


/**
 * Diese Methode hilft Lucene die VKC-internen Keyword-Vektoren zu indizieren.
 *
 * @author lawern
 */
public final class VectorAnalyzer extends Analyzer {
    private Analyser analyser = null;

    /**
     * Diese Methode wird von Lucene zur Indizierung des übergebenen Streams
     * aufgerufen.
     */
    public TokenStream tokenStream(String fieldName, Reader reader) {
        if ((fieldName.equals("contents")) &&
                (reader.getClass().getName().equals("java.io.StringReader"))) {
            ArrayList tokens = new ArrayList(200);

            //TDF-Token erzeugen
            try {
                BufferedReader vector = new BufferedReader(reader);
                String line;
                String keyword;
                int weight;
                int index;

                while ((line = vector.readLine()) != null) {
                    index = line.indexOf(':');
                    weight = Integer.parseInt(line.substring(0, index));
                    keyword = line.substring(index + 1);
                    tokens.add(new TdfToken(keyword, 0, weight));
                }
            } catch (IOException e) {
            }

            return new VectorTokenStream(tokens);
        } 

        return (new StopAnalyzer().tokenStream(fieldName, reader));
    }

    /**
     * Liefert den Analyser der für die Indizierung verwendet wird.
     *
     * @return Analyser der für die Indizierung verwendet wird
     */
    public Analyser getAnalyser() {
        return analyser;
    }
}


final class VectorTokenStream extends TokenStream {
    List tokens;
    TdfToken currentToken = null;
    Token token;
    double tokenCounter = 0;
    int listPointer = 0;
    int listSize = 0;

    /**
     * Initialisierung
     *
     * @param tdfElements Liste von TdfElement-Objekten aus dem DocConverter
     * @param keywords HashSet mit Keywords aus der Analyse
     */
    public VectorTokenStream(List tokens) {
        this.tokens = tokens;
        listSize = tokens.size();
    }

    public Token next() throws IOException {
        //evtl. neues TdfToken holen
        if (tokenCounter == 0) {
            if (listPointer < listSize) {
                currentToken = (TdfToken) tokens.get(listPointer);
                listPointer++;
                tokenCounter = currentToken.tdfWeight - 1.0;
                currentToken.termText = currentToken.termText.toLowerCase();

                //System.out.println("Token: " + currentToken.termText +
                //  " weight:" + currentToken.tdfWeight);
            }
        } else {
            tokenCounter--;
        }

        //Lucene-Token erzeugen
        token = new Token(currentToken.termText, currentToken.startOffset,
                currentToken.startOffset + currentToken.termText.length());

        return token;
    }

    public void close() throws IOException {
        tokens = null;
        currentToken = null;
    }
}
