"""

persistence.py:

contains what we need to make a (category) objects (see models.py) persist

beyond application scope and load them from outside sources

For now we can save, load and list

* to/from a file (using a turtle rdf graph serialization for categories)

* to/from a github repository (using a turtle rdf graph serialization

for categories)

"""

from abc import ABCMeta, abstractmethod

from catedit import github, app, log_api_rate

from base64 import b64decode

from flask.ext.github import GitHubError

import os

import json

logger = app.logger

class Persistence:

    """

        Meta-class for all persistence classes

    """

    __metaclass__ = ABCMeta

    @abstractmethod

    def session_compliant(self):

        """

            Abstract - Can this persistence submit a changeset?

        """

        return

    @abstractmethod

    def save(self, **kwargs):

        """

            Abstract - Saves object

        """

        return

    @abstractmethod

    def delete(self, **kwargs):

        """

            Abstract - Deletes object

        """

        return

    @abstractmethod

    def load(self, **kwargs):

        """

            Abstract - Loads object

        """

        return

    @abstractmethod

    def list(self, **kwargs):

        """

            Abstract - Lists objects

        """

        return

class PersistenceToFile(Persistence):

    """

        Persistence Class for saving to a local file (see config.py

        for tweaking)

        Expected kwargs for saving to/loading from a file are:

        * name : name of the file to write in/read from

        * content : desired content of the file when writing

    """

    def __init__(self, **kwargs):

        pass

    @property

    def session_compliant(self):

        """

            Not session compliant: each modification is submitted

        """

        return True

    def save(self, **kwargs):

        """

            Saves to a file

            Expected args:

            * deletion_dict

            * modification_dict

        """

        modification_dict = kwargs["modification_dict"]

        deletion_dict = kwargs["deletion_dict"]

        for (file_name, file_content) in modification_dict.items():

            path_to_save = app.config["PERSISTENCE_CONFIG"] \

                                     ["FILE_SAVE_DIRECTORY"] \

                           + file_name

            print(path_to_save)

            file_to_save = open(path_to_save, 'wb')

            file_to_save.write(bytes(file_content, "utf-8"))

            file_to_save.close()

        for file_name in deletion_dict.keys():

            path_to_delete = app.config["PERSISTENCE_CONFIG"] \

                                       ["FILE_SAVE_DIRECTORY"] \

                             + file_name

            os.remove(path_to_delete)

    def load(self, **kwargs):

        """

            Loads from a file

        """

        path_to_load = app.config["PERSISTENCE_CONFIG"]["FILE_SAVE_DIRECTORY"] \

                       + kwargs["name"]

        try:

            file_to_load = open(path_to_load, 'rb')

            file_content = str(file_to_load.read(), "utf-8")

            print(file_content)

            file_to_load.close()

        except FileNotFoundError:

            file_content=""

        return file_content

    def delete(self, **kwargs):

        """

            Deletes a file

        """

        path_to_delete = app.config["PERSISTENCE_CONFIG"] \

                                   ["FILE_SAVE_DIRECTORY"] + kwargs["name"]

        os.remove(path_to_delete)

    # IDEA: return { file_name: file_content } type dict

    def list(self, **kwargs):

        """

            Lists all files in file directory (as set in config.py)

        """

        file_content_list = []

        for file_name in os.listdir(app.config["PERSISTENCE_CONFIG"]

                                              ["FILE_SAVE_DIRECTORY"]):

            if not file_name or file_name[0] == ".":

                continue

            path_to_load = app.config["PERSISTENCE_CONFIG"] \

                                     ["FILE_SAVE_DIRECTORY"] + file_name

            file_to_load = open(path_to_load, 'rb')

            file_content = str(file_to_load.read(), "utf-8")

            file_to_load.close()

            file_content_list.append(file_content)

        # logger.debug(file_content_list)

        return file_content_list

class PersistenceToGithub(Persistence):

    """

        Persistence Class for saving to/loading from a Github repository (see

        config.py for tweaks)

        Expected kwargs for saving to/loading from a Github repository are:

        * name : name of the file to write in/read from

        * content : desired content of the file when writing

        * message : when saving or deleting, commit message to be saved

        to Github

    """

    def __init__(self, **kwargs):

        self.repository = kwargs.get("repository", "")

    @property

    def session_compliant(self):

        """

            Not session compliant: each modification is comitted

        """

        return True

    def save(self, **kwargs):

        """

            Saves all the recorded files in the session dict to a Github

            repository

            Expected kwargs is:

            * message: the commit message to document the changes

            * deletion_dict : a dict where the keys are the name of the files

            to delete, from the category repository (defined in

            config["CATEGORIES_PATH"]), currently value is a fixed

            string

                {cat_id: "deleted"}

            * modification_dict: a dict where they keys are the name of the

            files that changed and the values are the contents of said files

                {name_of_the_file: content_of_the_file}

            IMPORTANT: To save to a file Github, we have to use Git

            internal mechanics:

            1) Get the current reference for master branch

            2) Get the latest commit on that reference

            3) Get the tree associated to this commit

            4) Create a new tree using the old tree and the session dict that

            contains all the changes (keys are "modified_categories" and

            "deleted_categories")

                4-1) This requires creating new blobs for new files

            5) Create a new commit referencing the previous commit as parent

            and the new tree we just created

            6) Update the master branch reference so it points on this new

            commit

            About point 4):

            We have 3 list of elements: files already in repo, modified files,

            and deleted_files

            First, we loop on the files already in repo: this allows us to

            update it (if it's in both original file list and modified files

            list) or delete it (if it's in both original file list and deleted

            files list)

            Then, we loop on the modified files list. If it isn't in the

            original file list, then it's a new file and we append it to the

            tree

        """

        deletion_dict = kwargs["deletion_dict"]

        modification_dict = kwargs["modification_dict"]

        # point 1

        try:

            ref_master = github.get(

                "repos/"

                + app.config["PERSISTENCE_CONFIG"]["REPOSITORY_OWNER"] + "/"

                + self.repository

                + "/git/refs/heads/master",

                hooks=dict(response=log_api_rate)

            )

            #TODO: vérifier encoding - logger.debug(str(ref_master))

        except GitHubError as ghe:

            logger.error("GitHubError trying to get the reference "

                         + "to the master branch")

            logger.error(

                "Endpoint: "

                + "repos/"

                + app.config["PERSISTENCE_CONFIG"]["REPOSITORY_OWNER"] + "/"

                + self.repository

                + "/git/refs/heads/master"

            )

            logger.error(ghe.response.text)

        # point 2

        try:

            last_commit_master = github.get(

                "repos/"

                + app.config["PERSISTENCE_CONFIG"]["REPOSITORY_OWNER"] + "/"

                + self.repository

                + "/git/commits/"

                + ref_master["object"]["sha"],

                hooks=dict(response=log_api_rate)

            )

            #TODO: vérifier encoding - logger.debug(str(last_commit_master))

        except GitHubError as ghe:

            logger.error("GitHubError trying to get the commit associated "

                         + "to the latest reference to the master branch")

            logger.error(ghe.response.text)

        # Point 3

        try:

            last_commit_tree = github.get(

                "repos/"

                + app.config["PERSISTENCE_CONFIG"]["REPOSITORY_OWNER"] + "/"

                + self.repository

                + "/git/trees/"

                + last_commit_master["tree"]["sha"]

                + "?recursive=1",

                hooks=dict(response=log_api_rate)

            )

            #TODO: vérifier encoding - logger.debug(str(last_commit_tree))

        except GitHubError as ghe:

            logger.error("GitHubError trying to get the tree from the commit "

                         + "associated to the latest reference to the master "

                         + "branch")

            logger.error(ghe.response.text)

        # Point 4

        new_tree_data = {"tree": []}

        # First we loop over the existing elements to spot which are modified

        # and which are untouched and create new blobs when needed

        for element in last_commit_tree["tree"]:

            if element["type"] == "blob":

                # test if element is in deleted categories, if it is,

                # no point doing anything, the file won't be in the new tree

                if not(

                    element["path"] in [

                        (app.config["PERSISTENCE_CONFIG"]

                                   ["CATEGORIES_PATH"] + cat_name)

                        for cat_name in deletion_dict.keys()

                    ]

                ):

                    # the element is either modified or untouched so in both

                    # case we'll need a blob sha

                    blob_sha = ""

                    # test if element is in modified categories

                    if (

                        element["path"] in [

                            (app.config["PERSISTENCE_CONFIG"]

                                       ["CATEGORIES_PATH"] + cat_name)

                            for cat_name in modification_dict.keys()

                        ]

                    ):

                        # find element in modified categories

                        for (cat_name, cat_content) \

                                in modification_dict.items():

                            if element["path"] == (

                                app.config["PERSISTENCE_CONFIG"]

                                          ["CATEGORIES_PATH"] + cat_name

                            ):

                                # 4-1 for modified files, creating a new blob

                                new_blob_data = {

                                    "content": cat_content,

                                    "encoding": "utf-8"

                                }

                                try:

                                    new_blob = github.post(

                                        "repos/"

                                        + app.config["PERSISTENCE_CONFIG"]

                                                    ["REPOSITORY_OWNER"] + "/"

                                        + self.repository

                                        + "/git/blobs",

                                        data=new_blob_data,

                                        hooks=dict(response=log_api_rate)

                                    )

                                    blob_sha = new_blob["sha"]

                                    break

                                except GitHubError as ghe:

                                    logger.error(

                                        "GitHubError trying to post a new"

                                        + "blob with following data: "

                                        + str(new_blob_data)

                                    )

                                    logger.error(ghe.response.text)

                                logger.debug(str(

                                    github.get("rate_limit")["resources"]

                                ))

                    # this means element is an untouched file so we just get

                    # its sha

                    else:

                        blob_sha = element["sha"]

                    new_tree_data["tree"].append({"path": element["path"],

                                                  "mode": element["mode"],

                                                  "type": "blob",

                                                  "sha": blob_sha})

        #TODO: vérifier encoding - logger.debug(str(new_tree_data["tree"]))

        # Now we loop over modified categories to find the ones that don't

        # exist yet in the last commit tree in order to create blobs for them

        for (cat_name, cat_content) in modification_dict.items():

            logger.debug(app.config["PERSISTENCE_CONFIG"]

                                   ["CATEGORIES_PATH"]

                         + cat_name

                         + " should not be in "

                         + str([elt["path"] for

                                elt in last_commit_tree["tree"]]))

            if (app.config["PERSISTENCE_CONFIG"]

                          ["CATEGORIES_PATH"] + cat_name not in

                    [elt["path"] for elt in last_commit_tree["tree"]]):

                # 4-1 for added files, creating a new blob

                new_blob_data = {"content": cat_content,

                                 "encoding": "utf-8"}

                try:

                    new_blob = github.post(

                        "repos/"

                        + app.config["PERSISTENCE_CONFIG"]

                                    ["REPOSITORY_OWNER"] + "/"

                        + self.repository

                        + "/git/blobs",

                        data=new_blob_data,

                        hooks=dict(response=log_api_rate)

                    )

                except GitHubError as ghe:

                    logger.error(

                        "GitHubError trying to post a new blob with following"

                        + "data: "

                        + str(new_blob_data)

                    )

                    logger.error(ghe.response.text)

                new_tree_data["tree"].append({

                    "path": app.config["PERSISTENCE_CONFIG"]

                                      ["CATEGORIES_PATH"] + cat_name,

                    "mode": "100644",

                    "type": "blob",

                    "sha": new_blob["sha"]

                })

        #TODO: vérifier encoding - logger.debug(str(new_tree_data))

        # Finally, we post the new tree

        try:

            new_tree_response = github.post(

                "repos/"

                + app.config["PERSISTENCE_CONFIG"]["REPOSITORY_OWNER"] + "/"

                + self.repository

                + "/git/trees",

                data=new_tree_data

            ),

            hooks=dict(response=log_api_rate)

        except GitHubError as ghe:

            logger.error(

                "GitHubError trying to post a new tree with following data: "

                + str(new_tree_data)

            )

            logger.error(ghe.response.text)

        #TODO: vérifier encoding - logger.debug(str(new_tree_response[0]["sha"]))