"""
Gestion de l'archivage des justificatifs

Ecrit par Matthias HARTMANN
"""
import os
from shutil import rmtree

from app.models import Identite
from app.scodoc.sco_archives import BaseArchiver
from app.scodoc.sco_exceptions import ScoValueError


class JustificatifArchiver(BaseArchiver):
    """

    TOTALK:
        - oid -> etudid
        - archive_id -> date de création de l'archive (une archive par dépot de document)

    justificatif
        └── <dept_id>
            └── <etudid/oid>
                └── <archive_id>
                    ├── [_description.txt]
                    └── [<filename.ext>]

    """

    def __init__(self):
        BaseArchiver.__init__(self, archive_type="justificatifs")

    def save_justificatif(
        self,
        etudid: int,
        filename: str,
        data: bytes or str,
        archive_name: str = None,
        description: str = "",
    ) -> str:
        """
        Ajoute un fichier dans une archive "justificatif" pour l'etudid donné
        Retourne l'archive_name utilisé
        """
        self._set_dept(etudid)
        if archive_name is None:
            archive_id: str = self.create_obj_archive(
                oid=etudid, description=description
            )
        else:
            archive_id: str = self.get_id_from_name(etudid, archive_name)

        fname: str = self.store(archive_id, filename, data)

        return self.get_archive_name(archive_id), fname

    def delete_justificatif(self, etudid: int, archive_name: str, filename: str = None):
        """
        Supprime une archive ou un fichier particulier de l'archivage de l'étudiant donné
        """
        self._set_dept(etudid)
        if str(etudid) not in self.list_oids():
            raise ValueError(f"Aucune archive pour etudid[{etudid}]")

        archive_id = self.get_id_from_name(etudid, archive_name)

        if filename is not None:
            if filename not in self.list_archive(archive_id):
                raise ValueError(
                    f"filename {filename} inconnu dans l'archive archive_id[{archive_id}] -> etudid[{etudid}]"
                )

            path: str = os.path.join(self.get_obj_dir(etudid), archive_id, filename)

            if os.path.isfile(path):
                os.remove(path)

        else:
            self.delete_archive(
                os.path.join(
                    self.get_obj_dir(etudid),
                    archive_id,
                )
            )

    def list_justificatifs(self, archive_name: str, etudid: int) -> list[str]:
        """
        Retourne la liste des noms de fichiers dans l'archive donnée
        """
        self._set_dept(etudid)
        filenames: list[str] = []
        archive_id = self.get_id_from_name(etudid, archive_name)

        filenames = self.list_archive(archive_id)
        return filenames

    def get_justificatif_file(self, archive_name: str, etudid: int, filename: str):
        """
        Retourne une réponse de téléchargement de fichier si le fichier existe
        """
        self._set_dept(etudid)
        archive_id: str = self.get_id_from_name(etudid, archive_name)
        if filename in self.list_archive(archive_id):
            return self.get_archived_file(etudid, archive_name, filename)
        raise ScoValueError(
            f"Fichier {filename} introuvable dans l'archive {archive_name}"
        )

    def _set_dept(self, etudid: int):
        """
        Mets à jour le dept_id de l'archiver en fonction du département de l'étudiant
        """
        etud: Identite = Identite.query.filter_by(id=etudid).first()
        self.set_dept_id(etud.dept_id)

    def remove_dept_archive(self, dept_id: int = None):
        """
        Supprime toutes les archives d'un département (ou de tous les départements)
        """
        self.set_dept_id(1)
        self.initialize()

        if dept_id is None:
            rmtree(self.root, ignore_errors=True)
        else:
            rmtree(os.path.join(self.root, str(dept_id)), ignore_errors=True)