/*
 * $Id: SummarizedClassifier.java,v 1.2 2004/12/21 10:29:17 koppy Exp $
 *
 * Copyright (c) Siemens AG 2008 
 *           (c) Universität Paderborn 2008 
 * Licensed under EUPL 1.1. 
 * 
 * Created on 09.10.2004
 *
 * $Log: SummarizedClassifier.java,v $
 * Revision 1.2  2004/12/21 10:29:17  koppy
 * so einiges
 *
 * Revision 1.1  2004/10/09 16:03:01  koppy
 * Initiale Version
 *
 */
package vkc.ws.axis.service.patent;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import vkc.analyse.Analyser;
import vkc.db.entities.VKCCategory;
import vkc.db.entities.VKCDocument;
import vkc.db.entities.VKCUser;
import vkc.search.ClassifyResultEntry;
import vkc.server.archive.DataStoreException;

/**
 * This class represents
 * @author Andreas Koop
 */
public class SummarizedClassifier extends PatentClassifier{

    public static final float BY_KEYWORDS_CLASSIFICATION_WEIGHT = 1.0f;
    public static final float BY_DOCUMENTS_CLASSIFICATION_WEIGHT = 0.9f;
    public static final float BY_STDT_DOCS_CLASSIFICATION_WEIGHT = 0.8f;
    
    /**
     * Enthält die "<code>PatentClassifyResultDocument</code>e", die ein Klassifikationsergebnis
     * enthalten
     */
    private Collection classifyResultDocs = new ArrayList();
    
    /**
     * @param doc
     * @return
     */
    public boolean addClassifyResultDoc( PatentClassifyResultDocument doc ){
        return classifyResultDocs.add(doc);
    }
    
    /**
     * Diese Methode implementiert die Gesamtklassifizierung.
	 * Bei der Gesamtklassifizierung werden die Ergebnisse der Einzelklassifizierungen durch ein mathematisches
	 * Verfahren zusammengefasst. Denkbar sin z.B. einfache Addition der %-Werte für alle Kategorien und
	 * Normierung auf max. 100%. Kompliziertere Verfahren können die Teilergebisse oder einzelne Kategorien
	 * unterschiedlich gewichten.
     * @throws DataStoreException
	 * 
     * @see vkc.ws.axis.service.patent.PatentClassifier#classify(vkc.analyse.Analyser, vkc.db.entities.VKCDocument, int, vkc.db.entities.VKCUser, vkc.db.entities.VKCCategory)
     */
    protected Collection classify(Analyser analyser, VKCDocument doc,int keywordCount,
            VKCUser user, VKCCategory patentCat) throws Exception{
        
        if(classifyResultDocs.isEmpty())
            return new ArrayList();
        
        Collection classResultEntries = new ArrayList();
        Map allResults = new HashMap();
        
        // Über alle Klassifikationsergebnisse iterieren
        float maxPercent = 0f;
        for( Iterator it = this.classifyResultDocs.iterator(); it.hasNext();){
            PatentClassifyResultDocument classResultDoc = (PatentClassifyResultDocument)it.next();
            VKCDocument classResultVKCDoc = classResultDoc.getClassifyResultDoc();
            
            BufferedReader br = new BufferedReader(
                    			new InputStreamReader(classResultVKCDoc.getInputStream()));
            String line;
            while( (line = br.readLine()) != null){
                if(!PatentClassifyResultEntry.isValid(line))
                    continue;
                
                PatentClassifyResultEntry pcr = new PatentClassifyResultEntry(line);
                pcr.setPercentString( pcr.getPercent()*classResultDoc.getWeight() + "%");
                
                if(!allResults.containsKey( pcr.getCategoryId())){
                    allResults.put( pcr.getCategoryId(), pcr);
                    if( pcr.getPercent() > maxPercent)
                        maxPercent = pcr.getPercent();
                    continue;
                }
                
                PatentClassifyResultEntry existentPcr = (PatentClassifyResultEntry)allResults.get(pcr.getCategoryId());
                existentPcr.addPercent(pcr.getPercent());
                if( existentPcr.getPercent() > maxPercent)
                    maxPercent = existentPcr.getPercent();
            }
            
            br.close();
        }
        
        // Normieren und als ClassifyResultEntrys verpacken
        for(Iterator it = allResults.keySet().iterator(); it.hasNext();){
            PatentClassifyResultEntry pcr = (PatentClassifyResultEntry)allResults.get(it.next());

            classResultEntries.add( new ClassifyResultEntry(pcr.getCategoryId(), "---", null, null,
                    pcr.getPercent()/maxPercent));
        }
        
        return classResultEntries;
    }
    
    /** 
     * (non-Javadoc)
     * @see vkc.ws.axis.service.patent.PatentClassifier#getResultFilename(java.lang.String)
     */
    protected String getResultFilename(String originalPatentFilename) {
        return originalPatentFilename.substring(0, 
                originalPatentFilename.lastIndexOf("."))+ "_Classification_summarized.txt";
    }
    
    
    protected String getHeader() {
        return "# Gesamtklassifikationergebnis mit folgender Gewichtung:\n"+
        	   "# ByKeywordsClassification: " + SummarizedClassifier.BY_KEYWORDS_CLASSIFICATION_WEIGHT + "\n"+
        	   "# ByDocumentsClassification: " + SummarizedClassifier.BY_DOCUMENTS_CLASSIFICATION_WEIGHT + "\n"+
        	   "# ByStdTDocClassification: " + SummarizedClassifier.BY_STDT_DOCS_CLASSIFICATION_WEIGHT;
    }
    
    /** 
     * (non-Javadoc)
     * @see vkc.ws.axis.service.patent.PatentClassifier#getResultTitle(java.lang.String)
     */
    protected String getResultTitle(String originalPatentFilename) {
        return "Gesamtklassifikationsergebnis";
    }
}
