"""
Console -> quit

"""

from Service.PersoanaService import Service_Persoana
from Repository.InMemoriePersoane import RepoPersoane,RepoPersExceptie
from Domain.Validator_Persoana import PersoanaValidator, ExceptiePersoana

from Service.EvenimentService import EvenimenteService
from Repository.InMemorieEvenimente import RepoEvenimente,RepoEvenimenteExceptie
from Domain.Validator_Eveniment import ValidatorEvenimente, ExceptieEvenimente

class consola():
    """
    Consola
    """

    def __init__(self, servicep, servicee):
        self.__servicep = servicep
        self.__servicee = servicee

    def afiseaza_persoane(self):
        """
        Functie ce imi afiseaza persoanele
        """
        Persoane = self.__servicep.get_persoane()
        if (Persoane == ""):
            print("Nu s persoane ! ")
        else:
            for pers in Persoane:
                print( pers.get_personId(), pers.get_nume(), pers.get_adresa())

    def adauga_persoana(self):
        print()
        id_p = input("Introduceti id ul ")
        name = input("Introduceti numele ")
        adress = input("Introduceti adresa ")
        try:
            self.__servicep.Create_person(id_p, name, adress)
        except ExceptiePersoana as ex:
            print("Nu e bine ")
        except RepoPersExceptie as ex:
            print("Nu e bine ")


    def sterg_persoana(self):
        id_p = input("Stergeti persoana cu id ul ")
        return self.__servicep.sterg_persoana(id_p)

    def afiseaza_evenimente(self):
        """
        Functie ce imi afiseaza evenimentele
        """
        Evenimente = self.servicee.get_evenimente()
        if (Evenimente == ""):
            print("Nu s persoane ! ")
        else:
            for Eveniment in Evenimente:
                print(Eveniment.get_id(), Eveniment.get_data(), Eveniment.get_timp(), Eveniment.get_descriere())

    def adauga_eveniment(self):
        print()
        id = input("Introduceti id ul ")
        data = input("Introduceti data ")
        timp = input("Introduceti timp ")
        descriere = input("Introduceti descrierea ")
        try:
            self.__servicee.create_eveniment(id, data, timp, descriere)
        except RepoEvenimenteExceptie() as ex:
            print("Nu e bine ")
        except ExceptieEvenimente() as ex:
            print("Nu e bine ")



    def showUi(self):
        while True:
            print("[1] -> Persoane ")
            print("[2] -> Evenimente\n ")
            try:
                alegere = int(input())
            except ValueError as ve:
                print("Nu merge")

            #Daca alegem persoanele
            if (alegere == 1):
                print()
                print("[1] -> Adaugare persoana ")
                print("[2] -> Afisare persoane ")
                print("[3] -> Stergere persoana ")
                print("[4] -> Modificare persoana \n")
                try:
                    ce_fac = int(input())
                except ValueError as ve:
                    print("Nu merge")

                if(ce_fac == 1):
                    self.adauga_persoana()
                if(ce_fac == 2):
                    self.afiseaza_persoane()
                if(ce_fac == 3):
                    self.sterg_persoana()
                if(ce_fac == 4):
                    self.adauga_persoana()

            if (alegere == 2):
                print()
                print("[1] -> Adaugare eveniment ")
                print("[2] -> Afisare evenimente ")
                print("[3] -> Stergere eveniment ")
                print("[4] -> Modificare eveniment \n")
                try:
                    ce_fac = int(input())
                except ValueError as ve:
                    print("Nu merge")

                if (ce_fac == 1):
                    self.adauga_eveniment()
                if (ce_fac == 2):
                    self.afiseaza_evenimente()
                if (ce_fac == 3):
                    pass
                if (ce_fac == 4):
                    pass



validatorPersoana = PersoanaValidator()
repoPersoane = RepoPersoane()
servicePersoane = Service_Persoana(validatorPersoana, repoPersoane)

validatorEveniment = ValidatorEvenimente()
repoEvenimente = RepoEvenimente()
serviceEvenimente = EvenimenteService(validatorEveniment, repoEvenimente)

Consola = consola(servicePersoane,serviceEvenimente)

Consola.showUi()

'''
Created on 15 nov. 2018
Entitate eveniment

@author: Edy
'''

class eveniment(object):
    '''
    Clasa unui eveniment
    Contine: : id, data, timp, descriere
    '''

    def __init__(self, id, data, timp, descriere):
        '''
        Constructor
        '''
        self.__id = id
        self.__data = data
        self.__timp = timp
        self.__descriere = descriere

    def get_id(self):
        return self.__id

    def get_data(self):
        return self.__data

    def get_timp(self):
        return self.__timp

    def get_descriere(self):
        return self.__descriere

    def __eq__(self, eveniment2):
        return self.get_id() == eveniment2.get_id()

def test_creare_eveniment():
    Eveniment = eveniment("123", "20.11", "2 ore", "Muzica")
    assert Eveniment.get_id() == "123"
    assert Eveniment.get_data() == "20.11"
    assert Eveniment.get_timp() == "2 ore"
    assert Eveniment.get_descriere() == "Muzica"

def test_egalitate_evenimente():
    Eveniment1 = eveniment("123", "20.11", "2 ore", "Muzica")
    Eveniment2 = eveniment("123", "20.11", "2 ore", "Muzica")
    assert Eveniment1 == Eveniment2

test_creare_eveniment()
test_egalitate_evenimente()

'''
Created on 15 nov. 2018

Entitatea persoana
@author: Edy
'''

class persoana(object):
    '''
    Clasa unei persoane
    Contine : Id, Nume, Adresa
    '''

    def __init__(self, personId, nume, adresa):
        '''
        Constructor
        '''
        self.__personId = personId
        self.__nume = nume
        self.__adresa = adresa

    def get_personId(self):
        return self.__personId

    def get_nume(self):
        return self.__nume

    def get_adresa(self):
        return self.__adresa

    def __eq__(self,person):
        #Egalitatea dintre 2 persoane se face dupa id
        return self.get_personId() == person.get_personId()

def test_creare_persoana():
    #Testez daca merge crearea unei persoane
    Persoana = persoana("12", "Ion", "Adress")
    assert Persoana.get_personId() == "12"
    assert Persoana.get_nume() == "Ion"
    assert Persoana.get_adresa() == "Adress"

def test_egalitate():
    Persoana1 = persoana("123", "Mihai", "Adr")
    Persoana2 = persoana("123", "Mihai", "Adr")
    assert Persoana1 == Persoana2

test_creare_persoana()
test_egalitate()


'''
Created on 15 nov. 2018

Validam persoana

@author: Edy
'''

from Domain.Entitate_Persoana import persoana

class ExceptiePersoana(Exception):
    #Exceptia
    def __init__(self, erori):
        self.__erori = erori

    def get_erori(self):
        return self.__erori


class PersoanaValidator:

    def validate(self, person):
        erori = []

        if (person.get_personId() == ""):
            erori.append("Id ul nu poate fi gol ")

        if (person.get_nume() == ""):
            erori.append("Numele nu poate fi gol")

        if(person.get_adresa() == ""):
            erori.append("Adresa nu poate fi goala")

        if len(erori) > 0:
            raise ExceptiePersoana(erori)

def test_validator():
    # Functie de testare a validatorului
    validator= PersoanaValidator()
    Persoana1 = persoana("", "", "")

    try:
        validator.validate(Persoana1)
        assert False
    except ExceptiePersoana as ex:
        assert len(ex.get_erori()) == 3

    Persoana2 = persoana("asd", "", "")

    try:
        validator.validate(Persoana2)
        assert False
    except ExceptiePersoana as ex:
        assert len(ex.get_erori()) == 2

    Persoana3 = persoana("ads", "dsad", "dsa")
    try:
        validator.validate(Persoana3)
        assert True
    except ExceptiePersoana as ex:
        assert False

test_validator()

"""

Modul pentru validarea evenimentelor


"""

from Domain.Entitate_Eveniment import eveniment

class ExceptieEvenimente(Exception):
    def __init__(self, erori):
        self.__erori = erori

    def get_erori(self):
        return self.__erori


class ValidatorEvenimente():
    """
    Clasa pentru validarea evenimentelor
    """

    def validate(self, Eveniment):

        #id, data, timp, descriere

        erori = []
        if (Eveniment.get_id() == ""):
            erori.append("Id ul nu poate fi gol ")
        if (Eveniment.get_data() == ""):
            erori.append("Data nu poate fi goala ")
        if (Eveniment.get_timp() == ""):
            erori.append("Timpul nu poate fi gol" )
        if(Eveniment.get_descriere() == ""):
            erori.append("Descrierea nu poate fi goala ")

        if len(erori) > 0:
            raise ExceptieEvenimente(erori)

def test_validator_evenimente():
    validator = ValidatorEvenimente()

    Eveniment1 = eveniment("", "", "", "")
    try:
        validator.validate(Eveniment1)
        assert False
    except ExceptieEvenimente as ex:
        assert len(ex.get_erori()) == 4

    Eveniment2 = eveniment("asd", "aa","","")
    try:
        validator.validate(Eveniment2)
        assert False
    except ExceptieEvenimente as ex:
        assert len(ex.get_erori()) == 2

    Eveniment3 = eveniment("s","s","asd","a")
    try:
        validator.validate(Eveniment3)
        assert True
    except ExceptieEvenimente as ex:
        assert False

test_validator_evenimente()


 '''
Created on 16 nov. 2018

Modul pentru stocarea evenimentelor

@author: Edy
'''

from Domain.Entitate_Eveniment import eveniment

class RepoEvenimenteExceptie(Exception):
    pass

class RepoEvenimente():
    """
    Repository pt evenimente
    """

    def __init__(self):
        self.__Evenimente = {}

    def store_evenimente(self, eveniment):

        if eveniment.get_id() in self.__Evenimente:
            raise RepoEvenimenteExceptie

        self.__Evenimente[eveniment.get_id()] = eveniment

    def cate_evenimente(self):
        return len(self.__Evenimente)

    def get_evenimente(self):
        return list(self.__Evenimente.values())

def test_store_evenimente():

    repo = RepoEvenimente()
    eveniment1 = eveniment("yes", "no", "3", "123")

    repo.store_evenimente(eveniment1)
    assert repo.cate_evenimente() == 1

    try:
        repo.store_evenimente(eveniment1)
        assert False
    except RepoEvenimenteExceptie as ex:
        pass

test_store_evenimente()


'''
Created on 16 nov. 2018
Service_Persoana
@author: Edy
'''
from Domain.Validator_Persoana import PersoanaValidator,ExceptiePersoana
from Domain.Entitate_Persoana import persoana
from Repository.InMemoriePersoane import RepoPersoane, RepoPersExceptie

class Service_Persoana(object):
    '''
    Service ul pentru persoana!
    '''

    def __init__(self, validator_persoana, repo_persoana_validator):
        '''
        So we create validator_entity and repo_validator
        '''
        self.__validator_persoana = validator_persoana
        self.__repo_persoana_validator = repo_persoana_validator

    def Create_person(self, id_pers, nume, adresa):
        """
        Ca o persoana sa se creeze
        Trebuie sa nu aibe id , numele or adresa -> ""
        Vom apela validator pentru persoane sa vedem daca aceasta conditie este implinita
        Pai daca e indeplinita, trebuie sa vedem si la repo_validator daca nu e cumva acolo
        In caz naspa, Raise !

        """
        #Creem persoana
        Persoana1 = persoana(id_pers, nume, adresa)

        self.__validator_persoana.validate(Persoana1)

        #Si am validat first
        #Acuma trebuie repo_validate sa isi faca treaba

        self.__repo_persoana_validator.store_persoane(Persoana1)

        return Persoana1

    def get_persoane(self):
        # Afisarea persoanelor
        return self.__repo_persoana_validator.get_persoane()

    def sterg_persoana(self, id_p):
        return self.__repo_persoana_validator.sterg_persoana(id_p)

def test_creez_persoana():

    validator_pers = PersoanaValidator()
    repo_val = RepoPersoane()
    service_pers = Service_Persoana(validator_pers, repo_val)
    try:
        service_pers.Create_person("","ion","cluj")
        assert False
    except ExceptiePersoana as ex:
        assert True
    try:
        service_pers.Create_person("123","ion","cluj")
        assert True
    except RepoPersExceptie as ex:
        assert False

test_creez_persoana()

'''
Created on 16 nov. 2018
Service Evenimente
@author: Edy
'''

from Domain.Entitate_Eveniment import eveniment, test_creare_eveniment
from Domain.Validator_Eveniment import ValidatorEvenimente, ExceptieEvenimente
from Repository.InMemorieEvenimente import RepoEvenimente
from Repository.InMemoriePersoane import RepoPersExceptie

class EvenimenteService(object):
    '''
    CRUD
    '''

    def __init__(self, validator_eveniment, validator_repo_evenimente):
        '''
        Constructor
        '''
        self.__validator_eveniment = validator_eveniment
        self.__validator_repo_evenimente = validator_repo_evenimente

    def create_eveniment(self, id, data, timp, descriere):

        Eveniment = eveniment(id, data, timp, descriere)
        self.__validator_eveniment.validate(Eveniment)
        self.__validator_repo_evenimente.store_evenimente(Eveniment)
        return Eveniment

    def get_evenimente(self):
        return self.__validator_repo_evenimente.get_evenimente()


def test_creare_eveniment():
    """ we test if Evenimente Service is working """

    Eveniment = eveniment("123","20","11","frumos")
    repo_validator = RepoEvenimente()
    validator_evenimente = ValidatorEvenimente()
    service_evenimente = EvenimenteService(validator_evenimente, repo_validator)
    try:
        service_evenimente.create_eveniment("123","20","20","untold")
        assert True
    except ExceptieEvenimente as ex:
        assert False



test_creare_eveniment()


 '''
Created on 16 nov. 2018

Modul pentru stocarea persoanelor

@author: Edy
'''
from Domain.Entitate_Persoana import persoana

class RepoPersExceptie(Exception):

    def __init__(self):
        return


class RepoPersoane():

    def __init__(self):
        self.__Persoane = {}

    def store_persoane(self, Persoana):

        if Persoana.get_personId() in self.__Persoane:
            raise RepoPersExceptie
        self.__Persoane[Persoana.get_personId()] = Persoana


    def cate_persoane(self):
        return len(self.__Persoane)

    def get_persoane(self):
        return list(self.__Persoane.values())

    def sterg_persoana(self,id_p):
        if id_p in self.__Persoane:
            del self.__Persoane[id_p]

def test_store_persoane():
    Persoana = persoana("1","john","cluj")
    rep = RepoPersoane()
    assert rep.cate_persoane() == 0
    rep.store_persoane(Persoana)
    assert rep.cate_persoane() == 1
    try:
        rep.store_persoane(Persoana)
        assert False
    except RepoPersExceptie as ex:
        pass

test_store_persoane()