from rasa_core_sdk import Action
from rasa_core_sdk.events import SlotSet

#
# Birthplace
#
class ActionSearchBirthplace(Action):
    def name(self):
        return 'action_search_birthplace'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        dispatcher.utter_message("Person found:" + person)
        #import csv
        #import re
        #person = tracker.get_slot('physicist')
        #name_regex = re.compile(person, re.IGNORECASE)
        #actual_birthplace = None
        #with open('data.tsv') as csvfile:
        #    spamreader = csv.DictReader(csvfile, delimiter='\t')
        #    for row in spamreader:
        #        if name_regex.match(row['name']):
        #            actual_birthplace = row['birthplace']
        #if actual_birthplace is None:
        return[SlotSet('birthplace', [])]
        #return [SlotSet('birthplace', actual_birthplace if actual_birthplace is not None else [])]
        
        
class ActionUtterBirthplace(Action):
    def name(self):
        return 'action_utter_birthplace'

    def run(self, dispatcher, tracker, domain):
        #person = tracker.get_slot('physicist')
        #birthplace = tracker.get_slot('birthplace')
        #if  birthplace == None:
        #    dispatcher.utter_message("Error: Birthplace of " + person + " not   
        #    known.")
        #else:
        #    dispatcher.utter_message("The birthplace of " + person + " is " + 
        #    birthplace + ".")
        return []

#
# Day of death
#
class ActionSearchDayOfDeath(Action):
    def name(self):
        return 'action_search_day_of_death'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_day_of_death = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_day_of_death = row['day_of_death']
        if actual_day_of_death is None:
            return[SlotSet('day_of_death', [])]
        return [SlotSet('day_of_death', actual_day_of_death if actual_day_of_death is not None else [])]
        
        
class ActionUtterDayOfDeath(Action):
    def name(self):
        return 'action_utter_day_of_death'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        day_of_death = tracker.get_slot('day_of_death')
        if  day_of_death == None:
            dispatcher.utter_message("Error: day of death of " + person + "not known.")
        else:
            dispatcher.utter_message("The day of death of " + person + " is " + day_of_death + ".")
        return []

#
# Place of death
#
class ActionSearchPlaceOfDeath(Action):
    def name(self):
        return 'action_search_place_of_death'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_place_of_death = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_place_of_death = row['place_of_death']
        if actual_place_of_death is None:
            return[SlotSet('place_of_death', [])]
        return [SlotSet('place_of_death', actual_place_of_death if actual_place_of_death is not None else [])]
        
        
class ActionUtterPlaceOfDeath(Action):
    def name(self):
        return 'action_utter_place_of_death'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        place_of_death = tracker.get_slot('place_of_death')
        if  place_of_death == None:
            dispatcher.utter_message("Error: Place of death of " + person + "not known.")
        else:
            dispatcher.utter_message("The place of death of " + person + " is " + place_of_death + ".")
        return []

#
# Is alive
#
class ActionSearchIsAlive(Action):
    def name(self):
        return 'action_search_is_alive'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        if person == None:
            dispatcher.utter_message("Person nicht gefunden")
            return []
        name_regex = re.compile(person, re.IGNORECASE)
        actual_is_alive = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_is_alive = row['is_alive']
        if actual_is_alive is None:
            return[SlotSet('is_alive', [])]
        return [SlotSet('is_alive', actual_is_alive if actual_is_alive is not None else [])]
        
        
class ActionUtterPlaceOfDeath(Action):
    def name(self):
        return 'action_utter_is_alive'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        is_alive = tracker.get_slot('is_alive')
        if  is_alive == None:
            dispatcher.utter_message("Error: Life status of " + person + "not known.")
        else:
            dispatcher.utter_message("The Life status of " + person + " is " + is_alive + ".")
        return []

#
# num spouses
#
class ActionSearchNumSpouses(Action):
    def name(self):
        return 'action_search_num_spouses'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_num_spouses = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_num_spouses = row['num_spouses']
        if actual_num_spouses is None:
            return[SlotSet('num_spouses', [])]
        return [SlotSet('num_spouses', actual_num_spouses if actual_num_spouses is not None else [])]
        
        
class ActionUtterNumSpouses(Action):
    def name(self):
        return 'action_utter_num_spouses'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        num_spouses = tracker.get_slot('num_spouses')
        if num_spouses == None:
            dispatcher.utter_message("Error: Number of Spouses of " + person + "not known.")
        else:
            dispatcher.utter_message("The Number of spouses of " + person + " is " + num_spouses + ".")
        return []

#
# Primary Education
#
class ActionSearchPrimaryEducation(Action):
    def name(self):
        return 'action_search_primary_education'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_primary_education = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_primary_education = row['primary_education']
        if actual_primary_education is None:
            return[SlotSet('primary_education', [])]
        return [SlotSet('primary_education', actual_primary_education if actual_primary_education is not None else [])]
        
        
class ActionUtterPrimaryEducation(Action):
    def name(self):
        return 'action_utter_primary_education'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        primary_education = tracker.get_slot('primary_education')
        if  primary_education == None:
            dispatcher.utter_message("Error: Primary education of " + person + "not known.")
        else:
            dispatcher.utter_message("The primary education of " + person + " is " + primary_education + ".")
        return []

#
# University
#
class ActionSearchUniversity(Action):
    def name(self):
        return 'action_search_university'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_university = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_university = row['university']
        if actual_university is None:
            return[SlotSet('university', [])]
        return [SlotSet('university', actual_university if actual_universtiy is not None else [])]
        
        
class ActionUtterAreaOfResearch(Action):
    def name(self):
        return 'action_utter_area_of_research'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        area_of_research = tracker.get_slot('area_of_research')
        if area_of_research == None:
            dispatcher.utter_message("Error: Area of Research of " + person + "not known.")
        else:
            dispatcher.utter_message("The Area of research of " + person + " is " + area_of_research + ".")
        return []

#
# Workplace
#
class ActionSearchWorkplace(Action):
    def name(self):
        return 'action_search_workplace'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_workplace = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_workplace = row['workplace']
        if actual_workplace is None:
            return[SlotSet('workplace', [])]
        return [SlotSet('workplace', actual_workplace if actual_workplace is not None else [])]
        
        
class ActionUtterWorkplace(Action):
    def name(self):
        return 'action_utter_workplace'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        workplace = tracker.get_slot('workplace')
        if  workplace == None:
            dispatcher.utter_message("Error: Workplace of " + person + "not known.")
        else:
            dispatcher.utter_message("The Workplace of " + person + " is " + workplace + ".")
        return []

#
# Awards
#
class ActionSearchAwards(Action):
    def name(self):
        return 'action_search_awards'

    def run(self, dispatcher, tracker, domain):
        import csv
        import re
        person = tracker.get_slot('physicist')
        name_regex = re.compile(person, re.IGNORECASE)
        actual_awards = None
        with open('data.tsv') as csvfile:
            spamreader = csv.DictReader(csvfile, delimiter='\t')
            for row in spamreader:
                if name_regex.match(row['name']):
                    actual_awards = row['awards']
        if actual_awards is None:
            return[SlotSet('awards', [])]
        return [SlotSet('awards', actual_awards if actual_awards is not None else [])]
        
        
class ActionUtterAwards(Action):
    def name(self):
        return 'action_utter_awards'

    def run(self, dispatcher, tracker, domain):
        person = tracker.get_slot('physicist')
        awards = tracker.get_slot('awards')
        if  awards == None:
            dispatcher.utter_message("Error: Awards of " + person + "not known.")
        else:
            dispatcher.utter_message("The Awards of " + person + " is " + awards + ".")
        return []