# -*- coding: utf-8 -*-

from pyload.Api import LinkStatus, DownloadStatus as DS
from pyload.utils import to_list, has_method, uniqify
from pyload.utils.fs import exists, remove, fs_encode
from Base import Base, Retry


class Package:
    """ Container that indicates that a new package should be created """

    def __init__(self, name=None, links=None):
        self.name = name
        self.links = []

        if links:
            self.addLinks(links)

        # nested packages
        self.packs = []

    def addLinks(self, links):
        """ Add one or multiple links to the package

        :param links: One or list of urls or :class:`LinkStatus`
        """
        links = to_list(links)
        for link in links:
            if not isinstance(link, LinkStatus):
                link = LinkStatus(link, link, -1, DS.Queued)

            self.links.append(link)

    def addPackage(self, pack):
        self.packs.append(pack)

    def getURLs(self):
        return [link.url for link in self.links]

    def getAllURLs(self):
        urls = self.getURLs()
        for p in self.packs:
            urls.extend(p.getAllURLs())
        return urls

    # same name and urls is enough to be equal for packages
    def __eq__(self, other):
        return self.name == other.name and self.links == other.links

    def __repr__(self):
        return u"<CrypterPackage name=%s, links=[%s], packs=%s" % (self.name, ",".join(str(l) for l in self.links),
                                                                   self.packs)

    def __hash__(self):
        return hash(self.name) ^ hash(frozenset(self.links)) ^ hash(self.name)


class PyFileMockup:
    """ Legacy class needed by old crypter plugins """

    def __init__(self, url, pack):
        self.url = url
        self.name = url
        self._package = None
        self.packageid = pack.id if pack else -1

    def package(self):
        return self._package


class Crypter(Base):
    """
    Base class for (de)crypter plugins. Overwrite decrypt* methods.

    How to use decrypt* methods:

    You have to overwrite at least one method of decryptURL, decryptURLs, decryptFile.

    After decrypting and generating urls/packages you have to return the result.
    Valid return Data is:

    :class:`Package` instance Crypter.Package
        A **new** package will be created with the name and the urls of the object.

    List of urls and `Package` instances
        All urls in the list will be added to the **current** package. For each `Package`\
        instance a new package will be created.

    """

    #: Prefix to annotate that the submited string for decrypting is indeed file content
    CONTENT_PREFIX = "filecontent:"

    #: Optional name of an account plugin that should be used, but does not guarantee that one is available
    USE_ACCOUNT = None

    #: When True this crypter will not be decrypted directly and queued one by one.
    # Needed for crypter that can't run in parallel or need to wait between decryption.
    QUEUE_DECRYPT = False

    @classmethod
    def decrypt(cls, core, url_or_urls, password=None):
        """Static method to decrypt urls or content. Can be used by other plugins.
        To decrypt file content prefix the string with ``CONTENT_PREFIX `` as seen above.

        :param core: pyLoad `Core`, needed in decrypt context
        :param url_or_urls: List of urls or single url/ file content
        :param password: optional password used for decrypting

        :raises Exception: No decryption errors are cascaded
        :return: List of decrypted urls, all package info removed
        """
        urls = to_list(url_or_urls)
        p = cls(core, password)
        try:
            result = p._decrypt(urls)
        finally:
            p.clean()

        ret = []

        for url_or_pack in result:
            if isinstance(url_or_pack, Package): #package
                ret.extend(url_or_pack.getAllURLs())
            else: # single url
                ret.append(url_or_pack)
                # eliminate duplicates
        return uniqify(ret)

    # TODO: pass user to crypter
    # TODO: crypter could not only know url, but also the name and size
    def __init__(self, core, password=None):
        Base.__init__(self, core)

        self.req = None
        # load account if set
        if self.USE_ACCOUNT:
            self.account = self.core.accountManager.selectAccount(self.USE_ACCOUNT, self.user)
            if self.account:
                self.req = self.account.getAccountRequest()

        if self.req is None:
            self.req = core.requestFactory.getRequest()

        #: Password supplied by user
        self.password = password

        # For old style decrypter, do not use these!
        self.packages = []
        self.urls = []
        self.pyfile = None

        self.init()

    def init(self):
        """More init stuff if needed"""

    def setup(self):
        """Called everytime before decrypting. A Crypter plugin will be most likely used for several jobs."""

    def decryptURL(self, url):
        """Decrypt a single url

        :param url: url to decrypt
        :return: See :class:`Crypter` Documentation
        """
        if url.startswith("http"): # basic method to redirect
            return self.decryptFile(self.load(url))
        else:
            self.fail(_("Not existing file or unsupported protocol"))

    def decryptURLs(self, urls):
        """Decrypt a bunch of urls

        :param urls: list of urls
        :return: See :class:`Crypter` Documentation
        """
        raise NotImplementedError

    def decryptFile(self, content):
        """Decrypt file content

        :param content: content to decrypt as string
        :return: See :class:`Crypter` Documentation
        """
        raise NotImplementedError

    def _decrypt(self, urls):
        """Internal method to select decrypting method

        :param urls: List of urls/content
        :return:
        """
        cls = self.__class__

        # separate local and remote files
        content, urls = self.getLocalContent(urls)
        result = []

        if urls and has_method(cls, "decrypt"):
            self.logDebug("Deprecated .decrypt() method in Crypter plugin")
            result = []
            for url in urls:
                self.pyfile = PyFileMockup(url)
                self.setup()
                self.decrypt(self.pyfile)
                result.extend(self.convertPackages())
        elif urls:
            method = True
            try:
                self.setup()
                result = to_list(self.decryptURLs(urls))
            except NotImplementedError:
                method = False

            # this will raise error if not implemented
            if not method:
                for url in urls:
                    self.setup()
                    result.extend(to_list(self.decryptURL(url)))

        for f, c in content:
            self.setup()
            result.extend(to_list(self.decryptFile(c)))
            try:
                if f.startswith("tmp_"): remove(f)
            except IOError:
                self.logWarning(_("Could not remove file '%s'") % f)
                self.core.print_exc()

        return result

    def getLocalContent(self, urls):
        """Load files from disk and separate to file content and url list

        :param urls:
        :return: list of (filename, content), remote urls
        """
        content = []
        # do nothing if no decryptFile method
        if hasattr(self.__class__, "decryptFile"):
            remote = []
            for url in urls:
                path = None
                if url.startswith("http"): # skip urls directly
                    pass
                elif url.startswith(self.CONTENT_PREFIX):
                    path = url
                elif exists(url):
                    path = url
                elif exists(self.core.path(url)):
                    path = self.core.path(url)

                if path:
                    try:
                        if path.startswith(self.CONTENT_PREFIX):
                            content.append(("", path[len(self.CONTENT_PREFIX)]))
                        else:
                            f = open(fs_encode(path), "rb")
                            content.append((f.name, f.read()))
                            f.close()
                    except IOError, e:
                        self.logError("IOError", e)
                else:
                    remote.append(url)

            #swap filtered url list
            urls = remote

        return content, urls

    def retry(self):
        """ Retry decrypting, will only work once. Somewhat deprecated method, should be avoided. """
        raise Retry()

    def convertPackages(self):
        """ Deprecated """
        self.logDebug("Deprecated method .convertPackages()")
        res = [Package(name, urls) for name, urls in self.packages]
        res.extend(self.urls)
        return res

    def clean(self):
        if hasattr(self, "req"):
            self.req.close()
            del self.req