from parse.StoryMap import StoryMap, FragmentSlice
from enum import Enum
from typing import Dict, List


class ModifyReason(Enum):
    Removed = 0,
    Append = 1,
    Changed = 2,
    Nothing = 4,


class CmpTool:
    def __init__(self):
        pass

    def graph_compare(self, graph_new: Dict[str, StoryMap], graph_old: Dict[str, StoryMap]) -> Dict[ModifyReason, FragmentSlice]:
        fragments_has_removed = []
        for story in graph_old.values():
            fragments_has_removed = fragments_has_removed + self.__event_remove_check(graph_new, story)
            pass

        fragments_has_appended = []
        for story in graph_new.values():
            fragments_has_appended = fragments_has_appended + self.__event_append_check(graph_old, story)
            pass

        fragments_has_changed = []
        for story in graph_new.values():
            fragments_has_changed = fragments_has_changed + self.__event_changed_check(graph_old, story)
            pass

        return {
            ModifyReason.Removed: fragments_has_removed,
            ModifyReason.Append: fragments_has_appended,
            ModifyReason.Changed: fragments_has_changed,
        }

    def __event_remove_check(self, graph_new: Dict[str, StoryMap], story_old: StoryMap) -> List[FragmentSlice]:
        list_retv = []
        for slice in story_old.slice_list[1:]:
            if slice.is_define_node[0]:
                s_name = story_old.story_name
                f_name = slice.is_define_node[1]
                story_findout = graph_new[s_name]
                if story_findout is None or story_findout.get_fragment_defined(f_name) is None:
                    list_retv.append(slice)
                    pass
                pass
            pass
        return list_retv

    def __event_append_check(self, graph_old: Dict[str, StoryMap], story_new: StoryMap) -> List[FragmentSlice]:
        list_retv = []
        for slice in story_new.slice_list[1:]:
            if slice.is_define_node[0]:
                s_name = story_new.story_name
                f_name = slice.is_define_node[1]
                story_findout = graph_old[s_name]
                if story_findout is None or story_findout.get_fragment_defined(f_name) is None:
                    list_retv.append(slice)
                    pass
                pass
            pass
        return list_retv

    def __event_changed_check(self, graph_old: Dict[str, StoryMap], story_new: StoryMap) -> List[FragmentSlice]:
        story_old = graph_old[story_new.story_name]
        if story_old is not None:
            return self.__event_changed_chack_for(story_old, story_new)
        return []

    def __event_changed_chack_for(self, story_old: StoryMap, story_new: StoryMap) -> List[FragmentSlice]:
        list_retv = []
        for fragm_curr in story_new.slice_list[1:]:
            if fragm_curr.is_define_node[0]:
                fragm_prev = story_old.get_fragment_defined(fragm_curr.is_define_node[1])
                if fragm_prev is not None:
                    if fragm_curr.fragm_sort_i != fragm_prev.fragm_sort_i:
                        list_retv.append(fragm_curr)
                        pass

                    if len(fragm_curr.text_sections) != len(fragm_prev.text_sections):
                        list_retv.append(fragm_curr)
                    elif fragm_curr.text_sections != fragm_prev.text_sections:
                        list_retv.append(fragm_curr)
                        pass
                    pass
                pass
            pass
        return list_retv