package Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.swing.JOptionPane;

import junit.framework.TestCase;
import persistence.Administrator;
import persistence.Arzt;
import persistence.Patient;
import persistence.PatientenAkte;
import persistence.PatientenAktenEintrag;
import persistence.Pflegekraft;
import persistence.SystemNutzer;
import service.Service;
import servlets.SWPHelper;

public class ServiceTest extends TestCase {

    private SimpleDateFormat formatter = new SimpleDateFormat("dd.MM.yyyy");
    private Arzt arzt = null;
    private Patient patient = null;
    private Patient vergelichsPatient = null;
    private Pflegekraft pflegekraft = null;
    private PatientenAkte akte = null;
    private PatientenAktenEintrag aktenEintrag = null;
    private Service service = null;
    private SystemNutzer systemNutzer = null;

    private ArrayList<Patient> patientListe = null;
    private ArrayList<Arzt> arztListe = null;

    private EntityManagerFactory emfTest = Persistence
            .createEntityManagerFactory("SWP_2");
    private javax.persistence.EntityManager entityManagerTest = emfTest
            .createEntityManager();

    public ServiceTest(String name) {
        super(name);
    }

    protected void setUp() throws Exception {
        service = new Service();
        //Administrator erzeugen
        service.createAdministrator("Pirro", "Commander", formatter.parse(formatter.format(new Date(19, 04, 1990))),
                SystemNutzer.Geschlecht.MAENNLICH, "111", "1234", "01236547", "pirro@empire.de", "Schillerstr",
                "15", "A", "78045", "Atlantis");

        // Arzt erzeugen
        service.createArzt("Max", "Mustermann", formatter.parse(formatter
                .format(new Date(19, 04, 2012))),
                SystemNutzer.Geschlecht.MAENNLICH, "000", "1234", "055501234",
                "max@mustermann.de", "Maxstraße", "12", "A", "701668",
                "Maxstadt");
        // Arzt aus der DB holen
        arzt = (Arzt) service.sucheSystemnutzerNachSozialversicherungsN("000");

        // Patient erzeugen
        service.createPatient("martin", "max",
                SystemNutzer.Geschlecht.WEIBLICH, formatter.parse(formatter
                        .format(new Date(01, 01, 2001))), "Hausstraße", "12",
                "KL", "565656", "Martinsburg", "014665656", "m@mail.de",
                "11115", "AOK", "456456546", "222");

        // Patient aus der DB holen
        patient = (Patient) service
                .sucheSystemnutzerNachSozialversicherungsN("55jjj");
        // Patient erzeugen
        vergelichsPatient = new Patient("max", "martin", formatter
                .parse(formatter.format(new Date(01, 01, 2001))),
                SystemNutzer.Geschlecht.WEIBLICH, "55jjj", "11115",
                "014665656", "m@mail.de", "Hausstraße", "12", "KL", "565656",
                "Martinsburg", "AOK", "456456546");

        // Pflegekraft erzeugen
        service.createPflegekraft("Max", "Mustermann", formatter
                .parse(formatter.format(new Date(19, 04, 2012))),
                SystemNutzer.Geschlecht.MAENNLICH,
                "333", "1234", "055501234",
                "max@mustermann.de", "Maxstraße", "12", "A", "701668",
                "Maxstadt");
        // Pflegekraft aus der DB holen
        pflegekraft = (Pflegekraft) service
                .sucheSystemnutzerNachSozialversicherungsN("SozialversicherungsN1dsfdf234");
        if (patient.getAkte() != null) {
            patient.getAkte().getEintraege().clear();
        }
    }

    public void testCreateAdministrator() {

    }

    public void testCreateArzt() {
        // Manuell Arzt erzeugen um es anschließend mit Arzt über die
        // create-Methode aus Service zu vergleichen
        Arzt manuellErzeugterArzt = null;
        try {
            manuellErzeugterArzt = new Arzt("Max", "Mustermann", formatter
                    .parse(formatter.format(new Date(19, 04, 2012))),
                    SystemNutzer.Geschlecht.MAENNLICH, "000", "1234",
                    "055501234", "max@mustermann.de", "Maxstraße", "12", "A",
                    "701668", "Maxstadt");
        } catch (ParseException e) {
            JOptionPane.showMessageDialog(null,
                    "Es gab beim Umwandeln vom Geburtsdatum folgenden fehler:"
                            + e.getStackTrace());
        }

        assertEquals(manuellErzeugterArzt.getNachname(), arzt.getNachname());
        assertEquals(SWPHelper.verschluessele(manuellErzeugterArzt
                .getPasswort()), arzt.getPasswort());
        assertEquals(manuellErzeugterArzt.getSozialversicherungsNummer(), arzt
                .getSozialversicherungsNummer());
        assertEquals(manuellErzeugterArzt.getVorname(), arzt.getVorname());
        assertEquals(manuellErzeugterArzt.getAdresse().getHausnummer(), arzt
                .getAdresse().getHausnummer());
        assertEquals(manuellErzeugterArzt.getAdresse().getPlz(), arzt
                .getAdresse().getPlz());
        assertEquals(manuellErzeugterArzt.getAdresse().getStrasse(), arzt
                .getAdresse().getStrasse());
        assertEquals(manuellErzeugterArzt.getAdresse().getZusatz(), arzt
                .getAdresse().getZusatz());
        assertEquals(manuellErzeugterArzt.getAktullAusgewaehlterPatient(), arzt
                .getAktullAusgewaehlterPatient());
        assertEquals(manuellErzeugterArzt.getGeburtsDatum(), arzt
                .getGeburtsDatum());
        assertEquals(manuellErzeugterArzt.getGeschlecht(), arzt.getGeschlecht());
        assertEquals(manuellErzeugterArzt.getKontakt().getEmailAdresse(), arzt
                .getKontakt().getEmailAdresse());
        assertEquals(manuellErzeugterArzt.getKontakt().getTelefonnummer(), arzt
                .getKontakt().getTelefonnummer());
        assertEquals(manuellErzeugterArzt.getRolle(), arzt.getRolle());
        if (manuellErzeugterArzt.getPatientenListe() != null
                && arzt.getPatientenListe() != null) {
            assertEquals(manuellErzeugterArzt.getPatientenListe().size(), arzt
                    .getPatientenListe().size());
        }

        if (manuellErzeugterArzt.getPatientenEintraege() != null
                && arzt.getPatientenEintraege() != null) {
            assertEquals(manuellErzeugterArzt.getPatientenEintraege().size(),
                    arzt.getPatientenEintraege().size());
        }

    }

    public void testCreatePatient() {
        // Manuell Patient erzeugen um es anschließend mit Patient über
        // die
        // create-Methode aus Service zu vergleichen

        assertEquals(vergelichsPatient.getNachname(), patient.getNachname());
        assertEquals(SWPHelper.verschluessele(vergelichsPatient.getPasswort()),
                patient.getPasswort());
        assertEquals(vergelichsPatient.getSozialversicherungsNummer(), patient
                .getSozialversicherungsNummer());
        assertEquals(vergelichsPatient.getVorname(), patient.getVorname());
        assertEquals(vergelichsPatient.getAdresse().getHausnummer(), patient
                .getAdresse().getHausnummer());
        assertEquals(vergelichsPatient.getAdresse().getPlz(), patient
                .getAdresse().getPlz());
        assertEquals(vergelichsPatient.getAdresse().getStrasse(), patient
                .getAdresse().getStrasse());
        assertEquals(vergelichsPatient.getAdresse().getZusatz(), patient
                .getAdresse().getZusatz());
        assertEquals(vergelichsPatient.getGeburtsDatum(), patient
                .getGeburtsDatum());
        assertEquals(vergelichsPatient.getGeschlecht(), patient.getGeschlecht());
        assertEquals(vergelichsPatient.getKontakt().getEmailAdresse(), patient
                .getKontakt().getEmailAdresse());
        assertEquals(vergelichsPatient.getKontakt().getTelefonnummer(), patient
                .getKontakt().getTelefonnummer());
        assertEquals(vergelichsPatient.getRolle(), patient.getRolle());
    }

    public void testCreatePatientenAkte() throws ParseException {
        // PatientenAkte erzeugen
        service.createPatientenAkte(patient);
        akte = patient.getAkte();
        // Andere PatientenAkte wegen Vergleich erzeugen
        PatientenAkte patientenAkte = null;
        patientenAkte = new PatientenAkte(vergelichsPatient);

        assertEquals(patientenAkte.getPatient().getNachname(), akte
                .getPatient().getNachname());
        assertEquals(SWPHelper.verschluessele(patientenAkte.getPatient()
                .getPasswort()), akte.getPatient().getPasswort());
        assertEquals(patientenAkte.getPatient().getSozialversicherungsNummer(),
                akte.getPatient().getSozialversicherungsNummer());
        assertEquals(patientenAkte.getPatient().getVorname(), akte.getPatient()
                .getVorname());
        assertEquals(patientenAkte.getPatient().getAdresse().getHausnummer(),
                akte.getPatient().getAdresse().getHausnummer());
        assertEquals(patientenAkte.getPatient().getAdresse().getPlz(), akte
                .getPatient().getAdresse().getPlz());
        assertEquals(patientenAkte.getPatient().getAdresse().getStrasse(), akte
                .getPatient().getAdresse().getStrasse());
        assertEquals(patientenAkte.getPatient().getAdresse().getZusatz(), akte
                .getPatient().getAdresse().getZusatz());
        assertEquals(patientenAkte.getPatient().getGeburtsDatum(), akte
                .getPatient().getGeburtsDatum());
        assertEquals(patientenAkte.getPatient().getGeschlecht(), akte
                .getPatient().getGeschlecht());
        assertEquals(patientenAkte.getPatient().getKontakt().getEmailAdresse(),
                akte.getPatient().getKontakt().getEmailAdresse());
        assertEquals(
                patientenAkte.getPatient().getKontakt().getTelefonnummer(),
                akte.getPatient().getKontakt().getTelefonnummer());
        assertEquals(patientenAkte.getPatient().getRolle(), akte.getPatient()
                .getRolle());

        if (patientenAkte.getEintraege() != null && akte.getEintraege() != null) {
            assertEquals(patientenAkte.getEintraege().size(), akte
                    .getEintraege().size());
        }

    }

    public void testCreatePatientenAktenEintrag() {

        // PatientenAkteEintrag erzeugen
        service.createPatientenAkte(patient);
        akte = patient.getAkte();
        service.createPatientenAktenEintrag(new Date(10, 04, 2012), arzt,
                "Befund", "Cholesterinwert ist zu hoh(über 250)", "", patient);

        service.createPatientenAkte(vergelichsPatient);
        PatientenAkte vergleichsAkte = vergelichsPatient.getAkte();
        PatientenAktenEintrag vergleichsEintrag = new PatientenAktenEintrag(
                new Date(10, 04, 2012), arzt, "Befund",
                "Cholesterinwert ist zu hoh(über 250)", "", vergelichsPatient
                        .getAkte());
        vergleichsAkte.addEintrag(vergleichsEintrag);
        assertEquals(vergleichsAkte.getEintraege().get(0).getAblageLink(), akte
                .getEintraege().get(0).getAblageLink());
        assertEquals(vergleichsAkte.getEintraege().get(0).getArztName(), akte
                .getEintraege().get(0).getArztName());
        assertEquals(vergleichsAkte.getEintraege().get(0).getBezeichnung(),
                akte.getEintraege().get(0).getBezeichnung());
        assertEquals(vergleichsAkte.getEintraege().get(0).getKurzNotiz(), akte
                .getEintraege().get(0).getKurzNotiz());
        assertEquals(vergleichsAkte.getEintraege().get(0).getAnlegeDatum(),
                akte.getEintraege().get(0).getAnlegeDatum());
    }

    public void testCreatePflegekraft() {
        // Manuell Pflegekraft erzeugen um es anschließend mit Pflegekraft über
        // die
        // create-Methode aus Service zu vergleichen
        Pflegekraft manuellErzeugterPflegekraft = null;
        try {
            manuellErzeugterPflegekraft = new Pflegekraft("Max", "Mustermann",
                    formatter.parse(formatter.format(new Date(19, 04, 2012))),
                    SystemNutzer.Geschlecht.MAENNLICH,
                    "SozialversicherungsN1dsfdf234", "1234", "055501234",
                    "max@mustermann.de", "Maxstraße", "12", "A", "701668",
                    "Maxstadt");
        } catch (ParseException e) {
            JOptionPane.showMessageDialog(null,
                    "Es gab beim Umwandeln vom Geburtsdatum folgenden fehler:"
                            + e.getStackTrace());
        }

        assertEquals(manuellErzeugterPflegekraft.getNachname(), pflegekraft
                .getNachname());
        assertEquals(SWPHelper.verschluessele(manuellErzeugterPflegekraft
                .getPasswort()), pflegekraft.getPasswort());
        assertEquals(
                manuellErzeugterPflegekraft.getSozialversicherungsNummer(),
                pflegekraft.getSozialversicherungsNummer());
        assertEquals(manuellErzeugterPflegekraft.getVorname(), pflegekraft
                .getVorname());
        assertEquals(manuellErzeugterPflegekraft.getAdresse().getHausnummer(),
                pflegekraft.getAdresse().getHausnummer());
        assertEquals(manuellErzeugterPflegekraft.getAdresse().getPlz(),
                pflegekraft.getAdresse().getPlz());
        assertEquals(manuellErzeugterPflegekraft.getAdresse().getStrasse(),
                pflegekraft.getAdresse().getStrasse());
        assertEquals(manuellErzeugterPflegekraft.getAdresse().getZusatz(),
                pflegekraft.getAdresse().getZusatz());
        assertEquals(manuellErzeugterPflegekraft.getGeburtsDatum(), pflegekraft
                .getGeburtsDatum());
        assertEquals(manuellErzeugterPflegekraft.getGeschlecht(), pflegekraft
                .getGeschlecht());
        assertEquals(
                manuellErzeugterPflegekraft.getKontakt().getEmailAdresse(),
                pflegekraft.getKontakt().getEmailAdresse());
        assertEquals(manuellErzeugterPflegekraft.getKontakt()
                .getTelefonnummer(), pflegekraft.getKontakt()
                .getTelefonnummer());
        assertEquals(manuellErzeugterPflegekraft.getRolle(), pflegekraft
                .getRolle());
        if (manuellErzeugterPflegekraft.getPatientenListe() != null
                && pflegekraft.getPatientenListe() != null)
            assertEquals(manuellErzeugterPflegekraft.getPatientenListe(),
                    pflegekraft.getPatientenListe());

    }

    public void testEntferneSystemNutzer() {

    }

    public void testGetPatient() {

    }

    public void testGetSystemNutzer() {

    }

    public void testStore() {

    }

    public void testSucheAdministratorNachSozialversicherungsnummer() {
        String containsString1 = "11";
        String containsString2 = "111";
        String wrongString = "§$%&";
        List<Administrator> adminnistratorListe = service
             .sucheAdministratorNachSozialversicherungsnummer(containsString1);

        Iterator<Administrator> iterator = adminnistratorListe.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString1));
        }

        iterator = adminnistratorListe.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString2));
        }

        iterator = adminnistratorListe.iterator();
        while (iterator.hasNext()) {
            assertFalse(iterator.next().getSozialversicherungsNummer().contains(
                    wrongString));
        }
    }

    public void testSucheArztNachBenutzername() {

    }

    public void testSucheArztNachSozialversicherungsnummer() {
        String containsString1 = "00";
        String containsString2 = "000";
        String wrongString = "§$%&";

        List<Arzt> arztliste = service
                .sucheArztNachSozialversicherungsnummer(containsString1);

        Iterator<Arzt> iterator = arztliste.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString1));
        }

        iterator = arztliste.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString2));
        }

        iterator = arztliste.iterator();
        while (iterator.hasNext()) {
            assertFalse(iterator.next().getSozialversicherungsNummer().contains(
                    wrongString));
        }
    }

    public void testSuchePatientenAkteNachPatient() {

    }

    public void testSuchePatientNachSozialversicherungsnummer() {

        String containsString1 = "22";
        String containsString2 = "222";
        String wrongString = "§$%&";

        List<Patient> patientListe = service
                .suchePatientNachSozialversicherungsnummer(containsString1);

        Iterator<Patient> iterator = patientListe.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString1));
        }

        iterator = patientListe.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString2));
        }

        iterator = patientListe.iterator();
        while (iterator.hasNext()) {
            assertFalse(iterator.next().getSozialversicherungsNummer().contains(
                    wrongString));
        }


    }

    public void testSuchePflegekraftNachBenutzername() {

    }

    public void testSuchePflegekraftNachSozialversicherungsnummer() {

        String containsString1 = "22";
        String containsString2 = "222";
        String wrongString = "§$%&";

        List<Pflegekraft> pflegekraftListe = service
                .suchePflegekraftNachSozialversicherungsnummer(containsString1);

        Iterator<Pflegekraft> iterator = pflegekraftListe.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString1));
        }

        iterator = pflegekraftListe.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString2));
        }

        iterator = pflegekraftListe.iterator();
        while (iterator.hasNext()) {
            assertFalse(iterator.next().getSozialversicherungsNummer().contains(
                    wrongString));
        }


    }

    public void testSucheSystemNutzerNachId() {

    }

    public void testSucheSystemnutzerNachSozialversicherungsN() {

        String containsString1 = "00";
        String containsString2 = "000";
        String wrongString = "§$%&";

        List<SystemNutzer> systemNutzerListe = (List<SystemNutzer>) service
                .sucheSystemnutzerNachSozialversicherungsN(containsString1);

        Iterator<SystemNutzer> iterator = systemNutzerListe.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString1));
        }

        iterator = systemNutzerListe.iterator();
        while (iterator.hasNext()) {
            assertTrue(iterator.next().getSozialversicherungsNummer().contains(
                    containsString2));
        }

        iterator = systemNutzerListe.iterator();
        while (iterator.hasNext()) {
            assertFalse(iterator.next().getSozialversicherungsNummer().contains(
                    wrongString));
        }

    }

    public void testValidateAuthification() {

    }

    // public void sucheSystemnutzerNachSozialversicherungsNService(String
    // sozialN) {
    // systemNutzer = service.sucheSystemnutzerNachSozialversicherungsN(
    // sozialN);
    //
    // }

    /**
     * diese methode testeet suchePatientNachBenutzername vom service
     *
     * @param nachname
     */
    // public void testSuchePatientNachBenutzername() {
    // String nachname = patient.getNachname();
    //
    //
    // assert (nachname != null);
    // if ("".equals(nachname))
    // nachname = "%";
    // // suchePatientNachBenutzernameService(nachname);
    //
    // ArrayList<Patient> testPatientListe = null;
    // this.patientListe =
    // (ArrayList<Patient>)service.suchePatientNachBenutzername(nachname);
    //
    //
    //
    // Query query = entityManagerTest
    // .createQuery("Select patient from Patient patient where patient.nachname like :nachname");
    // query.setParameter("nachname", nachname);
    //
    // testPatientListe =
    // (ArrayList<Patient>)Collections.unmodifiableList(query.getResultList());
    //
    // for (int i = 0; i<testPatientListe.size()&& i<patientListe.size(); i++) {
    // Patient testPatient = testPatientListe.get(i);
    // this.patient = patientListe.get(i);
    //
    // assertEquals(testPatient.getNachname(), patient.getNachname());
    // assertEquals(testPatient.getPasswort(), patient.getPasswort());
    // assertEquals(testPatient.getSozialversicherungsNummer(), patient
    // .getSozialversicherungsNummer());
    // assertEquals(testPatient.getVorname(), patient.getVorname());
    // assertEquals(testPatient.getAdresse().getHausnummer(), patient
    // .getAdresse().getHausnummer());
    // assertEquals(testPatient.getAdresse().getPlz(), patient
    // .getAdresse().getPlz());
    // assertEquals(testPatient.getAdresse().getStrasse(), patient
    // .getAdresse().getStrasse());
    // assertEquals(testPatient.getAdresse().getZusatz(), patient
    // .getAdresse().getZusatz());
    // assertEquals(testPatient.getGeburtsDatum(), patient
    // .getGeburtsDatum());
    // assertEquals(testPatient.getGeschlecht(), patient.getGeschlecht());
    // assertEquals(testPatient.getKontakt().getEmailAdresse(), patient
    // .getKontakt().getEmailAdresse());
    // assertEquals(testPatient.getKontakt().getTelefonnummer(), patient
    // .getKontakt().getTelefonnummer());
    // assertEquals(testPatient.getRolle(), patient.getRolle());
    // }
    // }
    //
    // //
    // // private void suchePatientNachBenutzernameService(String nachname) {
    // // this.patientListe =
    // (ArrayList<Patient>)service.suchePatientNachBenutzername(nachname);
    // // }
    //
    // public void testSucheSystemnutzerNachSozialversicherungsN() {
    // String sozialN = patient.getSozialversicherungsNummer();
    // systemNutzer =
    // service.sucheSystemnutzerNachSozialversicherungsN(sozialN);
    // SystemNutzer testSystemNutzer;
    // assert !sozialN.equals(null);
    // assert !sozialN.equals("");
    //
    // List<SystemNutzer> systemNutzerListe = (List<SystemNutzer>)
    // entityManagerTest
    // .createNamedQuery("SystzemNutzer.sucheSystemNutzerNachSozialN")
    // .setParameter("sozialN", sozialN).getResultList();
    // if (systemNutzerListe.size() == 1) {
    // testSystemNutzer = systemNutzerListe.get(0);
    // }else {
    // testSystemNutzer = null;
    // }
    //
    // assertEquals(testSystemNutzer.getAdresse(), systemNutzer.getAdresse());
    // assertEquals(testSystemNutzer.getGeburtsDatum(),
    // systemNutzer.getGeburtsDatum());
    // assertEquals(testSystemNutzer.getGeschlecht(),
    // systemNutzer.getGeschlecht());
    // assertEquals(testSystemNutzer.getKontakt(), systemNutzer.getKontakt());
    // assertEquals(testSystemNutzer.getNachname(), systemNutzer.getNachname());
    // assertEquals(testSystemNutzer.getNutzerID(), systemNutzer.getNutzerID());
    // assertEquals(testSystemNutzer.getPasswort(), systemNutzer.getPasswort());
    // assertEquals(testSystemNutzer.getRolle(), systemNutzer.getRolle());
    // assertEquals(testSystemNutzer.getSozialversicherungsNummer(),
    // systemNutzer.getSozialversicherungsNummer());
    // assertEquals(testSystemNutzer.getVorname(), systemNutzer.getVorname());
    // assertEquals(testSystemNutzer.isDeaktiviert(),
    // systemNutzer.isDeaktiviert());
    //
    // }

    // private void sucheArztNachBenutzernameService(String nachname) {
    // this.arztListe =
    // (ArrayList<Arzt>)service.sucheArztNachBenutzername(nachname);
    // }

    protected void tearDown() throws Exception {
        super.tearDown();
    }

}