/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package buzzerproxy;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

/**
 * CacheManager.java - beinhaltet alle Funktione zum Cachen eines Suchbegriffs
 * und seiner Results
 * 
 * @author Sebastian Enger
 * @see Serialization
 * @since 1.1
 * @version 1.1 / 2011-08-21
 * @typ Class
 * 
 */
public class CacheManager implements Serializable {

    /**
     * 
     */
    private static final long                           serialVersionUID = 1L;

    /** Cache */
    private HashMap<String, ArrayList<ResultContainer>> cache;

    /** Cache Deleter */
    private CacheDeleter                                cacheDeleter;

    /** Cache Writer/Reader*/
    private Serialization                               ser;

    /**
     * Konstruktor
     * @throws Exception 
     */
    public CacheManager() throws Exception {
        cache = new HashMap<String, ArrayList<ResultContainer>>();

        ser = new Serialization( Constant.CACHEFILE );
    }

    public void setCache(HashMap<String, ArrayList<ResultContainer>> c) {
        this.cache = c;
    }

    public void addCache(HashMap<String, ArrayList<ResultContainer>> c) {
        this.cache.putAll( c );
    }

    public HashMap<String, ArrayList<ResultContainer>> getCache() {
        return this.cache;
    }

    // not tested
    public synchronized HashMap<String, ArrayList<ResultContainer>> sortByFilename(ArrayList<ResultContainer> rCT, String filetypes) {
        HashMap<String, ArrayList<ResultContainer>> c = new HashMap<String, ArrayList<ResultContainer>>();

        String[] typeSplit = filetypes.replaceAll( "\\.", "" ).split( "+" );
        // StringBuffer sb = new StringBuffer();
        for ( String type : typeSplit ) {
            ArrayList<ResultContainer> a = new ArrayList<ResultContainer>();
            for ( ResultContainer r : rCT ) {
                String ft = r.getFileTyp();
                if ( type.contains( ft ) ) {
                    // filetyp des containers und der gesuchte filetype sind
                    // gleich
                    a.add( r );
                }
            }
            c.put( type, a );
        }

        return c;

    }

    /**
     * @param searchquery
     * @param filetypes
     *            = .mp3+.wav+.flac
     * @return
     */
    public synchronized ArrayList<ResultContainer> getResultContainerFor(String searchquery, String filetypes) {
        return getResultContainerFor( searchquery, filetypes, false ); 
    }
    
    /**
     * @param searchquery
     * @param filetypes
     *            = .mp3+.wav+.flac
     * @return
     */
    private synchronized ArrayList<ResultContainer> getResultContainerFor(String searchquery, String filetypes, boolean onlyCache) {

        if ( filetypes == null )
            throw new NullPointerException();

        ArrayList<ResultContainer> res = new ArrayList<ResultContainer>();
        String[] typeSplit = filetypes.split( "+" );

        Set<Mediatype> mediatypes = new TreeSet<Mediatype>(); // für die neue Abfrage
        for ( String type : typeSplit ) {
            // Kontrolle der Abfrage (Madonna:.mp3)
            if ( cache.containsKey( searchquery + ":" + type ) ) {
                res.addAll( cache.get( searchquery + ":" + type ) );
            } else {
                Filetype ft = Filetype.getFileType( type );
                if ( ft != null )
                    mediatypes.add( ft.getType() );
            }
        }
        
        if ( onlyCache )
        	return res;

        // Evt Google nochmal abfragen
        if ( mediatypes.size() > 0 ) {
            Google g = new Google();
            GoogleResultParser gr = new GoogleResultParser();
            StringBuilder newFileTypes = new StringBuilder();

            // Anhand der Media Typen werden hier die Google Abfragen erstellt
            // Jeder Media Type hat viele Filetypen
            while ( mediatypes.iterator().hasNext() ) {
                Filetype[] fts = Filetype.getFilesTypeForMediaType( mediatypes.iterator().next() );
                if ( fts != null && fts.length > 0 ) {
                    for ( Filetype tf : fts ) {
                        newFileTypes.append( tf.getCaption() );

                        if ( fts[fts.length - 1] != tf )
                            newFileTypes.append( "+" );
                    }
                }
            }

            // Google Abfrage
            // Alte Version:
            ArrayList<ResultContainer> unsortedResultBox = null;
            String googleResultString = g.getGoogleContent( searchquery, newFileTypes.toString() );
            unsortedResultBox = gr.parseResults( googleResultString, newFileTypes.toString() );

//            // Neue Version - muss noch getestet werden
//            ArrayList<ResultContainer> unsortedResultBox = null;
//         	ArrayList<String> googleResultString = g.getGoogleContentMoreResults(searchquery, newFileTypes.toString() );
//         	unsortedResultBox = gr.parseMoreResults(googleResultString, newFileTypes.toString() );
            
            // Cache neu füllen
            fillCache( unsortedResultBox, mediatypes, searchquery );
            return getResultContainerFor( searchquery, filetypes, true );
        }

        return res;
    }

    /**
     * @param unsortedResultBox
     * @param mediatypes
     */
    private synchronized void fillCache(ArrayList<ResultContainer> unsortedResultBox, Set<Mediatype> mediatypes, String searchquery) {
        while ( mediatypes.iterator().hasNext() ) {
            Filetype[] fts = Filetype.getFilesTypeForMediaType( mediatypes.iterator().next() );
            if ( fts != null && fts.length > 0 ) {
                for ( Filetype tf : fts ) {
                    ArrayList<ResultContainer> rList = null;
                    if ( cache.containsKey( searchquery + ":." + tf.getCaption() ) )
                        rList = cache.get( searchquery + ":." + tf.getCaption() );
                    else
                        rList = new ArrayList<ResultContainer>();

                    rList.addAll( getByFiletype( tf, unsortedResultBox ) );
                    cache.put( searchquery + ":." + tf.getCaption(), rList );
                }
            }
        }
    }

    /**
     * @param filetype
     * @param unsortedResultBox
     * @return
     */
    private synchronized List<ResultContainer> getByFiletype(Filetype filetype, ArrayList<ResultContainer> unsortedResultBox) {
        List<ResultContainer> res = new ArrayList<ResultContainer>();
        for ( ResultContainer rc : unsortedResultBox )
            if ( rc.getFileTyp().equals( "." + filetype.getCaption() ) || rc.getFileTyp().equals( filetype.getCaption() ) )
                res.add( rc );
        return res;
    }
}