# coding:utf-8

import requests
from requests.auth import HTTPBasicAuth


class PiexelErrors(Exception):
    pass


class InvalidToken(PiexelErrors):
    pass


class ParameterError(PiexelErrors):
    pass


class InvalidResponse(PiexelErrors):
    pass


class Piexel:
    def __init__(self, domain, app='', token='', endpoint='/api/'):
        # self.app = app
        # self.token = token
        self.auth = HTTPBasicAuth(app, token)
        self.domain = domain
        self.endpoint = endpoint

    def _get_response(self, controller, fields, request_type='get', data=None):
        """
        Build response
        :param controller: controller à utiliser
        :param fields: champ à passer
        """
        url = self.domain + self.endpoint + controller
        if request_type == 'get':
            response = requests.get(url, auth=self.auth, params=fields)
        elif request_type == 'post':
            if data is not None:
                response = requests.post(url, auth=self.auth, params=fields, json=data)
            else:
                response = requests.post(url, auth=self.auth, params=fields)
        elif request_type == 'put':
            if data is not None:
                response = requests.put(url, auth=self.auth, params=fields, json=data)
            else:
                response = requests.put(url, auth=self.auth, params=fields)
        elif request_type == 'delete':
            response = requests.delete(url, auth=self.auth, data=fields)
        response.encoding = 'utf-8'
        code = response.status_code
        try:
            data = response.json()
        except:
            raise InvalidResponse(url, fields, response.text)
        if code == 403:  # FORBIDDEN
            raise InvalidToken(data['message'])
        elif code == 400:
            print('error:', response.text)
            raise ParameterError(data['message'])
        return data

    def _get_request(self, allowed, mandatory=[], **params):
        """
        Créé la requète
        """
        fields = {}
        for key, val in params.items():
            if key in allowed:
                fields[key] = val
        for m in mandatory:
            if m not in fields.keys():
                raise ParameterError('The parameter ' + m + ' is required.')
        return fields

    def get_films(self, **params):
        """
        Récupère les films
        :param params: paramètres à passer
        """
        fields = self._get_request(['id', 'title', 'title_vo', 'imdb_id', 'limit', 'first', 'first', 'files'], [],
                                   **params)
        return self._get_response('films', fields)

    def get_series(self, **params):
        """
        Récupère les séries
        :param params: paramètres à passer
        """
        fields = self._get_request(['id', 'title', 'imdb_id', 'limit', 'first', 'first', 'episodes'], [], **params)
        return self._get_response('series', fields)

    def get_episodes(self, **params):
        """
        Récupère les épisodes
        :param params: paramètres à passer
        """
        fields = self._get_request(['id', 'serie_id', 'title', 'imdb_id', 'limit', 'first', 'first', 'episodes'], [],
                                   **params)
        return self._get_response('episodes', fields)

    def get_tokens(self, **params):
        """
        Récupère les tokens
        :param params: paramètres à passer
        """
        fields = self._get_request([], [], **params)
        return self._get_response('indexer/tokens', fields)

    def get_folders(self, **params):
        """
        Récupère les dossiers de recherche
        :param params: paramètres à passer
        """
        fields = self._get_request([], [], **params)
        return self._get_response('indexer/folders', fields)

    def get_paths(self, **params):
        """
        Récupère les règles d'indexage
        :param params: paramètres à passer
        """
        fields = self._get_request([], [], **params)
        return self._get_response('indexer/paths', fields)

    def get_files(self, **params):
        """
        Récupère les fichiers
        :param params: paramètres à passer
        """
        fields = self._get_request(['id', 'path', 'name', 'limit', 'first', 'filable', 'like'], [], **params)
        return self._get_response('files', fields)

    def get_subtitles(self, **params):
        """
        Récupère les sous-titres
        :param params: paramètres à passer
        """
        fields = self._get_request(['id', 'path', 'name', 'limit', 'first', 'subtitlable'], [], **params)
        return self._get_response('subtitles', fields)

    def get_broken(self, **params):
        """
        Récupère les liens morts
        :param params: paramètres à passer
        """
        fields = self._get_request(['id', 'type'], [], **params)
        return self._get_response('broken', fields)

    def post_film(self, **params):
        """
        Ajoute un film
        :param params: paramètres à passer
        """
        fields = self._get_request(['title', 'year'], ['title'], **params)
        return self._get_response('film', fields, 'post')

    def post_file(self, **params):
        """
        Ajoute un fichier
        :param params: paramètres à passer
        """
        fields = self._get_request(['path', 'name', 'type', 'type_id'], ['path', 'name', 'type', 'type_id'], **params)
        return self._get_response('file', fields, 'post')

    def post_file_language(self, file, **params):
        """
        Ajoute une langue à un fichier
        :param params: paramètres à passer
        """
        fields = self._get_request(['value'], ['value'], **params)
        return self._get_response('languages/' + str(file) + '/attach', fields, 'post')

    def post_file_subtitle(self, file, **params):
        """
        Ajoute une langue de sous-titre à un fichier
        :param params: paramètres à passer
        """
        fields = self._get_request(['value'], ['value'], **params)
        return self._get_response('subtitle-languages/' + str(file) + '/attach', fields, 'post')

    def post_file_qualities(self, file, **params):
        """
        Ajoute une qualitée à un fichier
        :param params: paramètres à passer
        """
        fields = self._get_request(['value'], ['value'], **params)
        return self._get_response('qualities/' + str(file) + '/attach', fields, 'post')

    def clear_file_language(self, file):
        """
        Supprime toute qualité d'un fichier
        """
        return self._get_response('languages/' + str(file) + '/detach-all', {}, 'post')

    def clear_file_subtitle(self, file):
        """
        Supprime toute qualité d'un fichier
        """
        return self._get_response('subtitle-languages/' + str(file) + '/detach-all', {}, 'post')

    def clear_file_qualities(self, file):
        """
        Supprime toute qualité d'un fichier
        """
        return self._get_response('qualities/' + str(file) + '/detach-all', {}, 'post')

    def post_subtitle(self, **params):
        """
        Ajoute un sous-titre
        :param params: paramètres à passer
        """
        fields = self._get_request(['path', 'name', 'type', 'type_id', 'quality', 'lang'],
                                   ['path', 'name', 'type', 'type_id'], **params)
        return self._get_response('subtitles', fields, 'post')

    def post_serie(self, **params):
        """
        Ajoute une série
        :param params: paramètres à passer
        """
        fields = self._get_request(['title'], ['title'], **params)
        return self._get_response('serie', fields, 'post')

    def post_episode(self, **params):
        """
        Ajoute un épisode d'une série
        :param params: paramètres à passer
        """
        fields = self._get_request(['season', 'episode', 'serie_id'], ['season', 'episode', 'serie_id'], **params)
        return self._get_response('episode', fields, 'post')

    def put_file(self, id, **params):
        """
        Edite un fichier
        :param params: paramètres à passer
        """
        fields = self._get_request(['path', 'name', 'filable_type', 'filable_id', 'quality', 'lang', 'subtitles'], [],
                                   **params)
        return self._get_response('file/' + str(id), fields, 'put')

    def delete_file(self, id, **params):
        """
        Supprime un fichier
        :param params: paramètres à passer
        """
        fields = self._get_request([], [], **params)
        return self._get_response('file/' + str(id), fields, 'delete')

    def get_index(self, **params):
        """
        Récupère les fichiers indexés
        :param params: paramètres à passer
        """
        fields = self._get_request(['id', 'path', 'name', 'limit', 'first', 'is_referenced', 'like'], [], **params)
        return self._get_response('index', fields)

    def post_index(self, params):
        """
        Ajoute un fichier
        :param params: paramètres à passer
        """
        return self._get_response('index', {}, 'post', params)

    def delete_index(self, id):
        """
        Supprime un fichier indéxé
        :param id: id du fichier à supprimer
        """
        return self._get_response('index/' + str(id), {}, 'delete')

    def put_audio_codec(self, id, codec):
        """
        Ajoute le codec audio
        :param id: identifiant du fichier
        :param codec: nom du codec
        """
        fields = self._get_request(['name', "is_video"], ["name"], name=codec, is_video=0)
        return self._get_response('file/' + str(id) + '/codec', fields, 'put')

    def put_video_codec(self, id, codec):
        """
        Ajoute le codec video
        :param id: identifiant du fichier
        :param codec: nom du codec
        """
        fields = self._get_request(['name', "is_video"], ["name"], name=codec, is_video=1)
        return self._get_response('file/' + str(id) + '/codec', fields, 'put')

    def put_audio_container(self, id, container):
        """
        Ajoute le container audio
        :param id: identifiant du fichier
        :param container: nom du container
        """
        fields = self._get_request(['name', "is_video"], ["name"], name=container, is_video=0)
        return self._get_response('file/' + str(id) + '/container', fields, 'put')

    def put_video_container(self, id, container):
        """
        Ajoute le container video
        :param id: identifiant du fichier
        :param container: nom du container
        """
        fields = self._get_request(['name', "is_video"], ["name"], name=container, is_video=1)
        return self._get_response('file/' + str(id) + '/container', fields, 'put')

    def delete_audio_codec(self, file_id):
        """
        Supprime le codec audio
        :param file_id: identifiant du fichier
        """
        fields = self._get_request(["is_video"], ["is_video"], is_video=0)
        return self._get_response('file/' + str(file_id) + "/codec", fields, 'delete')

    def delete_video_codec(self, file_id):
        """
        Supprime le codec video
        :param file_id: identifiant du fichier
        """
        fields = self._get_request(["is_video"], ["is_video"], is_video=1)
        return self._get_response('file/' + str(file_id) + "/codec", fields, 'delete')

    def delete_audio_container(self, file_id):
        """
        Supprime le container audio
        :param file_id: identifiant du fichier
        """
        fields = self._get_request(["is_video"], ["is_video"], is_video=0)
        return self._get_response('file/' + str(file_id) + "/container", fields, 'delete')

    def delete_video_container(self, file_id):
        """
        Supprime le container video
        :param file_id: identifiant du fichier
        """
        fields = self._get_request(["is_video"], ["is_video"], is_video=1)
        return self._get_response('file/' + str(file_id) + "/container", fields, 'delete')