Untitled

package jpp.marketanalysis.exploration;


import java.math.BigDecimal;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Vector;

import jpp.marketanalysis.data.ShareCSVReader;
import jpp.marketanalysis.data.DataStorage;
import jpp.marketanalysis.data.Dataset;;

/**Klasse zur Analyse der Daten auf
 * Lokale/Globale "Extrema" und Durch-
 * schnitte.
 *
 * @author Hendrik Herschlein
 *
 */
public class ShareExploration {

    private static DataStorage db;


    /**
     * Der Konstruktor der Klasse, welcher als Argument den Pfad und Dateinamen
     * der CSV-Datei enthaelt. Im Konstruktor wird zunaechst die Datei fileName
     * gelesen (verweneden Sie den in Teil 1 implementierten ShareCSVReader).
     * Anschliessend wird die DataStorage Instanz mit deren getInstance()
     * Methode geholt und in ein privates Attribut der Klasse ShareExploration
     * geschrieben.
     *
     * @param fileName
     *            name der einzulesenden Datei
     */
    public ShareExploration(String fileName) {
        // Datei die uerbergeben wird einlesen mit ShareCSVReader
        ShareCSVReader.readData(fileName);
        db = DataStorage.getInstance();

    }

    /**
     * Gibt die DataStorage-Instanz zurueck.
     *
     * @return db
     */
    public DataStorage getDB() {
        return db;

    }

    /**
     * Liefert alle zur Aktie mit dem Namen stockName gespeicherten Daten
     * zurueck, und zwar als Vector von Dataset-Objekten.
     *
     * @param stockName
     *            Name der Aktie
     * @return alleDaten alle Daten, die zu der Aktie vorhanden sind
     */
    public Vector<Dataset> getAllData(String stockName) {

        Vector<Dataset> alleDaten = db.getEntry(stockName);
        return alleDaten;

    }

    /**
     * Liefert dasjenige Dataset der Aktie mit Namen stockName zurueck, welches
     * den hoechsten Wert der Aktie enthaelt. Dabei ist zu pruefen ob s ein
     * gueltiger Aktienname ist: ist stockName null oder der leere String "", so
     * soll eine NullPointerException bzw. eine IllegalArgumentException mit
     * aussagekraeftiger Meldung geworfen werden. Weiter ist zu pruefen, ob die
     * abgefragte Aktie in der Datenbank vorhanden ist. Ist dies nicht der Fall,
     * soll die Methode null zurueckgeben. Verwenden Sie zum finden des Maximums
     * die Collections.sort() Methode und den geeigneten Comparator (s.o.)
     *
     * @param stockName
     *            Aktienname
     * @return temp.get(0) Eintrag in temp an der Stelle 0 (Datensatz, der das
     *         lokale Maximum der Aktie enthaelt
     */
    public Dataset getLocalMaximum(String stockName) {

        if (stockName == null) {
            throw new NullPointerException("String nicht initialisiert");
        }
        if (stockName == "") {
            throw new IllegalArgumentException("Leerer String");
        }
        if (!ShareExploration.db.getAllData().containsKey(stockName)) {
            // enthaelt
            // die
            // Treemap
            // die Aktie?
            return null; // wenn sie die Aktie nicht enthaelt wird null
            // zurueckgegeben
        } else {
            DatasetMaxValComparator s = new DatasetMaxValComparator();
            List<Dataset> temp = db.getEntry(stockName);

            Collections.sort(temp, s);
            int i = temp.size();
            return temp.get(i - 1);

        }
    }

    /**
     * Liefert dasjenige Dataset der Aktie mit Namen stockName zurueck, welches
     * den niedrigsten Wert der Aktie enthaelt. Dabei ist zu pruefen ob
     * stockName ein gueltiger Aktienname ist: ist stockName null oder der leere
     * String "", so soll eine NullPointerException bzw. eine
     * IllegalArgumentException mit aussagekraeftiger Meldung geworfen werden.
     * Weiter ist zu pruefen, ob die abgefragte Aktie in der Datenbank vorhanden
     * ist. Ist dies nicht der Fall, soll die Methode null zurueckgeben.
     * Verwenden Sie zum finden des Minimums die Collections.sort() Methode und
     * den geeigneten Comparator (s.o.)
     *
     * @param stockName
     *            Name der betrachteten Aktie
     * @return temp.get(i-1) Der Datensatz, der das lokale Minimum der Aktie
     *         enthaelt
     */
    public Dataset getLocalMinimum(String stockName) {

        if (stockName == null) {
            throw new NullPointerException("String nicht initialisiert");
        }
        if (stockName == "") {
            throw new IllegalArgumentException("Leerer String");
        }
        if (!ShareExploration.db.getAllData().containsKey(stockName)) {
            // enthaelt
            // die
            // Treemap
            // die Aktie?
            return null; // wenn sie die Aktie nicht enthaelt wird null
            // zurueckgegeben
        } else {
            DatasetMinValComparator s = new DatasetMinValComparator();
            List<Dataset> temp = db.getEntry(stockName);

            Collections.sort(temp, s);
            int i = temp.size();
            return temp.get(i - 1); // denn der kleinste Wert steht immer auf
            // letzter Position

        }
    }


    /**
     * Liefert den durchschnittlichen Tagesendwert (close) der Aktie mit Namen
     * stockName zurueck, und zwar auf zwei Stellen nach dem Komma gerundet.
     * Dabei ist zu pruefen ob stockName ein gueltiger Aktienname ist: ist
     * stockName null oder der leere String "", so soll eine
     * NullPointerException bzw. eine IllegalArgumentException mit
     * aussagekraeftiger Meldung geworfen werden. Weiter ist zu pruefen, ob die
     * abgefragte Aktie in der Datenbank vorhanden ist. Ist dies nicht der Fall,
     * soll die Methode -1 zurueckgeben.
     *
     * @param s
     *            Aktienname
     * @return avgClose Durchschnitt der Close Werte einer bestimmten Aktie s
     */
    public double getLocalAverage(String s) {

        double summe = 0.0;
        double avgClose = 0.0;
        List<Dataset> avgTemp = db.getEntry(s);

        if (s == null) {
            throw new NullPointerException("String nicht initialisiert");
        }
        if (s == "") {
            throw new IllegalArgumentException("Leerer String");
        }
        if (!db.getAllData().containsKey(s)) {
            return -1;
        } else
            for (int i = 0; i < avgTemp.size(); i++) {
                summe = summe + avgTemp.get(i).getClose();


            }
         avgClose = summe / avgTemp.size();

         //Zweite Rundungsmoeglichkeit
//         avgClose = new BigDecimal(avgClose).setScale(2,
//         BigDecimal.ROUND_DOWN).doubleValue();
        final double rundung = 100.0;
        avgClose = Math.round(avgClose * rundung) / rundung;
        return avgClose;
    }

    /**
     * Gibt einen Vector< Object > zurueck. Dieser hat an der Stelle 0 den Namen
     * der Aktie mit dem hoechsten lokalen Maximum im DataStorage, an der Stelle
     * 1 ist das betreffende Dataset abgelegt. Sollte es mehrere Aktien geben,
     * welche das gleiche, lokale Maximum besitzen, so ist die Aktie, deren
     * Anfangsbuchstabe am weitesten vorne im Alphabet auftaucht,
     * zurueckzugeben.
     *
     * @return globMax globales Maximum
     */
    public Vector<Object> getGlobalMaximum() {

        Set<String> keys = db.getAllData().keySet();
        Iterator<String> itGlobMax = keys.iterator();

        Dataset max = null;
        String shareMax = null;
        Vector<Object> globMax = new Vector<Object>();

        while (itGlobMax.hasNext()) {
            String share = itGlobMax.next().toString();

            DatasetMaxValComparator s = new DatasetMaxValComparator();
            List<Dataset> temp = db.getEntry(share);
            Collections.sort(temp, s);
            int i = temp.size();
            Dataset lokalesMax = temp.get(i - 1);

            // Abfrage ob max == null ist, was wahr ist => max = erstes
            // lokales_max, das gefunden wird
            if (max == null) {
                max = lokalesMax;
                shareMax = share;
                // Abfrage, ob die Close werte von max (Jetzt eben erstes
                // gefundenes lokales_max groesser sind als
                // das neue lokale max. wenn ja: tauschen
            } else if (max.getHigh() < lokalesMax.getHigh()) {
                max = lokalesMax;
                shareMax = share;
            } else if (max.getHigh() == lokalesMax.getHigh()
                    && shareMax.compareTo(share) > 0) {
                max = lokalesMax;
                shareMax = share;
            }

        }
        globMax.add(shareMax);
        globMax.add(max);
        return globMax;
    }

    /**
     * Gibt einen Vector< Object > zurueck. Dieser hat an der Stelle 0 den Namen
     * der Aktie mit dem niedrigsten lokalen Minimum im DataStorage, an der
     * Stelle 1 ist das betreffende Dataset abgelegt. Sollte es mehrere Aktien
     * geben, welche das gleiche, lokale Minimum besitzen, so ist die Aktie,
     * deren Anfangsbuchstabe am weitesten vorne im Alphabet auftaucht,
     * zurueckzugeben.
     *
     * @return globMin globales Minimum
     */
    public Vector<Object> getGlobalMinimum() {

        Set<String> keys = db.getAllData().keySet();
        Iterator<String> itGlobMin = keys.iterator();
        Dataset min = null;
        String shareMin = null;
        Vector<Object> globMin = new Vector<Object>();
        while (itGlobMin.hasNext()) {
            String share = itGlobMin.next().toString();

            DatasetMinValComparator s = new DatasetMinValComparator();
            List<Dataset> temp = db.getEntry(share);
            Collections.sort(temp, s);
            int i = temp.size();
            Dataset lokalesMin = temp.get(i - 1);
            // Abfrage ob min == null ist, was wahr ist => min = erstes
            // lokalesMin, das gefunden wird
            if (min == null) {
                min = lokalesMin;
                shareMin = share;
                // Abfrage, ob die Close werte von min (Jetzt eben erstes
                // gefundenes lokalesMin groesser sind als
                // das neue lokale min. wenn ja: tauschen
            } else if (min.getLow() > lokalesMin.getLow()) {
                min = lokalesMin;
                shareMin = share;
            } else if (min.getLow() == lokalesMin.getLow()
                    && shareMin.compareTo(share) > 0) {
                min = lokalesMin;
                shareMin = share;
            }

        }
        globMin.add(shareMin);
        globMin.add(min);
        return globMin;
    }

    /**
     * Berechnet ueber alle bekannten Daten im DataStorage den Durchschnitt der
     * Tagesendwerte (close), und zwar auf zwei Stellen nach dem Komma gerundet.
     *
     * @return avgCloseGlob Globaler Durchschnitt der Close Werte
     */
    public double getGlobalAverage() {

        Set<String> keys = db.getAllData().keySet();
        Iterator<String> it2 = keys.iterator();

        double avgCloseGlob = 0;
        double summeAvgGlob = 0;

        while (it2.hasNext()) {
            String share = it2.next().toString();

            // Testausgaben
            // System.out.println(share);
            // System.out.println(db.getEntry(share));

            Vector<Dataset> avgGlobTemp = db.getEntry(share); // neuer vector
            // zu jedem
            // eintrag im
            // keyset share

            for (int i = 0; i < avgGlobTemp.size(); i++) {
                summeAvgGlob = summeAvgGlob + avgGlobTemp.get(i).getClose();

            }
            avgCloseGlob = summeAvgGlob
                    / (avgGlobTemp.size() * db.getNumOfEntries());
            //Hier wird IMMER aufgerundet
             avgCloseGlob = new BigDecimal(avgCloseGlob).setScale(2,
             BigDecimal.ROUND_UP).doubleValue();

             //Hier wird IMMER wie in der Schule gerundet
//            final double rundung = 100.0;
//            avgCloseGlob = Math.round(avgCloseGlob * rundung) / rundung;

        }
        return avgCloseGlob;
    }


    /**
     * Mainmethode mit Testaufrufen.
     *
     * @param args
     *            ...
     */
    public static void main(String[] args) {
        ShareExploration bla = new ShareExploration("example1.csv");
        // ShareExploration bla2 = new ShareExploration("example2.csv");
        String aktie = "Allianz N";
        String s = "Adidas";

        System.out.println("Local Max: "
                + bla.getLocalMaximum(aktie).toString());
        System.out.println("Local Min: "
                + bla.getLocalMinimum(aktie).toString());
        System.out.println("Local AVG: " + bla.getLocalAverage(s));
        System.out.println("db.getNumOfEntries: " + db.getNumOfEntries());
        System.out.println("Global Avg: " + bla.getGlobalAverage());
        System.out.println("Global Min: " + bla.getGlobalMinimum());
        System.out.println("Global Max: " + bla.getGlobalMaximum());

//         System.out.println("gibt Anzahl der datasets im vector aus:"
//         +spaeter.size()); // gibt Anzahl der datasets im vector aus
//         System.out.println("holt sich das erste Dataset im vector: "+spaeter.
//         get(0)); // holt sich das erste Dataset im vector
//         Dataset index0 = spaeter.get(0); // holt sich das erste Dataset im
//         vector
//         System.out.println(
//         "holt sich aus dem ersten Dataset das close element: "
//         +index0.getClose()); // holt sich aus dem ersten Dataset das close
//         element

    }

}