CourseFileSystem

# -- IMPORTS
#from User import User
from CourseError import CourseError
from PermissionError import PermissionError
import shutil
import json
import os

# -- CLASS
# TODO Verify users
# TODO Validate parameters of methods
class CourseFileSystem():

    DEFAULT_COURSES_FOLDER = "Courses"

    def __init__(self, user):
        #if not User.is_user(user):
            # -- throw error, not valid user
        #    return 1
        self._user = user

        # Permission
        from PermissionFileSystem import PermissionFileSystem
        self.permission_fs = PermissionFileSystem(self)

        """
        TESTING EXAMPLES
        """

        #print(self.add_course("Network Course"))

        #print(self.add_lesson("ciao", "Network  Course"))

        #print(self.permission_fs.create_permission_file(True))
        print(self.is_valid_course("ciao"))
        #print(self.permission_fs.course_exists_by_name("Ciao"))

    def is_valid_course(self, course_name):
        # Controllo che il corso esista nella directory
        if not course_name in os.listdir(CourseFileSystem.DEFAULT_COURSES_FOLDER):
            return False

        course_id = self.permission_fs.get_id_by_course_name(course_name)
        if PermissionError.is_permission_error(course_id):
            return False

        return True

    # TODO: PermissionFS implementation
    def is_valid_lesson(self, course_name, lesson_name):
        if self.is_valid_course(course_name):
            if lesson_name in os.listdir(
                os.path.join(CourseFileSystem.DEFAULT_COURSES_FOLDER, course_name
            )):
                return True
        return False

    # TODO: PermissionFS implementation
    def _get_available_courses(self, dir="Courses"):
        courses = dict()
        for entry in os.scandir(dir):
            if entry.is_dir():
                courses[entry.name] = self._get_available_lessons(entry.name)
        return courses

    # Backbone
    # TODO: PermissionFS implementation
    def _get_available_lesson(self, course_name, lesson_name):
        res = []
        if self.is_valid_lesson(course_name, lesson_name):
            for entry in os.scandir(
                os.path.join(CourseFileSystem.DEFAULT_COURSES_FOLDER, course_name, lesson_name)
            ):
                if entry.is_file():
                    res.append(entry.name)
        return res

    # Backbone
    # TODO: PermissionFS implementation
    def _get_available_lessons(self, course_name):
        res = dict()
        if self.is_valid_course(course_name):
            for entry in os.scandir(
                os.path.join(CourseFileSystem.DEFAULT_COURSES_FOLDER, course_name)
            ):
                res[entry.name] = self._get_available_lesson(course_name, entry.name)
        return res

    # TODO: Add try-except in case of error
    # This method uses the default courses folder var of the class
    def create_course_folder(self):
        if not os.path.isdir(CourseFileSystem.DEFAULT_COURSES_FOLDER):
            os.makedirs(CourseFileSystem.DEFAULT_COURSES_FOLDER)
            return True
        return False

    # Backbone, doing stuff on the real file system
    def add_course(self, course_name):

        self.create_course_folder()

        # If it already exists you cannot overwrite it
        if self.is_valid_course(course_name):
            return False # Reminder: this should throw an exception, or not (?)

        # Wait, seems like there is a course with that name in the permissions
        if self.permission_fs.course_exists_by_name(course_name):
            return False # Reminder: this should definitely throw an exception

        try:
            os.makedirs(
                os.path.join(
                    CourseFileSystem.DEFAULT_COURSES_FOLDER,
                    course_name
                )
            )
        except OSError:
            return False # Well, could this be another future exception?
        # Just creating the course entry into the permissions file
        self.permission_fs.add_course(course_name)

        return True

    # Backbone, doing stuff on the real file system
    def remove_course(self, course_id):
        if not isinstance(course_id, str):
            return False

        course_name = self.permission_fs.get_name_by_course_id(course_id)
        if not course_name:
            return False # Throw Exception, not valid course in permissions

        if not self.is_valid_course(course_name):
            return False # Throw Exception, course deleted from directory

        # Alright, removing the course from the directory
        try:
            shutil.rmtree(
                os.path.join(
                    CourseFileSystem.DEFAULT_COURSES_FOLDER,
                    course_name
                ),
                ignore_errors=True
            )
        except:
            return False # Exception, couldn't remove the course folder

        # Alright, removing the course from the permissions
        if not self.permission_fs.remove_course(course_id):
            return False # Exception, couldn't remove the course permission

        return True

    def add_lesson(self, lesson_name, course_name):
        self.create_course_folder()

        # If it already exists you cannot overwrite it
        if not self.is_valid_course(course_name):
            return CourseError("valid course", "Esiste già un corso con questo nome")

        if not self.permission_fs.add_lesson(lesson_name, course_name):
            # TODO: Allo stato attuale non si può capire se la lezione esiste già
            # a livello filesystem o a livello permessi. Da implementare.
            return CourseError("valid lesson", "Esiste già una lezione con questo nome")
        return True


    def remove_lesson(self, lesson_id):
        self.create_course_folder()

        # TODO: Remove lesson from filesystem

        if not self.permission_fs.remove_lesson(lesson_id):
            return False
        return True

    @staticmethod
    def is_course_file_system(var):
        if isinstance(var, CourseFileSystem):
            return True
        return False

    # TODO
    def __str__(self):
        pass